diff --git a/.gitignore b/.gitignore
index c2f1b514..881a2246 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,9 @@
 # IDE Generated files
 *.suo
+.vs/
+CMakeSettings.json
+.idea
+cmake-build-debug/
 
 # Compiled Object files
 *.slo
@@ -56,3 +60,5 @@ SetBuildVars_X64.bat
 !src/openvr_plugin/resources/*.obj
 
 *.kdev4
+
+.DS_Store
diff --git a/.gitmodules b/.gitmodules
index cf28d352..829d4f3d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,6 +1,3 @@
-[submodule "thirdparty/libusb"]
-	path = thirdparty/libusb
-	url = https://github.com/libusb/libusb.git
 [submodule "thirdparty/hidapi"]
 	path = thirdparty/hidapi
 	url = https://github.com/signal11/hidapi.git
@@ -18,24 +15,15 @@
 [submodule "thirdparty/protobuf"]
 	path = thirdparty/protobuf
 	url = https://github.com/google/protobuf.git
-[submodule "thirdparty/imgui"]
-	path = thirdparty/imgui
-	url = https://github.com/ocornut/imgui.git
 [submodule "thirdparty/stb"]
 	path = thirdparty/stb
 	url = https://github.com/nothings/stb.git
-[submodule "thirdparty/SDL2"]
-	path = thirdparty/SDL2
-	url = https://github.com/spurious/SDL-mirror.git
-[submodule "thirdparty/eigen"]
-	path = thirdparty/eigen
-	url = https://github.com/libigl/eigen.git
 [submodule "thirdparty/kalman"]
 	path = thirdparty/kalman
 	url = https://github.com/mherb/kalman.git
 [submodule "thirdparty/libstem_gamepad"]
 	path = thirdparty/libstem_gamepad
-	url = https://github.com/cboulay/libstem_gamepad.git
+	url = https://github.com/psmoveservice/libstem_gamepad.git
 [submodule "thirdparty/lockfreequeue"]
 	path = thirdparty/lockfreequeue
 	url = https://github.com/cameron314/readerwriterqueue.git
diff --git a/cmake/Environment.cmake b/cmake/Environment.cmake
index 8bd9311f..c14dc23e 100644
--- a/cmake/Environment.cmake
+++ b/cmake/Environment.cmake
@@ -43,21 +43,21 @@ endif()
 #links against static runtime, so we need our apps to link
 #against the static runtime too.
 #https://cmake.org/Wiki/CMake_FAQ#How_can_I_build_my_MSVC_application_with_a_static_runtime.3F
-IF(MSVC)
-    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
-    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+#IF(MSVC)
+#    SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+#    SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
 
-    set(CompilerFlags
-        CMAKE_CXX_FLAGS
-        CMAKE_CXX_FLAGS_DEBUG
-        CMAKE_CXX_FLAGS_RELEASE
-        CMAKE_C_FLAGS
-        CMAKE_C_FLAGS_DEBUG
-        CMAKE_C_FLAGS_RELEASE
-        )
-    foreach(CompilerFlag ${CompilerFlags})
-      string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
-    endforeach()
-ELSE()
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch")
-ENDIF(MSVC)
+#    set(CompilerFlags
+#        CMAKE_CXX_FLAGS
+#        CMAKE_CXX_FLAGS_DEBUG
+#        CMAKE_CXX_FLAGS_RELEASE
+#        CMAKE_C_FLAGS
+#        CMAKE_C_FLAGS_DEBUG
+#        CMAKE_C_FLAGS_RELEASE
+#        )
+#    foreach(CompilerFlag ${CompilerFlags})
+#      string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+#    endforeach()
+#ELSE()
+#    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch")
+#ENDIF(MSVC)
diff --git a/cmake/FindSDL2.cmake b/cmake/FindSDL2.cmake
deleted file mode 100644
index c04a1c23..00000000
--- a/cmake/FindSDL2.cmake
+++ /dev/null
@@ -1,163 +0,0 @@
-# Locate SDL2 library
-# This module defines
-# SDL2_LIBRARY, the name of the library to link against
-# SDL2_FOUND, if false, do not try to link to SDL2
-# SDL2_INCLUDE_DIR, where to find SDL.h
-#
-# This module responds to the the flag:
-# SDL2_BUILDING_LIBRARY
-# If this is defined, then no SDL2main will be linked in because
-# only applications need main().
-# Otherwise, it is assumed you are building an application and this
-# module will attempt to locate and set the the proper link flags
-# as part of the returned SDL2_LIBRARY variable.
-#
-# Don't forget to include SDLmain.h and SDLmain.m your project for the
-# OS X framework based version. (Other versions link to -lSDL2main which
-# this module will try to find on your behalf.) Also for OS X, this
-# module will automatically add the -framework Cocoa on your behalf.
-#
-#
-# Additional Note: If you see an empty SDL2_LIBRARY_TEMP in your configuration
-# and no SDL2_LIBRARY, it means CMake did not find your SDL2 library
-# (SDL2.dll, libsdl2.so, SDL2.framework, etc).
-# Set SDL2_LIBRARY_TEMP to point to your SDL2 library, and configure again.
-# Similarly, if you see an empty SDL2MAIN_LIBRARY, you should set this value
-# as appropriate. These values are used to generate the final SDL2_LIBRARY
-# variable, but when these values are unset, SDL2_LIBRARY does not get created.
-#
-#
-# $SDL2DIR is an environment variable that would
-# correspond to the ./configure --prefix=$SDL2DIR
-# used in building SDL2.
-# l.e.galup  9-20-02
-#
-# Modified by Eric Wing.
-# Added code to assist with automated building by using environmental variables
-# and providing a more controlled/consistent search behavior.
-# Added new modifications to recognize OS X frameworks and
-# additional Unix paths (FreeBSD, etc).
-# Also corrected the header search path to follow "proper" SDL guidelines.
-# Added a search for SDL2main which is needed by some platforms.
-# Added a search for threads which is needed by some platforms.
-# Added needed compile switches for MinGW.
-#
-# On OSX, this will prefer the Framework version (if found) over others.
-# People will have to manually change the cache values of
-# SDL2_LIBRARY to override this selection or set the CMake environment
-# CMAKE_INCLUDE_PATH to modify the search paths.
-#
-# Note that the header path has changed from SDL2/SDL.h to just SDL.h
-# This needed to change because "proper" SDL convention
-# is #include "SDL.h", not <SDL2/SDL.h>. This is done for portability
-# reasons because not all systems place things in SDL2/ (see FreeBSD).
-
-#=============================================================================
-# Copyright 2003-2009 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.)
-
-SET(SDL2_SEARCH_PATHS
-  ~/Library/Frameworks
-  /Library/Frameworks
-  /usr/local
-  /usr
-  /sw # Fink
-  /opt/local # DarwinPorts
-  /opt/csw # Blastwave
-  /opt
-)
-
-FIND_PATH(SDL2_INCLUDE_DIR SDL.h
-  HINTS
-  $ENV{SDL2DIR}
-  PATH_SUFFIXES include/SDL2 include
-  PATHS ${SDL2_SEARCH_PATHS}
-)
-
-FIND_LIBRARY(SDL2_LIBRARY_TEMP
-  NAMES SDL2
-  HINTS
-  $ENV{SDL2DIR}
-  PATH_SUFFIXES lib64 lib build/Release
-  PATHS ${SDL2_SEARCH_PATHS}
-)
-
-IF(NOT SDL2_BUILDING_LIBRARY)
-  IF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-    # Non-OS X framework versions expect you to also dynamically link to
-    # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
-    # seem to provide SDL2main for compatibility even though they don't
-    # necessarily need it.
-    FIND_LIBRARY(SDL2MAIN_LIBRARY
-      NAMES SDL2main
-      HINTS
-      $ENV{SDL2DIR}
-      PATH_SUFFIXES lib64 lib build/Release
-      PATHS ${SDL2_SEARCH_PATHS}
-    )
-  ENDIF(NOT ${SDL2_INCLUDE_DIR} MATCHES ".framework")
-ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-# SDL2 may require threads on your system.
-# The Apple build may not need an explicit flag because one of the
-# frameworks may already provide it.
-# But for non-OSX systems, I will use the CMake Threads package.
-IF(NOT APPLE)
-  FIND_PACKAGE(Threads)
-ENDIF(NOT APPLE)
-
-# MinGW needs an additional library, mwindows
-# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -lmwindows
-# (Actually on second look, I think it only needs one of the m* libraries.)
-IF(MINGW)
-  SET(MINGW32_LIBRARY mingw32 CACHE STRING "mwindows for MinGW")
-ENDIF(MINGW)
-
-IF(SDL2_LIBRARY_TEMP)
-  # For SDL2main
-  IF(NOT SDL2_BUILDING_LIBRARY)
-    IF(SDL2MAIN_LIBRARY)
-      SET(SDL2_LIBRARY_TEMP ${SDL2MAIN_LIBRARY} ${SDL2_LIBRARY_TEMP})
-    ENDIF(SDL2MAIN_LIBRARY)
-  ENDIF(NOT SDL2_BUILDING_LIBRARY)
-
-  # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
-  # CMake doesn't display the -framework Cocoa string in the UI even
-  # though it actually is there if I modify a pre-used variable.
-  # I think it has something to do with the CACHE STRING.
-  # So I use a temporary variable until the end so I can set the
-  # "real" variable in one-shot.
-  IF(APPLE)
-    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} "-framework Cocoa")
-  ENDIF(APPLE)
-
-  # For threads, as mentioned Apple doesn't need this.
-  # In fact, there seems to be a problem if I used the Threads package
-  # and try using this line, so I'm just skipping it entirely for OS X.
-  IF(NOT APPLE)
-    SET(SDL2_LIBRARY_TEMP ${SDL2_LIBRARY_TEMP} ${CMAKE_THREAD_LIBS_INIT})
-  ENDIF(NOT APPLE)
-
-  # For MinGW library
-  IF(MINGW)
-    SET(SDL2_LIBRARY_TEMP ${MINGW32_LIBRARY} ${SDL2_LIBRARY_TEMP})
-  ENDIF(MINGW)
-
-  # Set the final string here so the GUI reflects the final state.
-  SET(SDL2_LIBRARY ${SDL2_LIBRARY_TEMP} CACHE STRING "Where the SDL2 Library can be found")
-  # Set the temp variable to INTERNAL so it is not seen in the CMake GUI
-  SET(SDL2_LIBRARY_TEMP "${SDL2_LIBRARY_TEMP}" CACHE INTERNAL "")
-ENDIF(SDL2_LIBRARY_TEMP)
-
-INCLUDE(FindPackageHandleStandardArgs)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2 REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR)
diff --git a/cmake/FindUSB1.cmake b/cmake/FindUSB1.cmake
index a4379598..00519f7f 100755
--- a/cmake/FindUSB1.cmake
+++ b/cmake/FindUSB1.cmake
@@ -21,79 +21,23 @@ IF (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
     set(LIBUSB_FOUND TRUE)
 
 ELSE (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-    set(LIBUSB_ROOT ${CMAKE_CURRENT_LIST_DIR}/../thirdparty/libusb)
-    # Because we want to use the static library,
-    # look locally only.
+    
     find_path(LIBUSB_INCLUDE_DIR
         NAMES
             libusb.h
-        PATHS 
-            ${LIBUSB_ROOT}/libusb
-            ${LIBUSB_ROOT}/libusb-1.0
+        HINTS 
             /usr/local/include
+		PATH_SUFFIXES
+			libusb-1.0
     )
-    # There are 4 platform-specific ways we might get the libraries.
-    # 1 - Windows MSVC, download the source, compile with MSVC
-    # 2 - Windows MSVC, download pre-compiled binaries <- Do not use; wrong CRT library
-    # 3 - Windows MinGW, download pre-compiled binaries
-    # 4 - OSX, download the source, build, but do not install
-    # 5 - OSX, homebrew OR download the source, build, and install
-    # Each of these puts the compiled library into a different folder
-    # and that is also architecture-specific.
-
-    set(LIBUSB_LIB_SEARCH_PATH_RELEASE ${LIBUSB_ROOT})
-    set(LIBUSB_LIB_SEARCH_PATH_DEBUG ${LIBUSB_ROOT})
-    IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-        IF(MINGW)
-            set(LIBUSB_PLATFORM_PREFIX MinGW)  # Does this get used?
-            #TODO: Add self-compiled folder for MinGW
-            IF (${CMAKE_C_SIZEOF_DATA_PTR} EQUAL 8)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_RELEASE
-                    ${LIBUSB_ROOT}/MinGW64/static)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_DEBUG
-                    ${LIBUSB_ROOT}/MinGW64/static)
-            ELSE()
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_RELEASE
-                    ${LIBUSB_ROOT}/MinGW32/static)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_DEBUG
-                    ${LIBUSB_ROOT}/MinGW32/static)
-            ENDIF()
-        ELSE() # MSVC?
-            set(LIBUSB_PLATFORM_PREFIX MS)  # Does this get used?
-            IF (${CMAKE_C_SIZEOF_DATA_PTR} EQUAL 8)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_RELEASE
-                    ${LIBUSB_ROOT}/x64/Release/lib)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_DEBUG
-                    ${LIBUSB_ROOT}/x64/Debug/lib)
-            ELSE()
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_RELEASE
-                    ${LIBUSB_ROOT}/Win32/Release/lib)
-                list(APPEND LIBUSB_LIB_SEARCH_PATH_DEBUG
-                    ${LIBUSB_ROOT}/Win32/Debug/lib)
-            ENDIF()
-        ENDIF()
-    ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-        list(APPEND LIBUSB_LIB_SEARCH_PATH_RELEASE
-                    ${LIBUSB_ROOT}/libusb/.libs
-                    /usr/local/lib)
-        list(APPEND LIBUSB_LIB_SEARCH_PATH_DEBUG
-                    ${LIBUSB_ROOT}/libusb/.libs
-                    /usr/local/lib)
-    ENDIF()
     
-    FIND_LIBRARY(LIBUSB_LIBRARY_RELEASE
-            NAMES libusb-1.0.a libusb-1.0.lib libusb-1.0 usb-1.0 usb
-            PATHS ${LIBUSB_LIB_SEARCH_PATH_RELEASE})
-    FIND_LIBRARY(LIBUSB_LIBRARY_DEBUG
+    FIND_LIBRARY(LIBUSB_LIBRARIES
             NAMES libusb-1.0.a libusb-1.0.lib libusb-1.0 usb-1.0 usb
-            PATHS ${LIBUSB_LIB_SEARCH_PATH_DEBUG})
-    SET(LIBUSB_LIBRARIES
-        debug ${LIBUSB_LIBRARY_DEBUG}
-        optimized ${LIBUSB_LIBRARY_RELEASE})
+            PATHS /usr/local/lib)
 
-  include(FindPackageHandleStandardArgs)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBUSB DEFAULT_MSG LIBUSB_LIBRARIES LIBUSB_INCLUDE_DIR)
+    include(FindPackageHandleStandardArgs)
+    FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBUSB DEFAULT_MSG LIBUSB_LIBRARIES LIBUSB_INCLUDE_DIR)
 
-  MARK_AS_ADVANCED(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
+    MARK_AS_ADVANCED(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
 
 ENDIF (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
\ No newline at end of file
diff --git a/cmake/ThirdParty.cmake b/cmake/ThirdParty.cmake
index d6b1a4fc..e49fa253 100644
--- a/cmake/ThirdParty.cmake
+++ b/cmake/ThirdParty.cmake
@@ -1,6 +1,4 @@
-# When not using MSVC, we recommend using system-wide libraries
-# (installed via homebrew on Mac or apt-get in Linux/Ubuntu)
-# In MSVC, we auto-download the source and make it an external_project
+# This is where we find thirdparty libraries and packages that are common to two or more targets.
 
 # Platform specific libraries
 SET(PLATFORM_LIBS)
@@ -32,115 +30,45 @@ ELSE() #Linux
     list(APPEND PLATFORM_LIBS rt)
 ENDIF()
 
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    find_package(PkgConfig REQUIRED)
+ENDIF()
+
 
 # Eigen3
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    # TODO: Convert this to ExternalProject_Add
-    # Can manually set EIGEN3_INCLUDE_DIR to "${ROOT_DIR}/thirdparty/eigen
-    MESSAGE(STATUS "Using Eigen3 in submodule")
-    LIST(APPEND CMAKE_MODULE_PATH "${ROOT_DIR}/thirdparty/eigen/cmake")
-    SET(ENV{EIGEN3_ROOT} "${ROOT_DIR}/thirdparty/eigen")
-    find_package(Eigen3 REQUIRED)
+    find_package(Eigen3 CONFIG REQUIRED)
 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     MESSAGE(STATUS "Using homebrew Eigen3")
     find_package(Eigen3 REQUIRED CONFIG PATHS /usr/local/opt/eigen/lib/cmake/eigen3)
 ELSE()
-    LIST(APPEND CMAKE_MODULE_PATH "${ROOT_DIR}/thirdparty/eigen/cmake")
-    SET(ENV{EIGEN3_ROOT} "/usr/include/eigen3")
-    find_package(Eigen3 REQUIRED)
+    find_package(Eigen3 REQUIRED)  # TODO: Test as CONFIG
 ENDIF()
+# Use with:
+# target_link_libraries(main PRIVATE Eigen3::Eigen)
 
 
 # OpenCV
 # Override by adding "-DOpenCV_DIR=C:\path\to\opencv\build" to your cmake command
 IF(NOT OpenCV_DIR)
-    IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-        ExternalProject_Add(opencv
-          PREFIX ${ROOT_DIR}/deps/opencv
-          GIT_REPOSITORY https://github.com/opencv/opencv.git
-          GIT_SHALLOW 1
-          GIT_TAG 3.1.0
-          CMAKE_GENERATOR ${gen}
-          CMAKE_ARGS
-            -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
-            -DCMAKE_INCLUDE_PATH=${ROOT_DIR}/deps/local/include
-            -DCMAKE_LIBRARY_PATH=${ROOT_DIR}/deps/local/lib
-            -DBUILD_WITH_STATIC_CRT:BOOL=ON
-            -DBUILD_SHARED_LIBS:BOOL=OFF
-            -DBUILD_DOCS:BOOL=OFF
-            -DBUILD_EXAMPLES:BOOL=OFF
-            -DBUILD_TESTS:BOOL=OFF
-            -DBUILD_PERF_TESTS:BOOL=OFF
-            #-DCMAKE_BUILD_TYPE:STRING=Release
-            -DWITH_FFMPEG:BOOL=OFF
-            -DWITH_OPENEXR:BOOL=OFF
-            -DWITH_JASPER:BOOL=OFF
-            -DWITH_TIFF:BOOL=OFF
-            -DWITH_IPP:BOOL=OFF
-            -DBUILD_opencv_apps:BOOL=OFF
-            -DBUILD_opencv_calib3d:BOOL=ON
-            -DBUILD_opencv_flann:BOOL=ON
-            -DBUILD_opencv_features2d:BOOL=ON
-            -DBUILD_opencv_objdetect:BOOL=ON
-            -DBUILD_opencv_photo:BOOL=ON
-            -DBUILD_opencv_ts:BOOL=OFF
-            -DBUILD_opencv_ml:BOOL=ON
-            -DBUILD_opencv_video:BOOL=ON
-            -DBUILD_opencv_java:BOOL=OFF
-            -DBUILD_opencv_python2:BOOL=OFF
-            -DBUILD_opencv_python3:BOOL=OFF
-            -DPYTHON2_LIBRARY:STRING=C:/Python27/libs/python27.lib
-            -DPYTHON3_LIBRARY:STRING=C:/Python35/libs/python35.lib
-          INSTALL_DIR ${ROOT_DIR}/deps/local/
-        )
-
-        add_definitions(-DHAS_OPENCV)
-
-        set(OpenCV_DIR ${ROOT_DIR}/deps/local)
-        set(OpenCV_INCLUDE_DIRS ${ROOT_DIR}/deps/local/include )
-        if (${CMAKE_C_SIZEOF_DATA_PTR} EQUAL 8)
-            set(OPENCV_LIBS_DIR ${ROOT_DIR}/deps/local/x64/vc14/staticlib)
-        else()
-            set(OPENCV_LIBS_DIR ${ROOT_DIR}/deps/local/x86/vc14/staticlib)
-        endif()
-
-        foreach(__CVLIB core calib3d features2d flann imgproc imgcodecs ml highgui objdetect video videoio)
-            set(OpenCV_${__CVLIB}_LIBRARY debug ${OPENCV_LIBS_DIR}/opencv_${__CVLIB}310d.lib optimized ${OPENCV_LIBS_DIR}/opencv_${__CVLIB}310.lib CACHE STRING "" FORCE)
-            set(OpenCV_LIBS ${OpenCV_LIBS} ${OpenCV_${__CVLIB}_LIBRARY})
-        endforeach(__CVLIB)    
-
-        foreach(__CVLIB libjpeg libpng libwebp zlib)
-            set(OpenCV_${__CVLIB}_LIBRARY debug ${OPENCV_LIBS_DIR}/${__CVLIB}d.lib optimized ${OPENCV_LIBS_DIR}/${__CVLIB}.lib CACHE STRING "" FORCE)
-            set(OpenCV_LIBS ${OpenCV_LIBS} ${OpenCV_${__CVLIB}_LIBRARY})
-        endforeach(__CVLIB)     
-
-        LIST(APPEND OpenCV_LIBS vfw32.lib)
-
-    ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
         # Location of homebrew opencv3's OpenCVConfig.cmake
         # Alternatively, can do `brew ln opencv3 --force`
         MESSAGE(STATUS "Using homebrew opencv3")
-        set(OpenCV_DIR "/usr/local/opt/opencv3/share/OpenCV")
+        set(OpenCV_DIR "/usr/local/opt/opencv@3/share/OpenCV")
     ELSE()
-        set(OpenCV_DIR “/usr/local/share/OpenCV”)
+        set(OpenCV_DIR “/usr/share/OpenCV”)
     ENDIF()#Windows or Darwin
+    LIST(APPEND CMAKE_MODULE_PATH ${OpenCV_DIR})
 ENDIF(NOT OpenCV_DIR)
-LIST(APPEND CMAKE_MODULE_PATH ${OpenCV_DIR})
-set(OpenCV_STATIC ON)
-IF(NOT(${CMAKE_SYSTEM_NAME} MATCHES "Windows"))
-    FIND_PACKAGE(OpenCV REQUIRED)
-ENDIF()
-
+# set(OpenCV_STATIC ON)
+FIND_PACKAGE(OpenCV REQUIRED)
+# Use with:
+#target_include_directories(main PRIVATE ${OpenCV_INCLUDE_DIRS})
+#target_link_libraries(main PRIVATE ${OpenCV_LIBS})
 
 # Boost
 IF(MSVC)
-    # Default location of pre-compiled Boost for Windows
-    # Override by adding "-DBOOST_ROOT=C:\path\to\boost\ -DBOOST_LIBRARYDIR=C:\path\to\boost\lib32-msvc-14.0\" to your cmake command
-    IF (NOT BOOST_ROOT)
-        SET(BOOST_ROOT "C:/local/boost_1_61_0/")
-        SET(BOOST_LIBRARYDIR "C:/local/boost_1_61_0/lib32-msvc-14.0/")
-    ENDIF()
-
     # Disable asio auto linking in date-time and regex
     add_definitions(-DBOOST_DATE_TIME_NO_LIB)
     add_definitions(-DBOOST_REGEX_NO_LIB)
@@ -149,24 +77,32 @@ IF(MSVC)
 ENDIF()
 SET(Boost_DEBUG                OFF) #Switch this and next to ON for help debugging Boost problems.
 SET(Boost_DETAILED_FAILURE_MSG OFF)
-set(Boost_USE_STATIC_LIBS      ON) # only find static libs
+set(Boost_USE_STATIC_LIBS      OFF) # only find static libs
 set(Boost_USE_MULTITHREADED    ON)
-set(Boost_USE_STATIC_RUNTIME   ON) #Not default. Because our app is linking against static runtime (see above).
-find_package(Boost REQUIRED)  # Future targets can specify components.
+set(Boost_USE_STATIC_RUNTIME   OFF) # Default = OFF
+find_package(Boost REQUIRED)
+# Because the version of Boost supported depends on cmake and can often lag behind,
+# we cannot use (e.g.) target_link_libraries(${target} Boost::filesystem)
+# So, use:
+# find_package(Boost REQUIRED COMPONENTS <list of components>)
+# target_include_directories(${target} ${Boost_INCLUDE_DIRS})
+# target_link_libraries(${target} ${Boost_LIBRARIES})
 
 
 # Protobuf
-IF(MSVC)
-    set(PROTOBUF_SRC_ROOT_FOLDER ${ROOT_DIR}/thirdparty/protobuf)
-    #PROTOBUF_IMPORT_DIRS ?
-    # Default location of protobuf for Windows
-    #SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "${ROOT_DIR}/thirdparty/protobuf")
-ENDIF(MSVC)
-set(PROTOBUF_ORIG_FIND_LIBRARY_SUFFIXES "${CMAKE_FIND_LIBRARY_SUFFIXES}") # Store original
-set(CMAKE_FIND_LIBRARY_SUFFIXES .a .lib .so .dylib .dll)  # Prefer static libs
-find_package(Protobuf REQUIRED)
-set(CMAKE_FIND_LIBRARY_SUFFIXES "${PROTOBUF_ORIG_FIND_LIBRARY_SUFFIXES}")  # Restore original
-include_directories(${CMAKE_BINARY_DIR}/psmoveprotocol)  # This is where the .proto files are compiled to.
+set(Protobuf_DEBUG OFF)  # Turn on to debug protobuf issues.
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+	find_package(Protobuf CONFIG REQUIRED)
+	# Use with: target_link_libraries(PSMoveProtocol PRIVATE protobuf::libprotoc protobuf::libprotobuf)
+ELSE()
+	find_package(Protobuf REQUIRED)
+	# Use with:
+	# target_include_directories(${target} ${Protobuf_INCLUDE_DIRS})
+	# target_link_libraries(${target} ${Protobuf_LIBRARIES})
+ENDIF()
+# Also, .proto files can be added to a target with:
+# protobuf_generate(TARGET ${target} PROTOS ${my.proto})
+
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     # protobuf current generates many warnings in MacOS:
     #'OSMemoryBarrier' is deprecated: first deprecated in macOS 10.12 - Use std::atomic_thread_fence() from <atomic> instead
@@ -175,27 +111,16 @@ ENDIF()
 
 
 # SDL and GL
-set(SDL_GL_INCLUDE_DIRS)
-set(SDL_GL_LIBS)
+find_package(SDL2 CONFIG REQUIRED)
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     find_library(OPENGL_FRAMEWORK OpenGL)
-    find_package(SDL2)
-    list(APPEND SDL_GL_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
-    list(APPEND SDL_GL_LIBS
-        ${SDL2_LIBRARY} ${OPENGL_FRAMEWORK} ${GLUT_FRAMEWORK})
+    list(APPEND SDL2_LIBRARIES ${OPENGL_FRAMEWORK} ${GLUT_FRAMEWORK})
 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-    find_package(SDL2)
-    list(APPEND SDL_GL_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
-    list(APPEND SDL_GL_LIBS ${SDL2_LIBRARY} GL)
-ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    SET(ENV{SDL2DIR} ${ROOT_DIR}/thirdparty/SDL2/)
-    find_package(SDL2)
-    list(APPEND SDL_GL_INCLUDE_DIRS ${SDL2_INCLUDE_DIR})
-    list(APPEND SDL_GL_LIBS 
-        ${SDL2_LIBRARY}
-        imm32.lib
-        version.lib)
+    list(APPEND SDL2_LIBRARIES GL)
 ENDIF()
+# Use with:
+# target_include_directories(main ${SDL2_INCLUDE_DIRS})
+# target_link_libraries(main PRIVATE ${SDL2_LIBRARIES})
 
 
 # For PSEye camera
@@ -236,24 +161,36 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows"
     #list(APPEND PSEYE_LIBRARIES ${LIBUSB_LIBRARIES})
 ENDIF()
 
+# We don't officially support anything but the PS3Eye camera at the moment
+# and it's currently confusing debugging other peoples camera issues with
+# random webcams being opened.
+# However, this is the only way to open the PS3Eye on Linux.
+option(EnableWebcam "EnableWebcam" OFF)
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    set(EnableWebcam ON)
+ENDIF()
+IF(${EnableWebcam})
+    add_compile_definitions(ENABLE_WEBCAM)
+ENDIF()
+
 
 # hidapi
 set(HIDAPI_INCLUDE_DIRS ${ROOT_DIR}/thirdparty/hidapi/hidapi)
-set(HIDAPI_SRC)
-set(HIDAPI_LIBS)
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    list(APPEND HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/windows/hid.c)
+    set(HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/windows/hid.c)
 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    list(APPEND HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/mac/hid.c)
+    set(HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/mac/hid.c)
 ELSE()
-    list(APPEND HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/linux/hid.c)
-    find_package(PkgConfig REQUIRED)
+    set(HIDAPI_SRC ${ROOT_DIR}/thirdparty/hidapi/linux/hid.c)
+#   I tried using hidapi from apt-get but it didn't work.
+#    pkg_check_modules(HIDAPI REQUIRED hidapi-libusb)
+#    pkg_check_modules(HIDAPI REQUIRED hidapi-hidraw)
     pkg_check_modules(UDEV REQUIRED libudev)
-    list(APPEND HIDAPI_INCLUDE_DIRS ${UDEV_INCLUDE_DIRS})
-    list(APPEND HIDAPI_LIBS ${UDEV_LIBRARIES})
+    list(APPEND HIDAPI_INCLUDE_DIRS ${UDEV_INCLUDEDIR})
+    list(APPEND HIDAPI_LIBRARIES ${UDEV_LIBRARIES})
     pkg_check_modules(BLUEZ REQUIRED bluez)
-    list(APPEND HIDAPI_INCLUDE_DIRS ${BLUEZ_INCLUDE_DIRS})
-    list(APPEND HIDAPI_LIBS ${BLUEZ_LIBRARIES})
+    list(APPEND HIDAPI_INCLUDE_DIRS ${BLUEZ_INCLUDEDIR})
+    list(APPEND HIDAPI_LIBRARIES ${BLUEZ_LIBRARIES})
 ENDIF()
 
 
@@ -266,4 +203,4 @@ ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     list(APPEND LIBSTEM_GAMEPAD_SRC ${ROOT_DIR}/thirdparty/libstem_gamepad/source/gamepad/Gamepad_macosx.c)
 ELSE()
     list(APPEND LIBSTEM_GAMEPAD_SRC ${ROOT_DIR}/thirdparty/libstem_gamepad/source/gamepad/Gamepad_linux.c)
-ENDIF()
\ No newline at end of file
+ENDIF()
diff --git a/doc/BUILD_MACOS.md b/doc/BUILD_MACOS.md
new file mode 100644
index 00000000..0430a3f2
--- /dev/null
+++ b/doc/BUILD_MACOS.md
@@ -0,0 +1,13 @@
+Temporary build notes:
+
+* install homebrew
+    * `/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"` # Install homebrew
+* `brew update`
+* `brew install cmake git sdl2 libusb eigen opencv@3 boost protobuf glm`
+* cd into root PSMoveService folder
+* `mkdir build_deps && cd build_deps`
+    * From root PSMoveService folder
+* `git clone https://github.com/ocornut/imgui.git`
+* `cd ..`
+* `mkdir build && cd build`
+* `cmake ..`
diff --git a/doc/BUILD_UBUNTU.md b/doc/BUILD_UBUNTU.md
new file mode 100644
index 00000000..141112b5
--- /dev/null
+++ b/doc/BUILD_UBUNTU.md
@@ -0,0 +1,39 @@
+## <a name="Linux">Linux</a>
+
+Tested with Ubuntu 18.04 AMD64. Not quite ready.
+
+### Prerequisites
+
+The following should be run from inside the cloned PSMoveService directory.
+
+1. `mkdir build_deps && cd build_deps`
+1. Build tools
+    * `sudo apt-get install build-essential git checkinstall pkg-config autoconf automake libtool`
+    * Ubuntu ships with an old version of cmake. We need to manually install a more recent version:
+        * `wget https://github.com/Kitware/CMake/releases/download/v3.13.4/cmake-3.13.4-Linux-x86_64.sh`
+        * `sudo sh cmake-3.13.4-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir`
+1. Third party libraries from apt-get
+    * `sudo apt-get install libopencv-dev libsdl2-dev libeigen3-dev libbluetooth-dev libhidapi-dev libusb-1.0 libprotobuf-dev protobuf-compiler libglm-dev`
+1. You will probably have to close your terminal window and open a new one.
+1. ImGui - Unlike Windows with vcpkg, there's no package-manager version of ImGui, so we download it. I don't think we have to build.
+    * `git clone https://github.com/ocornut/imgui.git`
+1. We need a newish version of boost, one that has boost.asio.io_context instead of .io_service
+    * `wget -O boost.tar.bz2 "https://dl.bintray.com/boostorg/release/1.69.0/source/boost_1_69_0.tar.bz2"`
+    * `tar xvfj boost.tar.bz2`
+    * `cd boost_1_69_0`
+    * `sudo ./bootstrap.sh`
+        * TODO: Add `--with-libraries=library-name-list` to shorten compile time.
+    * `sudo ./b2 install`
+    * `cd ..`
+
+### Generate project files
+
+1. Assuming you are still in the build_deps folder, do a `cd ..`
+1. `mkdir build && cd build`
+1. `cmake ..`
+1. `make .`
+
+### udev access
+
+1. `sudo cp misc/99-psmove.rules /etc/udev/rules.d/`
+1. `sudo udevadm trigger`
diff --git a/doc/BUILD_WIN.md b/doc/BUILD_WIN.md
new file mode 100644
index 00000000..2a09b55a
--- /dev/null
+++ b/doc/BUILD_WIN.md
@@ -0,0 +1,20 @@
+Temporary build notes:
+
+* Download vcpkg
+* >vcpkg install sdl2:x64-windows libusb:x64-windows opencv:x64-windows boost:x64-windows eigen3:x64-windows protobuf:x64-windows glm:x64-windows imgui:x64-windows
+* Build with VS2017 integrated cmake
+    * Open PSMoveService folder in Visual Studio 2017. Let cmake scan and attempt to configure.
+    See [here](https://docs.microsoft.com/en-us/cpp/ide/cmake-tools-for-visual-cpp?view=vs-2017#ide-integration).
+    * Using the dropdown menu, make sure your configuration is set to x64-Release (or Debug if so desired).
+    * Set your CMake configuration settings from the cmake menu
+        ```
+        ,
+            "variables": [{
+              "name": "CMAKE_TOOLCHAIN_FILE",
+              "value": "D:\\Tools\\Misc\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake"
+            }]
+        ```
+* Alternatively, Config and generate with command line
+    * cmake .. -G "Visual Studio 15 2017 Win64" -DCMAKE_TOOLCHAIN_FILE=D:\Tools\Misc\vcpkg\scripts\buildsystems\vcpkg.cmake
+        * Optional addons:  -DVCPKG_TARGET_TRIPLET=x64-windows -DCMAKE_BUILD_TYPE=Release
+
diff --git a/misc/99-psmove.rules b/misc/99-psmove.rules
new file mode 100644
index 00000000..611040b1
--- /dev/null
+++ b/misc/99-psmove.rules
@@ -0,0 +1,14 @@
+# hidraw interface: Bluetooth (=0005), PS Move Motion Controller (=054c:03d5)
+SUBSYSTEM=="hidraw", KERNELS=="0005:054C:03D5.*", MODE="0666"
+
+# hidraw interface: USB (=0003), PS Move Motion Controller (=054c:03d5)
+SUBSYSTEM=="hidraw", KERNELS=="0003:054C:03D5.*", MODE="0666"
+
+# hidraw interface: Bluetooth (=0005), PS4 Move Motion Controller, CECH-ZCM2 (=054c:0c5e)
+SUBSYSTEM=="hidraw", KERNELS=="0005:054C:0C5E.*", MODE="0666"
+
+# hidraw interface: USB (=0003), PS4 Move Motion Controller, CECH-ZCM2 (=054c:0c5e)
+SUBSYSTEM=="hidraw", KERNELS=="0003:054C:0C5E.*", MODE="0666"
+
+# libusb interface: obsolete (we use hidraw for everything now)
+#SUBSYSTEM=="usb", ATTRS{idVendor}=="054c", ATTRS{idProduct}=="03d5", MODE="0666"
diff --git a/src/psmoveclient/CMakeLists.txt b/src/psmoveclient/CMakeLists.txt
index 288753f5..66e85277 100644
--- a/src/psmoveclient/CMakeLists.txt
+++ b/src/psmoveclient/CMakeLists.txt
@@ -7,29 +7,30 @@ include (GenerateExportHeader)
 
 set(CMAKE_INSTALL_PREFIX ${ROOT_DIR}/dist)
 
-set(PSMOVE_CLIENT_INCL_DIRS)
-set(PSMOVE_CLIENT_REQ_LIBS)
+set(PSMOVECLIENT_LIBRARY_SRC)
+set(PSMOVECLIENT_INCL_DIRS)
+set(PSMOVECLIENT_REQ_LIBS)
 
-list(APPEND PSMOVE_CLIENT_INCL_DIRS
-    ${ROOT_DIR}/thirdparty/Boost.Application/include/
-    ${ROOT_DIR}/thirdparty/type_index/include/)
+list(APPEND PSMOVECLIENT_INCL_DIRS
+	${ROOT_DIR}/thirdparty/type_index/include/
+    ${ROOT_DIR}/thirdparty/Boost.Application/include/)
+# https://github.com/cboulay/PSMoveService/issues/39 ?
 
-# Protobuf
-list(APPEND PSMOVE_CLIENT_INCL_DIRS ${PROTOBUF_INCLUDE_DIRS})
-list(APPEND PSMOVE_CLIENT_REQ_LIBS ${PROTOBUF_LIBRARIES})
+# Protobuf - Transitively through PSMoveProtocol
+# list(APPEND PSMOVECLIENT_REQ_LIBS protobuf::libprotoc protobuf::libprotobuf)
 
 # Boost
 find_package(Boost REQUIRED QUIET COMPONENTS system)
-list(APPEND PSMOVE_CLIENT_INCL_DIRS ${Boost_INCLUDE_DIRS})
-list(APPEND PSMOVE_CLIENT_REQ_LIBS ${Boost_LIBRARIES})
+list(APPEND PSMOVECLIENT_INCL_DIRS ${Boost_INCLUDE_DIRS})
+list(APPEND PSMOVECLIENT_REQ_LIBS ${Boost_LIBRARIES})
 
-# PSMoveProtocol
-include_directories(${ROOT_DIR}/src/psmoveprotocol/)
-list(APPEND PSMOVE_CLIENT_REQ_LIBS PSMoveProtocol)
+# PSMoveProtocol - brings protobuf
+list(APPEND PSMOVECLIENT_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol/)
+list(APPEND PSMOVECLIENT_REQ_LIBS PSMoveProtocol)
 
 # PSMoveMath
-include_directories(${ROOT_DIR}/src/psmovemath/)
-list(APPEND PSMOVE_CLIENT_REQ_LIBS PSMoveMath)
+list(APPEND PSMOVECLIENT_INCL_DIRS ${ROOT_DIR}/src/psmovemath/)
+list(APPEND PSMOVECLIENT_REQ_LIBS PSMoveMath)
 
 # Source files that are needed for the shared library
 file(GLOB PSMOVECLIENT_LIBRARY_SRC
@@ -37,36 +38,23 @@ file(GLOB PSMOVECLIENT_LIBRARY_SRC
     "${CMAKE_CURRENT_LIST_DIR}/*.cpp"
 )
 
-# TODO: Build PSMoveClient as a STATIC or OBJECT w/ $<TARGET_OBJECTS:objlib>
-add_library(PSMoveClient_static STATIC ${PSMOVECLIENT_LIBRARY_SRC})
-target_include_directories(PSMoveClient_static PUBLIC ${PSMOVE_CLIENT_INCL_DIRS})
-target_link_libraries(PSMoveClient_static PUBLIC ${PLATFORM_LIBS} ${PSMOVE_CLIENT_REQ_LIBS})
-target_compile_definitions(PSMoveClient_static PRIVATE PSMOVECLIENT_CPP_API)
-target_compile_definitions(PSMoveClient_static PRIVATE PSMoveClient_STATIC)
+# Build PSMoveClient CPP SHARED library.
+add_library(PSMoveClient SHARED ${PSMOVECLIENT_LIBRARY_SRC})
+target_include_directories(PSMoveClient PRIVATE ${PSMOVECLIENT_INCL_DIRS})
+target_link_libraries(PSMoveClient PRIVATE ${PLATFORM_LIBS} ${PSMOVECLIENT_REQ_LIBS})
+set_target_properties(PSMoveClient PROPERTIES PUBLIC_HEADER "ClientConstants.h;PSMoveClient_export.h; PSMoveClient.h")
+target_compile_definitions(PSMoveClient PRIVATE PSMoveClient_EXPORTS)
+target_compile_definitions(PSMoveClient PRIVATE PSMOVECLIENT_CPP_API)
 
-#
-# PSMoveClient_CAPI Shared library
-#
-set(PSMOVE_CLIENT_CAPI_REQ_LIBS)
-
-# PSMoveClient_static
-list(APPEND PSMOVE_CLIENT_CAPI_REQ_LIBS PSMoveClient_static)
-#Via PSMoveClient_static, transitively inherits PSMoveProtocol < Protobuf, Boost, PSMoveMath
-
-# Source files to develop the shared library.
-list(APPEND PSMOVECLIENT_CAPI_LIBRARY_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveClient_export.h"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveClient_CAPI.h"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveClient_CAPI.cpp"
-)
-
-# Shared library
+# Build PSMoveClient_CAPI SHARED library.
 add_library(PSMoveClient_CAPI SHARED ${PSMOVECLIENT_LIBRARY_SRC})
-target_include_directories(PSMoveClient_CAPI PUBLIC ${CMAKE_CURRENT_LIST_DIR})
-target_link_libraries(PSMoveClient_CAPI PRIVATE ${PSMOVE_CLIENT_CAPI_REQ_LIBS})
+target_include_directories(PSMoveClient_CAPI PRIVATE ${PSMOVECLIENT_INCL_DIRS})
+target_link_libraries(PSMoveClient_CAPI PRIVATE ${PLATFORM_LIBS} ${PSMOVECLIENT_REQ_LIBS})
 set_target_properties(PSMoveClient_CAPI PROPERTIES PUBLIC_HEADER "ClientConstants.h;ClientGeometry_CAPI.h;PSMoveClient_CAPI.h;PSMoveClient_export.h")
 set_target_properties(PSMoveClient_CAPI PROPERTIES CXX_VISIBILITY_PRESET hidden)
 set_target_properties(PSMoveClient_CAPI PROPERTIES C_VISIBILITY_PRESET hidden)
+target_compile_definitions(PSMoveClient_CAPI PRIVATE PSMoveClient_CAPI_EXPORTS)
+
 
 # Install
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
diff --git a/src/psmoveclient/ClientNetworkManager.cpp b/src/psmoveclient/ClientNetworkManager.cpp
index a5fed7c9..33b48b25 100644
--- a/src/psmoveclient/ClientNetworkManager.cpp
+++ b/src/psmoveclient/ClientNetworkManager.cpp
@@ -38,10 +38,10 @@ class ClientNetworkManagerImpl
         : m_server_host(host)
         , m_server_port(port)
 
-        , m_io_service()
-        , m_tcp_socket(m_io_service)
+        , m_io_context()
+        , m_tcp_socket(m_io_context)
         , m_tcp_connection_id(-1)
-        , m_udp_socket(m_io_service, udp::endpoint(udp::v4(), 0))
+        , m_udp_socket(m_io_context, udp::endpoint(udp::v4(), 0))
         , m_udp_server_endpoint()
         , m_udp_remote_endpoint()
         , m_connection_stopped(false)
@@ -69,7 +69,7 @@ class ClientNetworkManagerImpl
 
     bool start()
     {
-        tcp::resolver resolver(m_io_service);
+        tcp::resolver resolver(m_io_context);
         tcp::resolver::iterator endpoint_iter= resolver.resolve(tcp::resolver::query(tcp::v4(), m_server_host, m_server_port));
 
         m_connection_stopped= false;
@@ -108,7 +108,7 @@ class ClientNetworkManagerImpl
             // * TCP request has finished writing
             // * TCP response has finished receiving
             // * UDP data frame has finished writing
-            m_io_service.poll();
+            m_io_context.poll();
 
             // In the event that a UDP data frame write completed immediately,
             // we should start another UDP data frame write.
@@ -291,7 +291,7 @@ class ClientNetworkManagerImpl
             CLIENT_LOG_DEBUG("   ") << msg_size << " bytes";
 
             // Start an asynchronous operation to send the data frame
-            // NOTE: Even if the write completes immediate, the callback will only be called from io_service::poll()
+            // NOTE: Even if the write completes immediate, the callback will only be called from io_context::poll()
             m_udp_socket.async_send_to(
                 boost::asio::buffer(m_input_data_frame_buffer, sizeof(m_input_data_frame_buffer)),
                 m_udp_server_endpoint,
@@ -598,7 +598,7 @@ class ClientNetworkManagerImpl
                         m_has_pending_udp_write = true;
 
                         // Start an asynchronous operation to send the data frame
-                        // NOTE: Even if the write completes immediate, the callback will only be called from io_service::poll()
+                        // NOTE: Even if the write completes immediate, the callback will only be called from io_context::poll()
                         m_udp_socket.async_send_to(
                             boost::asio::buffer(m_input_data_frame_buffer, sizeof(m_input_data_frame_buffer)),
                             m_udp_server_endpoint,
@@ -719,7 +719,7 @@ class ClientNetworkManagerImpl
     std::string m_server_host;
     std::string m_server_port;
 
-    asio::io_service m_io_service;
+    asio::io_context m_io_context;
     tcp::socket m_tcp_socket;
     int m_tcp_connection_id;
 
diff --git a/src/psmoveclient/PSMoveClient_export.h b/src/psmoveclient/PSMoveClient_export.h
index 5b957240..14fc1fae 100644
--- a/src/psmoveclient/PSMoveClient_export.h
+++ b/src/psmoveclient/PSMoveClient_export.h
@@ -59,7 +59,7 @@
             #define PSM_PRIVATE_FUNCTION(rval)                      __attribute__((visibility("hidden")))   rval    PSM_CALL
             #define PSM_PRIVATE_CLASS                               __attribute__((visibility("hidden")))
         #endif  //defined _WIN32 || defined __CYGWIN__
-    #elif defined(PSMoveClient_STATIC) || defined(PSMoveClient_CAPI_STATIC)  // Building static lib
+    #elif defined(PSMoveClient_NOEXPORT) || defined(PSMoveClient_CAPI_NOEXPORT)  // Building static lib
         #define PSM_PUBLIC_FUNCTION(rval)           PSM_EXTERN_C                                            rval    PSM_CALL
         #define PSM_PUBLIC_CLASS
         #define PSM_PRIVATE_FUNCTION(rval)                                                                  rval    PSM_CALL
diff --git a/src/psmoveconfigtool/AppStage_AccelerometerCalibration.cpp b/src/psmoveconfigtool/AppStage_AccelerometerCalibration.cpp
index aa324a6c..35056ee8 100644
--- a/src/psmoveconfigtool/AppStage_AccelerometerCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_AccelerometerCalibration.cpp
@@ -360,7 +360,6 @@ void AppStage_AccelerometerCalibration::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "Accelerometer Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_ColorCalibration.cpp b/src/psmoveconfigtool/AppStage_ColorCalibration.cpp
index fd41caf2..77a68e4b 100644
--- a/src/psmoveconfigtool/AppStage_ColorCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_ColorCalibration.cpp
@@ -379,7 +379,6 @@ void AppStage_ColorCalibration::renderUI()
     const float k_panel_width = 300.f;
     const char *k_window_title = "Color Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
@@ -884,8 +883,8 @@ void AppStage_ColorCalibration::renderUI()
         // Tracker Alignment Marker
         if (m_bShowAlignment)
         {
-            float prevAlpha = ImGui::GetStyle().WindowFillAlphaDefault;
-            ImGui::GetStyle().WindowFillAlphaDefault = 0.f;
+            //float prevAlpha = ImGui::GetStyle().WindowFillAlphaDefault;
+            //ImGui::GetStyle().WindowFillAlphaDefault = 0.f;
 
             float align_window_size = 30.f;
             float x0 = (ImGui::GetIO().DisplaySize.x - align_window_size) / 2;
@@ -895,7 +894,6 @@ void AppStage_ColorCalibration::renderUI()
             ImGui::SetNextWindowSize(ImVec2(align_window_size, align_window_size));
             ImGui::Begin("Alignment Window", nullptr,
                 ImGuiWindowFlags_NoTitleBar |
-                ImGuiWindowFlags_ShowBorders |
                 ImGuiWindowFlags_NoResize |
                 ImGuiWindowFlags_NoMove |
                 ImGuiWindowFlags_NoScrollbar |
@@ -947,7 +945,7 @@ void AppStage_ColorCalibration::renderUI()
             );
 
             ImGui::End();
-            ImGui::GetStyle().WindowFillAlphaDefault = prevAlpha;
+            //ImGui::GetStyle().WindowFillAlphaDefault = prevAlpha;
         }
 
     } break;
diff --git a/src/psmoveconfigtool/AppStage_ComputeTrackerPoses.cpp b/src/psmoveconfigtool/AppStage_ComputeTrackerPoses.cpp
index 1e16e348..70039580 100644
--- a/src/psmoveconfigtool/AppStage_ComputeTrackerPoses.cpp
+++ b/src/psmoveconfigtool/AppStage_ComputeTrackerPoses.cpp
@@ -320,7 +320,6 @@ void AppStage_ComputeTrackerPoses::renderUI()
     const float k_panel_width = 300.f;
     const char *k_window_title = "Compute Tracker Poses";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
@@ -457,8 +456,8 @@ void AppStage_ComputeTrackerPoses::renderUI()
         // Tracker Alignment Marker
         if (m_bShowAlignment)
         {
-            float prevAlpha = ImGui::GetStyle().WindowFillAlphaDefault;
-            ImGui::GetStyle().WindowFillAlphaDefault = 0.f;
+            //float prevAlpha = ImGui::GetStyle().WindowFillAlphaDefault;
+            //ImGui::GetStyle().WindowFillAlphaDefault = 0.f;
 
             float align_window_size = 30.f;
             float x0 = (ImGui::GetIO().DisplaySize.x - align_window_size) / 2;
@@ -468,7 +467,6 @@ void AppStage_ComputeTrackerPoses::renderUI()
             ImGui::SetNextWindowSize(ImVec2(align_window_size, align_window_size));
             ImGui::Begin("Alignment Window", nullptr,
                 ImGuiWindowFlags_NoTitleBar |
-                ImGuiWindowFlags_ShowBorders |
                 ImGuiWindowFlags_NoResize |
                 ImGuiWindowFlags_NoMove |
                 ImGuiWindowFlags_NoScrollbar |
@@ -490,7 +488,7 @@ void AppStage_ComputeTrackerPoses::renderUI()
             );
 
             ImGui::End();
-            ImGui::GetStyle().WindowFillAlphaDefault = prevAlpha;
+            //ImGui::GetStyle().WindowFillAlphaDefault = prevAlpha;
         }
 
         break;
diff --git a/src/psmoveconfigtool/AppStage_ControllerSettings.cpp b/src/psmoveconfigtool/AppStage_ControllerSettings.cpp
index 6d83b398..88fc1861 100644
--- a/src/psmoveconfigtool/AppStage_ControllerSettings.cpp
+++ b/src/psmoveconfigtool/AppStage_ControllerSettings.cpp
@@ -328,7 +328,6 @@ void AppStage_ControllerSettings::renderUI()
 {
     const char *k_window_title= "Controller Settings";
     const ImGuiWindowFlags window_flags = 
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize | 
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
@@ -341,8 +340,9 @@ void AppStage_ControllerSettings::renderUI()
             ImGui::SetNextWindowPosCenter();
             ImGui::SetNextWindowSize(ImVec2(350, 490));
             ImGui::Begin("Controller Settings", nullptr, window_flags | ImGuiWindowFlags_MenuBar);
+			
 
-            if (ImGui::CollapsingHeader("Host Info", 0, true, true))
+            if (ImGui::CollapsingHeader("Host Info", ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed))
             {
                 if (m_hostSerial.length() > 1 && m_hostSerial != "00:00:00:00:00:00")
                 {
@@ -358,7 +358,7 @@ void AppStage_ControllerSettings::renderUI()
             {
                 ControllerInfo &controllerInfo= m_controllerInfos[m_selectedControllerIndex];
 
-                if (ImGui::CollapsingHeader("Controller Settings", 0, true, true))
+                if (ImGui::CollapsingHeader("Controller Settings", ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed))
                 {
                     if (m_selectedControllerIndex > 0)
                     {
@@ -513,7 +513,7 @@ void AppStage_ControllerSettings::renderUI()
 				    if (!m_app->excludePositionSettings &&
 						(controllerInfo.IsBluetooth || controllerInfo.ControllerType == PSMController_Virtual))
                     {
-                        if (ImGui::CollapsingHeader("Filters", 0, true, false))
+                        if (ImGui::CollapsingHeader("Filters", ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed))
                         {
 					        if ((controllerInfo.ControllerType == PSMController_Move && controllerInfo.IsBluetooth) ||
 						        controllerInfo.ControllerType == PSMController_Virtual)
@@ -593,7 +593,10 @@ void AppStage_ControllerSettings::renderUI()
 
 				if (controllerInfo.ControllerType == PSMController_Move && controllerInfo.IsBluetooth)
                 {
-					if (ImGui::CollapsingHeader("Controller Calibration", 0, true, m_app->excludePositionSettings))
+					ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Framed;
+					if (m_app->excludePositionSettings)
+						flags |= ImGuiTreeNodeFlags_DefaultOpen;
+					if (ImGui::CollapsingHeader("Controller Calibration", flags))
 					{
 						if (controllerInfo.HasMagnetometer)
 						{
@@ -625,7 +628,10 @@ void AppStage_ControllerSettings::renderUI()
 
 				if (controllerInfo.IsBluetooth || controllerInfo.ControllerType == PSMController_Virtual)
 				{
-					if (ImGui::CollapsingHeader("Controller Tests", 0, true, m_app->excludePositionSettings))
+					ImGuiTreeNodeFlags flags = ImGuiTreeNodeFlags_Framed;
+					if (m_app->excludePositionSettings)
+						flags |= ImGuiTreeNodeFlags_DefaultOpen;
+					if (ImGui::CollapsingHeader("Controller Tests", flags))
 					{
 						if (controllerInfo.ControllerType == PSMController_Move)
 						{
diff --git a/src/psmoveconfigtool/AppStage_DistortionCalibration.cpp b/src/psmoveconfigtool/AppStage_DistortionCalibration.cpp
index cb837cb3..f5a3f532 100644
--- a/src/psmoveconfigtool/AppStage_DistortionCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_DistortionCalibration.cpp
@@ -586,7 +586,6 @@ void AppStage_DistortionCalibration::renderUI()
     const float k_panel_width = 200.f;
     const char *k_window_title = "Distortion Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_GyroscopeCalibration.cpp b/src/psmoveconfigtool/AppStage_GyroscopeCalibration.cpp
index 499a0178..83ea3e24 100644
--- a/src/psmoveconfigtool/AppStage_GyroscopeCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_GyroscopeCalibration.cpp
@@ -392,7 +392,6 @@ void AppStage_GyroscopeCalibration::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "Gyroscope Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_HMDAccelerometerCalibration.cpp b/src/psmoveconfigtool/AppStage_HMDAccelerometerCalibration.cpp
index 2e028449..dc277c8c 100644
--- a/src/psmoveconfigtool/AppStage_HMDAccelerometerCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_HMDAccelerometerCalibration.cpp
@@ -314,7 +314,6 @@ void AppStage_HMDAccelerometerCalibration::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "HMD Accelerometer Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_HMDGyroscopeCalibration.cpp b/src/psmoveconfigtool/AppStage_HMDGyroscopeCalibration.cpp
index 1ba51fbc..f26db974 100644
--- a/src/psmoveconfigtool/AppStage_HMDGyroscopeCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_HMDGyroscopeCalibration.cpp
@@ -387,7 +387,6 @@ void AppStage_HMDGyroscopeCalibration::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "HMD Gyroscope Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_HMDModelCalibration.cpp b/src/psmoveconfigtool/AppStage_HMDModelCalibration.cpp
index 63da6adc..ea9a96ca 100644
--- a/src/psmoveconfigtool/AppStage_HMDModelCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_HMDModelCalibration.cpp
@@ -545,7 +545,6 @@ void AppStage_HMDModelCalibration::renderUI()
 	const float k_panel_width = 300.f;
 	const char *k_window_title = "Compute HMD Model";
 	const ImGuiWindowFlags window_flags =
-		ImGuiWindowFlags_ShowBorders |
 		ImGuiWindowFlags_NoResize |
 		ImGuiWindowFlags_NoMove |
 		ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_HMDSettings.cpp b/src/psmoveconfigtool/AppStage_HMDSettings.cpp
index 9fd9bb9f..70f314d5 100644
--- a/src/psmoveconfigtool/AppStage_HMDSettings.cpp
+++ b/src/psmoveconfigtool/AppStage_HMDSettings.cpp
@@ -137,7 +137,6 @@ void AppStage_HMDSettings::renderUI()
 {
     const char *k_window_title = "HMD Settings";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_MagnetometerCalibration.cpp b/src/psmoveconfigtool/AppStage_MagnetometerCalibration.cpp
index 5782fb9b..0f0f508b 100644
--- a/src/psmoveconfigtool/AppStage_MagnetometerCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_MagnetometerCalibration.cpp
@@ -646,7 +646,6 @@ void AppStage_MagnetometerCalibration::renderUI()
     const float k_panel_width= 500;
     const char *k_window_title= "Magnetometer Calibration";
     const ImGuiWindowFlags window_flags = 
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize | 
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_MainMenu.cpp b/src/psmoveconfigtool/AppStage_MainMenu.cpp
index 7419445f..d1ff4227 100644
--- a/src/psmoveconfigtool/AppStage_MainMenu.cpp
+++ b/src/psmoveconfigtool/AppStage_MainMenu.cpp
@@ -63,7 +63,6 @@ void AppStage_MainMenu::renderUI()
     case connectedToService:
         {
             ImGuiWindowFlags window_flags = 
-                ImGuiWindowFlags_ShowBorders |
                 ImGuiWindowFlags_NoResize | 
                 ImGuiWindowFlags_NoMove |
                 ImGuiWindowFlags_NoScrollbar |
@@ -100,7 +99,6 @@ void AppStage_MainMenu::renderUI()
     case pendingConnectToToService:
         {
             ImGuiWindowFlags window_flags = 
-                ImGuiWindowFlags_ShowBorders |
                 ImGuiWindowFlags_NoResize | 
                 ImGuiWindowFlags_NoMove |
                 ImGuiWindowFlags_NoScrollbar |
@@ -119,7 +117,6 @@ void AppStage_MainMenu::renderUI()
 	case disconnectedFromService:
         {
             ImGuiWindowFlags window_flags = 
-                ImGuiWindowFlags_ShowBorders |
                 ImGuiWindowFlags_NoResize | 
                 ImGuiWindowFlags_NoMove |
                 ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_OpticalCalibration.cpp b/src/psmoveconfigtool/AppStage_OpticalCalibration.cpp
index 8df0dd1a..e30fe74c 100644
--- a/src/psmoveconfigtool/AppStage_OpticalCalibration.cpp
+++ b/src/psmoveconfigtool/AppStage_OpticalCalibration.cpp
@@ -543,7 +543,6 @@ void AppStage_OpticalCalibration::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "Optical Noise Calibration";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_PairController.cpp b/src/psmoveconfigtool/AppStage_PairController.cpp
index 5e39adef..af40ccbb 100644
--- a/src/psmoveconfigtool/AppStage_PairController.cpp
+++ b/src/psmoveconfigtool/AppStage_PairController.cpp
@@ -59,7 +59,6 @@ void AppStage_PairController::renderUI()
 {
     const char *k_window_title= "Controller Pairing";
     const ImGuiWindowFlags window_flags = 
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize | 
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_ServiceSettings.cpp b/src/psmoveconfigtool/AppStage_ServiceSettings.cpp
index aba965ae..4bd73c0a 100644
--- a/src/psmoveconfigtool/AppStage_ServiceSettings.cpp
+++ b/src/psmoveconfigtool/AppStage_ServiceSettings.cpp
@@ -37,7 +37,6 @@ void AppStage_ServiceSettings::update()
 void AppStage_ServiceSettings::renderUI()
 {
     ImGuiWindowFlags window_flags = 
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize | 
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_TestButtons.cpp b/src/psmoveconfigtool/AppStage_TestButtons.cpp
index 0d508788..b720356d 100644
--- a/src/psmoveconfigtool/AppStage_TestButtons.cpp
+++ b/src/psmoveconfigtool/AppStage_TestButtons.cpp
@@ -143,7 +143,6 @@ void AppStage_TestButtons::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "Test Buttons";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_AlwaysAutoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_TestRumble.cpp b/src/psmoveconfigtool/AppStage_TestRumble.cpp
index 25f1e4c9..94913b71 100644
--- a/src/psmoveconfigtool/AppStage_TestRumble.cpp
+++ b/src/psmoveconfigtool/AppStage_TestRumble.cpp
@@ -129,7 +129,6 @@ void AppStage_TestRumble::renderUI()
     const float k_panel_width = 500;
     const char *k_window_title = "Test Rumble";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_TestTracker.cpp b/src/psmoveconfigtool/AppStage_TestTracker.cpp
index 57e1e07f..ef6e36fe 100644
--- a/src/psmoveconfigtool/AppStage_TestTracker.cpp
+++ b/src/psmoveconfigtool/AppStage_TestTracker.cpp
@@ -99,7 +99,6 @@ void AppStage_TestTracker::renderUI()
     const float k_panel_width = 300.f;
     const char *k_window_title = "Video Feed Test";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppStage_TrackerSettings.cpp b/src/psmoveconfigtool/AppStage_TrackerSettings.cpp
index 2b36c66e..21119f27 100644
--- a/src/psmoveconfigtool/AppStage_TrackerSettings.cpp
+++ b/src/psmoveconfigtool/AppStage_TrackerSettings.cpp
@@ -167,7 +167,6 @@ void AppStage_TrackerSettings::renderUI()
 {
     const char *k_window_title = "Tracker Settings";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_AlwaysAutoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/AppSubStage_CalibrateWithMat.cpp b/src/psmoveconfigtool/AppSubStage_CalibrateWithMat.cpp
index ace61c16..effd89d7 100644
--- a/src/psmoveconfigtool/AppSubStage_CalibrateWithMat.cpp
+++ b/src/psmoveconfigtool/AppSubStage_CalibrateWithMat.cpp
@@ -577,7 +577,6 @@ void AppSubStage_CalibrateWithMat::renderUI()
     const float k_panel_width = 450.f;
     const char *k_window_title = "Compute Tracker Poses";
     const ImGuiWindowFlags window_flags =
-        ImGuiWindowFlags_ShowBorders |
         ImGuiWindowFlags_NoResize |
         ImGuiWindowFlags_NoMove |
         ImGuiWindowFlags_NoScrollbar |
diff --git a/src/psmoveconfigtool/CMakeLists.txt b/src/psmoveconfigtool/CMakeLists.txt
index c8dd52f5..08491599 100644
--- a/src/psmoveconfigtool/CMakeLists.txt
+++ b/src/psmoveconfigtool/CMakeLists.txt
@@ -1,6 +1,11 @@
 set(ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
 set(PSMOVECONFIGTOOL_INCL_DIRS)
 set(PSMOVECONFIGTOOL_REQ_LIBS)
+# Source files that are needed for the psmove config tool
+file(GLOB PSMOVECONFIGTOOL_SRC
+        "${CMAKE_CURRENT_LIST_DIR}/*.h"
+        "${CMAKE_CURRENT_LIST_DIR}/*.cpp"
+)
 
 # Boost
 find_package(Boost REQUIRED QUIET COMPONENTS date_time)
@@ -9,46 +14,50 @@ list(APPEND PSMOVECONFIGTOOL_REQ_LIBS ${Boost_LIBRARIES})
 
 # platform independent include paths
 list(APPEND PSMOVECONFIGTOOL_INCL_DIRS
-    ${EIGEN3_INCLUDE_DIR}
-    ${ROOT_DIR}/thirdparty/glm
     ${ROOT_DIR}/thirdparty/sparseicp
     ${ROOT_DIR}/thirdparty/stb
-    ${ROOT_DIR}/thirdparty/imgui
     ${ROOT_DIR}/src/psmoveclient/
     ${ROOT_DIR}/src/psmovemath/
     ${ROOT_DIR}/src/psmoveprotocol/
-    ${PROTOBUF_INCLUDE_DIRS})
+)
 
 # platform independent libraries
 list(APPEND PSMOVECONFIGTOOL_REQ_LIBS 
     PSMoveClient_CAPI
     PSMoveMath
     PSMoveProtocol
-    ${PROTOBUF_LIBRARIES})
+    Eigen3::Eigen
+    ${Protobuf_LIBRARIES})
+list(APPEND PSMOVECONFIGTOOL_INCL_DIRS ${Protobuf_INCLUDE_DIRS})
     
 # SDL/GL
-list(APPEND PSMOVECONFIGTOOL_INCL_DIRS ${SDL_GL_INCLUDE_DIRS})
-list(APPEND PSMOVECONFIGTOOL_REQ_LIBS ${SDL_GL_LIBS})
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+	list(APPEND PSMOVECONFIGTOOL_REQ_LIBS SDL2::SDL2 SDL2::SDL2main)
+ELSE()
+	list(APPEND PSMOVECONFIGTOOL_REQ_LIBS ${SDL2_LIBRARIES})
+ENDIF()
+list(APPEND PSMOVECONFIGTOOL_INCL_DIRS ${SDL2_INCLUDE_DIRS})
 
 # OpenCV
 list(APPEND PSMOVECONFIGTOOL_INCL_DIRS ${OpenCV_INCLUDE_DIRS})
 list(APPEND PSMOVECONFIGTOOL_REQ_LIBS ${OpenCV_LIBS})
 
-# Source files that are needed for the psmove config tool
-file(GLOB PSMOVECONFIGTOOL_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/*.cpp"
-    "${ROOT_DIR}/thirdparty/imgui/*.cpp"
-)
+#ImGui
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+	find_package(imgui CONFIG REQUIRED)
+    list(APPEND PSMOVECONFIGTOOL_REQ_LIBS imgui::imgui)
+ELSE()  #((${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR (${CMAKE_SYSTEM_NAME} MATCHES "Darwin"))
+    # No installable ImGui package on Linux/MacOS. Add headers and source manually. See build docs.
+    list(APPEND PSMOVECONFIGTOOL_INCL_DIRS
+        ${ROOT_DIR}/build_deps/imgui)
+    file(GLOB IMGUI_SRC "${ROOT_DIR}/build_deps/imgui/*.cpp")
+    list(APPEND PSMOVECONFIGTOOL_SRC ${IMGUI_SRC})
+ENDIF()
 
 # PSMoveConfigTool
 add_executable(PSMoveConfigTool ${PSMOVECONFIGTOOL_SRC})
-target_include_directories(PSMoveConfigTool PUBLIC ${PSMOVECONFIGTOOL_INCL_DIRS})
-target_link_libraries(PSMoveConfigTool ${PSMOVECONFIGTOOL_REQ_LIBS})
-
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-add_dependencies(PSMoveService opencv)
-ENDIF()
+target_include_directories(PSMoveConfigTool PRIVATE ${PSMOVECONFIGTOOL_INCL_DIRS})
+target_link_libraries(PSMoveConfigTool PRIVATE ${PSMOVECONFIGTOOL_REQ_LIBS})
 
 # Allow access to the protocol buffers (extracting response parameters)
 target_compile_definitions(PSMoveConfigTool
diff --git a/src/psmoveconfigtool/Renderer.cpp b/src/psmoveconfigtool/Renderer.cpp
index 962cbff5..ce7bebde 100644
--- a/src/psmoveconfigtool/Renderer.cpp
+++ b/src/psmoveconfigtool/Renderer.cpp
@@ -44,13 +44,14 @@ static const float k_camera_z_far= 5000.f;
 static const ImVec4 k_clear_color = ImColor(114, 144, 154);
 
 static const glm::vec3 k_psmove_frustum_color = glm::vec3(0.1f, 0.7f, 0.3f);
+static char* g_ClipboardTextData = NULL;
 
 //-- statics -----
 Renderer *Renderer::m_instance= NULL;
 
 //-- prototypes -----
-static const char* ImGui_ImplSdl_GetClipboardText();
-static void ImGui_ImplSdl_SetClipboardText(const char* text);
+static const char* ImGui_ImplSDL2_GetClipboardText(void*);
+static void ImGui_ImplSDL2_SetClipboardText(void*, const char* text);
 static void ImGui_ImplSdl_RenderDrawLists(ImDrawData* draw_data);
 
 //-- public methods -----
@@ -81,6 +82,8 @@ bool Renderer::init()
 {
     bool success = true;
 
+    // https://github.com/ocornut/imgui/blob/master/examples/example_sdl_opengl2/main.cpp
+
     Log_INFO("Renderer::init()", "Initializing Renderer Context");
 
     if (SDL_Init(SDL_INIT_VIDEO) == 0) 
@@ -103,12 +106,16 @@ bool Renderer::init()
         SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
         SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
 
+        SDL_DisplayMode current;
+        SDL_GetCurrentDisplayMode(0, &current);
+
 		snprintf(szWindowTitle, sizeof(szWindowTitle), "PSMove Config Tool");
+        SDL_WindowFlags window_flags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI);
         m_window = SDL_CreateWindow(szWindowTitle,
             SDL_WINDOWPOS_CENTERED,
             SDL_WINDOWPOS_CENTERED,
             k_window_pixel_width, k_window_pixel_height,
-            SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN);
+            window_flags);
         m_windowWidth= k_window_pixel_width;
         m_windowHeight= k_window_pixel_height;
 
@@ -132,7 +139,19 @@ bool Renderer::init()
     // Setup ImGui key-bindings and callback functions
     if (success)
     {
-        ImGuiIO& io = ImGui::GetIO();
+        ImGui::CreateContext();
+        ImGuiIO& io = ImGui::GetIO(); (void)io;
+
+        // Setup Dear ImGui style
+        ImGui::StyleColorsDark();
+        //ImGui::StyleColorsClassic();
+
+        // ImGui_ImplSDL2_InitForOpenGL(window, gl_context);  https://github.com/ocornut/imgui/blob/master/examples/imgui_impl_sdl.cpp#L123
+
+        //io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;       // We can honor GetMouseCursor() values (optional)
+        //io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;        // We can honor io.WantSetMousePos requests (optional, rarely used)
+        io.BackendPlatformName = "imgui_impl_sdl";
+
         io.KeyMap[ImGuiKey_Tab] = SDLK_TAB;                     // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
         io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT;
         io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT;
@@ -153,9 +172,12 @@ bool Renderer::init()
         io.KeyMap[ImGuiKey_Y] = SDLK_y;
         io.KeyMap[ImGuiKey_Z] = SDLK_z;
 
-        io.RenderDrawListsFn = ImGui_ImplSdl_RenderDrawLists;   // Alternatively you can set this to NULL and call ImGui::GetDrawData() after ImGui::Render() to get the same ImDrawData pointer.
-        io.SetClipboardTextFn = ImGui_ImplSdl_SetClipboardText;
-        io.GetClipboardTextFn = ImGui_ImplSdl_GetClipboardText;
+        io.RenderDrawListsFn = ImGui_ImplSdl_RenderDrawLists;
+        // Alternatively you can set this to NULL and call ImGui::GetDrawData() after ImGui::Render() to get the same ImDrawData pointer.
+
+        io.SetClipboardTextFn = ImGui_ImplSDL2_SetClipboardText;
+        io.GetClipboardTextFn = ImGui_ImplSDL2_GetClipboardText;
+        io.ClipboardUserData = NULL;
 
     #ifdef _WIN32
         SDL_SysWMinfo wmInfo;
@@ -164,6 +186,9 @@ bool Renderer::init()
         io.ImeWindowHandle = wmInfo.info.win.window;
     #endif
 
+        // https://github.com/ocornut/imgui/blob/master/examples/example_sdl_opengl2/main.cpp#L50
+        io.BackendRendererName = "imgui_impl_opengl2";
+
         m_Time= 0.0f;
         m_MouseWheel= 0.0f;
         m_FontTexture= 0;
@@ -201,7 +226,12 @@ void Renderer::destroy()
         m_FontTexture = 0;
     }
 
-    ImGui::Shutdown();
+    // Destroy last known clipboard data
+    if (g_ClipboardTextData)
+        SDL_free(g_ClipboardTextData);
+    g_ClipboardTextData = NULL;
+
+    ImGui::DestroyContext();
 
     if (m_glContext != NULL)
     {
@@ -226,6 +256,7 @@ void Renderer::destroy()
 
 bool Renderer::onSDLEvent(const SDL_Event *event)
 {
+    // https://github.com/ocornut/imgui/blob/master/examples/imgui_impl_sdl.cpp#L82
     ImGuiIO& io = ImGui::GetIO();
 
     switch (event->type)
@@ -327,7 +358,7 @@ void Renderer::renderUIBegin()
     // Setup time step
     Uint32 time = SDL_GetTicks();
     double current_time = time / 1000.0;
-    io.DeltaTime = m_Time > 0.0 ? (float)(current_time - m_Time) : (float)(1.0f/60.0f);
+    io.DeltaTime = (current_time - m_Time) > 0.0 ? (float)(current_time - m_Time) : (float)(1.0f/60.0f);
     m_Time = current_time;
 
     // Setup inputs
@@ -1293,12 +1324,15 @@ void drawVirtualHMDModel(const glm::mat4 &transform, const glm::vec3 &color)
 }
 
 // -- IMGUI Callbacks -----
-static const char* ImGui_ImplSdl_GetClipboardText()
+static const char* ImGui_ImplSDL2_GetClipboardText(void*)
 {
-	return SDL_GetClipboardText();
+    if (g_ClipboardTextData)
+        SDL_free(g_ClipboardTextData);
+    g_ClipboardTextData = SDL_GetClipboardText();
+    return g_ClipboardTextData;
 }
 
-static void ImGui_ImplSdl_SetClipboardText(const char* text)
+static void ImGui_ImplSDL2_SetClipboardText(void*, const char* text)
 {
     SDL_SetClipboardText(text);
 }
diff --git a/src/psmovemath/CMakeLists.txt b/src/psmovemath/CMakeLists.txt
index 43879b4b..9579ca6f 100644
--- a/src/psmovemath/CMakeLists.txt
+++ b/src/psmovemath/CMakeLists.txt
@@ -1,24 +1,18 @@
 cmake_minimum_required(VERSION 3.0)
 
-set(ROOT_DIR ${CMAKE_CURRENT_LIST_DIR}/../..)
-set(PSMOVE_MATH_INCL_DIRS)
+find_package(glm CONFIG REQUIRED)
 
-list(APPEND PSMOVE_MATH_INCL_DIRS
-    ${EIGEN3_INCLUDE_DIR}
-    ${ROOT_DIR}/thirdparty/glm/)
-
-# Source files that are needed for the static library
+# Source files that are needed for the object library
 file(GLOB PSMOVE_MATH_LIBRARY_SRC
     "${CMAKE_CURRENT_LIST_DIR}/*.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/*.h"
 )
 
-# Static library
-add_library(PSMoveMath STATIC ${PSMOVE_MATH_LIBRARY_SRC})
-
-target_include_directories(PSMoveMath PUBLIC ${PSMOVE_MATH_INCL_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
-set_target_properties(PSMoveMath PROPERTIES
-    COMPILE_FLAGS "-DBUILDING_STATIC_LIBRARY -fPIC")
+# Object library
+add_library(PSMoveMath OBJECT ${PSMOVE_MATH_LIBRARY_SRC})
+set_property(TARGET PSMoveMath PROPERTY POSITION_INDEPENDENT_CODE ON)
+# target_include_directories(PSMoveMath PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+target_link_libraries(PSMoveMath PRIVATE Eigen3::Eigen glm)
 
 #MacOS OpenCV must be self-built, this links against older std, which is hidden
 #Therefore the PSMoveConfigTool must be hidden
diff --git a/src/psmoveprotocol/CMakeLists.txt b/src/psmoveprotocol/CMakeLists.txt
index 3cb35952..fea24e60 100644
--- a/src/psmoveprotocol/CMakeLists.txt
+++ b/src/psmoveprotocol/CMakeLists.txt
@@ -1,14 +1,5 @@
+cmake_minimum_required(VERSION 3.12)
 set(PSMOVEPROTOCOL_LIBRARY_SRC)    # Container for source files
-set(PSMOVEPROTOCOL_INCLUDE_DIRS)   # Container for include directories
-set(PSMOVEPROTOCOL_REQUIRED_LIBS)  # Container for library dependencies
-
-# Dependencies
-
-# Protobuf
-list(APPEND PSMOVEPROTOCOL_INCLUDE_DIRS ${PROTOBUF_INCLUDE_DIRS})
-list(APPEND PSMOVEPROTOCOL_REQUIRED_LIBS ${PROTOBUF_LIBRARIES})
-protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS ${CMAKE_CURRENT_LIST_DIR}/PSMoveProtocol.proto)
-#See http://stackoverflow.com/questions/20824194/cmake-with-google-protocol-buffers
 
 # Source files and headers
 file(GLOB PSMOVEPROTOCOL_LIBRARY_SRC
@@ -16,15 +7,22 @@ file(GLOB PSMOVEPROTOCOL_LIBRARY_SRC
     "${CMAKE_CURRENT_LIST_DIR}/*.h"
 )
 
-list(APPEND PSMOVEPROTOCOL_LIBRARY_SRC ${PROTO_SRCS} ${PROTO_HDRS})
+# PSMoveProtocol library
+add_library(PSMoveProtocol OBJECT ${PSMOVEPROTOCOL_LIBRARY_SRC})
+set_property(TARGET PSMoveProtocol PROPERTY POSITION_INDEPENDENT_CODE ON)
+target_include_directories(PSMoveProtocol PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+	target_link_libraries(PSMoveProtocol PUBLIC protobuf::libprotoc protobuf::libprotobuf)
+ELSE()
+	target_link_libraries(PSMoveProtocol PUBLIC ${Protobuf_LIBRARIES})
+	target_include_directories(PSMoveProtocol PUBLIC ${Protobuf_INCLUDE_DIRS})
+ENDIF()
+protobuf_generate(
+    TARGET PSMoveProtocol
+    PROTOS ${CMAKE_CURRENT_LIST_DIR}/PSMoveProtocol.proto
+)
+
 
-# Static library
-add_library(PSMoveProtocol STATIC ${PSMOVEPROTOCOL_LIBRARY_SRC})
-target_include_directories(PSMoveProtocol PUBLIC ${PSMOVEPROTOCOL_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
-target_link_libraries(PSMoveProtocol PRIVATE ${PSMOVEPROTOCOL_REQUIRED_LIBS})
-set_target_properties(PSMoveProtocol PROPERTIES
-    COMPILE_FLAGS "-DBUILDING_STATIC_LIBRARY -fPIC")
-    
 # Install
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
     install(FILES ProtocolVersion.h SharedConstants.h
@@ -36,4 +34,4 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 ELSE() #Linux/Darwin
     install(FILES ProtocolVersion.h SharedConstants.h
 	DESTINATION include)
-ENDIF()
\ No newline at end of file
+ENDIF()
diff --git a/src/psmoveservice/CMakeLists.txt b/src/psmoveservice/CMakeLists.txt
index b51e42bc..82110ffe 100644
--- a/src/psmoveservice/CMakeLists.txt
+++ b/src/psmoveservice/CMakeLists.txt
@@ -1,290 +1,283 @@
-cmake_minimum_required(VERSION 3.0)
-
-# Dependencies
-set(PSMOVE_SERVICE_INCL_DIRS)
-set(PSMOVE_SERVICE_REQ_LIBS)
-
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${PLATFORM_LIBS})
-
-# Source files for PSMoveService
-file(GLOB PSMOVESERVICE_CONFIG_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig/*.h"
-)
-source_group("Config" FILES ${PSMOVESERVICE_CONFIG_SRC})
-
-file(GLOB PSMOVESERVICE_CONTROLLER_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/PSDualShock4/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSDualShock4/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveController/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveController/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/PSNaviController/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSNaviController/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/VirtualController/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/VirtualController/*.h"
-)
-source_group("Controller" FILES ${PSMOVESERVICE_CONTROLLER_SRC})
-
-file(GLOB PSMOVESERVICE_DEVICE_ENUM_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator/*.h"
-)
-source_group("Device\\Enumerator" FILES ${PSMOVESERVICE_DEVICE_ENUM_SRC})
-
-file(GLOB PSMOVESERVICE_DEVICE_INT_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Interface/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Interface/*.h"
-)
-source_group("Device\\Interface" FILES ${PSMOVESERVICE_DEVICE_INT_SRC})
-
-file(GLOB PSMOVESERVICE_DEVICE_MGR_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Manager/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Device/Manager/*.h"
-)
-source_group("Device\\Manager" FILES ${PSMOVESERVICE_DEVICE_MGR_SRC})
-
-file(GLOB PSMOVESERVICE_DEVICE_USB_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Device/USB/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Device/USB/*.h"
-)
-source_group("Device\\USB" FILES ${PSMOVESERVICE_DEVICE_USB_SRC})
-
-file(GLOB PSMOVESERVICE_DEVICE_VIEW_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Device/View/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Device/View/*.h"
-)
-source_group("Device\\View" FILES ${PSMOVESERVICE_DEVICE_VIEW_SRC})
-
-file(GLOB PSMOVESERVICE_HMD_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/VirtualHMD/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/VirtualHMD/*.h"
-)
-source_group("HMD" FILES ${PSMOVESERVICE_HMD_SRC})
-
-file(GLOB PSMOVESERVICE_FILTER_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Filter/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Filter/*.h"
-)
-source_group("Filter" FILES ${PSMOVESERVICE_FILTER_SRC})
-
-list(APPEND PSMOVESERVICE_PLATFORM_SRC
-    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueries.h
-    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequests.h
-    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequests.cpp)
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    list(APPEND PSMOVESERVICE_PLATFORM_SRC
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsWin32.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesWin32.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPIWin32.h
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPIWin32.cpp)
-ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    list(APPEND PSMOVESERVICE_PLATFORM_SRC
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsOSX.mm
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesOSX.mm)
-ELSE()
-    list(APPEND PSMOVESERVICE_PLATFORM_SRC
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsLinux.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesLinux.cpp)
-ENDIF()
-source_group("Platform" FILES ${PSMOVESERVICE_PLATFORM_SRC})
-
-file(GLOB PSMOVESERVICE_SERVER_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Server/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Server/*.h"
-)
-source_group("Server" FILES ${PSMOVESERVICE_SERVER_SRC})
-
-file(GLOB PSMOVESERVICE_TRACKER_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/*.h"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye/*.h"
-)
-source_group("Tracker" FILES ${PSMOVESERVICE_TRACKER_SRC})
-
-file(GLOB PSMOVESERVICE_UTILS_SRC
-    "${CMAKE_CURRENT_LIST_DIR}/Utils/*.cpp"
-    "${CMAKE_CURRENT_LIST_DIR}/Utils/*.h"
-)
-source_group("Utils" FILES ${PSMOVESERVICE_UTILS_SRC})
-
-set(PSMOVESERVICE_SRC
-    ${PSMOVESERVICE_CONFIG_SRC}
-    ${PSMOVESERVICE_CONTROLLER_SRC}
-    ${PSMOVESERVICE_DEVICE_ENUM_SRC}
-    ${PSMOVESERVICE_DEVICE_INT_SRC}
-    ${PSMOVESERVICE_DEVICE_MGR_SRC}
-    ${PSMOVESERVICE_DEVICE_USB_SRC}
-    ${PSMOVESERVICE_DEVICE_VIEW_SRC}
-    ${PSMOVESERVICE_HMD_SRC}
-    ${PSMOVESERVICE_FILTER_SRC}
-    ${PSMOVESERVICE_PLATFORM_SRC}
-    ${PSMOVESERVICE_SERVER_SRC} 
-    ${PSMOVESERVICE_TRACKER_SRC}
-    ${PSMOVESERVICE_UTILS_SRC}
-)
-
-list(APPEND PSMOVE_SERVICE_INCL_DIRS
-    ${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator
-    ${CMAKE_CURRENT_LIST_DIR}/Device/Interface
-    ${CMAKE_CURRENT_LIST_DIR}/Device/Manager
-    ${CMAKE_CURRENT_LIST_DIR}/Device/USB
-    ${CMAKE_CURRENT_LIST_DIR}/Device/View
-    ${CMAKE_CURRENT_LIST_DIR}/Filter
-    ${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD
-    ${CMAKE_CURRENT_LIST_DIR}/VirtualHMD
-    ${CMAKE_CURRENT_LIST_DIR}/Platform
-    ${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig
-    ${CMAKE_CURRENT_LIST_DIR}/PSDualShock4
-    ${CMAKE_CURRENT_LIST_DIR}/PSMoveController
-    ${CMAKE_CURRENT_LIST_DIR}/PSNaviController
-    ${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker
-    ${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye
-    ${CMAKE_CURRENT_LIST_DIR}/Server
-    ${CMAKE_CURRENT_LIST_DIR}/Utils
-    ${CMAKE_CURRENT_LIST_DIR}/VirtualController
-)
-
-# Lockfree Queue
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/thirdparty/lockfreequeue)
-
-# Eigen math library
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${EIGEN3_INCLUDE_DIR})
-
-# mherb/Kalman library
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/thirdparty/kalman/include)
-
-# Boost.Application and type_index are header only (?)
-list(APPEND PSMOVE_SERVICE_INCL_DIRS
-    ${ROOT_DIR}/thirdparty/Boost.Application/include/
-    ${ROOT_DIR}/thirdparty/Boost.Application/example/
-    ${ROOT_DIR}/thirdparty/type_index/include/)
-
-# Protobuf (already found in top-level CMakeLists)
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${PROTOBUF_INCLUDE_DIRS})
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${PROTOBUF_LIBRARIES})
-
-# Boost. TODO: Trim this list.
-find_package(Boost REQUIRED QUIET COMPONENTS atomic chrono filesystem program_options system thread)
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${Boost_INCLUDE_DIRS})
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${Boost_LIBRARIES})
-
-# hidapi
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${HIDAPI_INCLUDE_DIRS})
-list(APPEND PSMOVESERVICE_SRC ${HIDAPI_SRC})
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${HIDAPI_LIBS})
-
-# LibUSB for device management
-find_package(USB1 REQUIRED)
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${LIBUSB_INCLUDE_DIR})
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${LIBUSB_LIBRARIES})
-
-# libstem_gamepad
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${LIBSTEM_GAMEPAD_INCLUDE_DIRS})
-list(APPEND PSMOVESERVICE_SRC ${LIBSTEM_GAMEPAD_SRC})
-
-# PSMoveDataFrame
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol/)
-list(APPEND PSMOVE_SERVICE_REQ_LIBS PSMoveProtocol)
-
-# PSMoveMath
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/src/psmovemath/)
-list(APPEND PSMOVE_SERVICE_REQ_LIBS PSMoveMath)
-
-# Tracker
-# Requires OpenCV, PS3EYEDriver (Mac/Win64), CLEye (Win32)
-
-# OpenCV - empty on Windows
-IF(MSVC) # not necessary for OpenCV > 2.8 on other build systems
-    list(APPEND PSMOVE_SERVICE_INCL_DIRS ${OpenCV_INCLUDE_DIRS}) 
-ENDIF()
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${OpenCV_LIBS})
-
-# PS Eye - This brings in LIBUSB on Windows and Mac, but not Linux
-list(APPEND PSMOVESERVICE_SRC ${PSEYE_SRC})
-list(APPEND PSMOVE_SERVICE_INCL_DIRS ${PSEYE_INCLUDE_DIRS})
-list(APPEND PSMOVE_SERVICE_REQ_LIBS ${PSEYE_LIBRARIES})
-
-add_executable(PSMoveService ${PSMOVESERVICE_SRC})
-target_include_directories(PSMoveService PUBLIC ${PSMOVE_SERVICE_INCL_DIRS})
-target_link_libraries(PSMoveService ${PSMOVE_SERVICE_REQ_LIBS})
-
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    add_dependencies(PSMoveService opencv)
-ENDIF()
-
-# Install
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    install(TARGETS PSMoveService
-        CONFIGURATIONS Debug
-        RUNTIME DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
-        LIBRARY DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib
-        ARCHIVE DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib)
-    install(TARGETS PSMoveService
-        CONFIGURATIONS Release
-        RUNTIME DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
-        LIBRARY DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib
-        ARCHIVE DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib)        
-    IF(${ISWIN32})
-        install(DIRECTORY "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/"
-            CONFIGURATIONS Debug
-            DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
-            FILES_MATCHING PATTERN "*.dll")
-        install(DIRECTORY "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/"
-            CONFIGURATIONS Release
-            DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
-            FILES_MATCHING PATTERN "*.dll")            
-    ENDIF()#ISWIN32
-ELSE() #Linux/Darwin
-ENDIF()
-
-# On Windows builds we want to create an additional admin version of PSMS.
-# This is used for when we want to pair new controllers.
-# Part of the pairing process in Windows requires manually poking entries in the
-# "SYSTEM\CurrentControlSet\Services\HidBth\Parameters\Devices" registry key folder,
-# which only an admin account can do.
-# Since you can't change the permissions of an exe after it's started
-# and since relaunching a process as admin is un-reliable, having a second
-# admin version of the PSMS exe is the simplest option
-# https://stackoverflow.com/questions/19617955/c-run-program-as-administrator
-# https://blogs.msdn.microsoft.com/winsdk/2013/03/22/how-to-launch-a-process-as-a-full-administrator-when-uac-is-enabled/
-IF(MSVC)
-	# Create the new PSMS admin exe (same code as PSMS)
-	add_executable(PSMoveServiceAdmin ${PSMOVESERVICE_SRC})
-	target_include_directories(PSMoveServiceAdmin PUBLIC ${PSMOVE_SERVICE_INCL_DIRS})
-	target_link_libraries(PSMoveServiceAdmin ${PSMOVE_SERVICE_REQ_LIBS})
-	
-	add_dependencies(PSMoveServiceAdmin opencv)
-	
-	# set the UAC level in the property sheet
-    set_target_properties(PSMoveServiceAdmin PROPERTIES LINK_FLAGS "/level='requireAdministrator' /uiAccess='false'")
-	
-    install(TARGETS PSMoveServiceAdmin
-        CONFIGURATIONS Debug
-        RUNTIME DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
-        LIBRARY DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib
-        ARCHIVE DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib)
-    install(TARGETS PSMoveServiceAdmin
-        CONFIGURATIONS Release
-        RUNTIME DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
-        LIBRARY DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib
-        ARCHIVE DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib)    	
-ENDIF()
-
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    IF(NOT(${CMAKE_C_SIZEOF_DATA_PTR} EQUAL 8))
-        IF(${CL_EYE_SDK_PATH} STREQUAL "CL_EYE_SDK_PATH-NOTFOUND")
-            #If the developer does not have CLEyeMulticam.dll on their system,
-            #copy it to the correct directory to prevent crashes.
-            #Windows service binaries should be distributed with this DLL.
-            #It will be up to CLEYE SDK users to delete this version of the DLL
-            #to use their system version.
-            add_custom_command(TARGET PSMoveService POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different
-                    "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/CLEyeMulticam.dll"
-                    $<TARGET_FILE_DIR:PSMoveService>)
-        ENDIF()
-    ENDIF()
-ENDIF()#ISWIN32 and CL_EYE_SDK_PATH-NOTFOUND
+cmake_minimum_required(VERSION 3.0)
+
+# Dependencies
+set(PSMOVE_SERVICE_INCL_DIRS)
+set(PSMOVE_SERVICE_REQ_LIBS)
+
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${PLATFORM_LIBS})
+
+# Source files for PSMoveService
+file(GLOB PSMOVESERVICE_CONFIG_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig/*.h"
+)
+source_group("Config" FILES ${PSMOVESERVICE_CONFIG_SRC})
+
+file(GLOB PSMOVESERVICE_CONTROLLER_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/PSDualShock4/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSDualShock4/*.h"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveController/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveController/*.h"
+    "${CMAKE_CURRENT_LIST_DIR}/PSNaviController/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSNaviController/*.h"
+    "${CMAKE_CURRENT_LIST_DIR}/VirtualController/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/VirtualController/*.h"
+)
+source_group("Controller" FILES ${PSMOVESERVICE_CONTROLLER_SRC})
+
+file(GLOB PSMOVESERVICE_DEVICE_ENUM_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator/*.h"
+)
+source_group("Device\\Enumerator" FILES ${PSMOVESERVICE_DEVICE_ENUM_SRC})
+
+file(GLOB PSMOVESERVICE_DEVICE_INT_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Interface/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Interface/*.h"
+)
+source_group("Device\\Interface" FILES ${PSMOVESERVICE_DEVICE_INT_SRC})
+
+file(GLOB PSMOVESERVICE_DEVICE_MGR_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Manager/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Device/Manager/*.h"
+)
+source_group("Device\\Manager" FILES ${PSMOVESERVICE_DEVICE_MGR_SRC})
+
+file(GLOB PSMOVESERVICE_DEVICE_USB_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Device/USB/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Device/USB/*.h"
+)
+source_group("Device\\USB" FILES ${PSMOVESERVICE_DEVICE_USB_SRC})
+
+file(GLOB PSMOVESERVICE_DEVICE_VIEW_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Device/View/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Device/View/*.h"
+)
+source_group("Device\\View" FILES ${PSMOVESERVICE_DEVICE_VIEW_SRC})
+
+file(GLOB PSMOVESERVICE_HMD_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD/*.h"
+    "${CMAKE_CURRENT_LIST_DIR}/VirtualHMD/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/VirtualHMD/*.h"
+)
+source_group("HMD" FILES ${PSMOVESERVICE_HMD_SRC})
+
+file(GLOB PSMOVESERVICE_FILTER_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Filter/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Filter/*.h"
+)
+source_group("Filter" FILES ${PSMOVESERVICE_FILTER_SRC})
+
+list(APPEND PSMOVESERVICE_PLATFORM_SRC
+    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueries.h
+    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequests.h
+    ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequests.cpp)
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    list(APPEND PSMOVESERVICE_PLATFORM_SRC
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsWin32.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesWin32.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPIWin32.h
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPIWin32.cpp)
+ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    list(APPEND PSMOVESERVICE_PLATFORM_SRC
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsOSX.mm
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesOSX.mm)
+ELSE()
+    list(APPEND PSMOVESERVICE_PLATFORM_SRC
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothRequestsLinux.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/BluetoothQueriesLinux.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPILinux.h
+        ${CMAKE_CURRENT_LIST_DIR}/Platform/PlatformDeviceAPILinux.cpp)
+ENDIF()
+source_group("Platform" FILES ${PSMOVESERVICE_PLATFORM_SRC})
+
+file(GLOB PSMOVESERVICE_SERVER_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Server/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Server/*.h"
+)
+source_group("Server" FILES ${PSMOVESERVICE_SERVER_SRC})
+
+file(GLOB PSMOVESERVICE_TRACKER_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/*.h"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye/*.h"
+)
+source_group("Tracker" FILES ${PSMOVESERVICE_TRACKER_SRC})
+
+file(GLOB PSMOVESERVICE_UTILS_SRC
+    "${CMAKE_CURRENT_LIST_DIR}/Utils/*.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Utils/*.h"
+)
+source_group("Utils" FILES ${PSMOVESERVICE_UTILS_SRC})
+
+set(PSMOVESERVICE_SRC
+    ${PSMOVESERVICE_CONFIG_SRC}
+    ${PSMOVESERVICE_CONTROLLER_SRC}
+    ${PSMOVESERVICE_DEVICE_ENUM_SRC}
+    ${PSMOVESERVICE_DEVICE_INT_SRC}
+    ${PSMOVESERVICE_DEVICE_MGR_SRC}
+    ${PSMOVESERVICE_DEVICE_USB_SRC}
+    ${PSMOVESERVICE_DEVICE_VIEW_SRC}
+    ${PSMOVESERVICE_HMD_SRC}
+    ${PSMOVESERVICE_FILTER_SRC}
+    ${PSMOVESERVICE_PLATFORM_SRC}
+    ${PSMOVESERVICE_SERVER_SRC} 
+    ${PSMOVESERVICE_TRACKER_SRC}
+    ${PSMOVESERVICE_UTILS_SRC}
+)
+
+list(APPEND PSMOVE_SERVICE_INCL_DIRS
+    ${CMAKE_CURRENT_LIST_DIR}/Device/Enumerator
+    ${CMAKE_CURRENT_LIST_DIR}/Device/Interface
+    ${CMAKE_CURRENT_LIST_DIR}/Device/Manager
+    ${CMAKE_CURRENT_LIST_DIR}/Device/USB
+    ${CMAKE_CURRENT_LIST_DIR}/Device/View
+    ${CMAKE_CURRENT_LIST_DIR}/Filter
+    ${CMAKE_CURRENT_LIST_DIR}/MorpheusHMD
+    ${CMAKE_CURRENT_LIST_DIR}/VirtualHMD
+    ${CMAKE_CURRENT_LIST_DIR}/Platform
+    ${CMAKE_CURRENT_LIST_DIR}/PSMoveConfig
+    ${CMAKE_CURRENT_LIST_DIR}/PSDualShock4
+    ${CMAKE_CURRENT_LIST_DIR}/PSMoveController
+    ${CMAKE_CURRENT_LIST_DIR}/PSNaviController
+    ${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker
+    ${CMAKE_CURRENT_LIST_DIR}/PSMoveTracker/PSEye
+    ${CMAKE_CURRENT_LIST_DIR}/Server
+    ${CMAKE_CURRENT_LIST_DIR}/Utils
+    ${CMAKE_CURRENT_LIST_DIR}/VirtualController
+)
+
+# Lockfree Queue
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/thirdparty/lockfreequeue)
+
+# Eigen math library
+list(APPEND PSMOVE_SERVICE_REQ_LIBS Eigen3::Eigen)
+
+# mherb/Kalman library
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/thirdparty/kalman/include)
+
+# Boost.Application and type_index are header only (?)
+list(APPEND PSMOVE_SERVICE_INCL_DIRS
+    ${ROOT_DIR}/thirdparty/Boost.Application/include/
+    ${ROOT_DIR}/thirdparty/Boost.Application/example/)
+
+# Protobuf (already found in top-level CMakeLists)
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${Protobuf_INCLUDE_DIRS})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${Protobuf_LIBRARIES})
+
+# Boost. TODO: Trim this list.
+find_package(Boost REQUIRED QUIET COMPONENTS atomic chrono filesystem program_options system thread)
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${Boost_INCLUDE_DIRS})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${Boost_LIBRARIES})
+
+# hidapi
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${HIDAPI_INCLUDE_DIRS})
+list(APPEND PSMOVESERVICE_SRC ${HIDAPI_SRC})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${HIDAPI_LIBRARIES})
+
+# LibUSB for device management
+find_package(USB1 REQUIRED)
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${LIBUSB_INCLUDE_DIR})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${LIBUSB_LIBRARIES})
+
+# libstem_gamepad
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${LIBSTEM_GAMEPAD_INCLUDE_DIRS})
+list(APPEND PSMOVESERVICE_SRC ${LIBSTEM_GAMEPAD_SRC})
+
+# PSMoveProtocol OBJECT lib
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol/)
+list(APPEND PSMOVE_SERVICE_REQ_LIBS PSMoveProtocol)
+
+# PSMoveMath OBJECT lib
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${ROOT_DIR}/src/psmovemath/)
+list(APPEND PSMOVE_SERVICE_REQ_LIBS PSMoveMath)
+
+# Tracker
+# Requires OpenCV, PS3EYEDriver (Mac/Win64), CLEye (Win32)
+
+# OpenCV
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${OpenCV_INCLUDE_DIRS})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${OpenCV_LIBS})
+
+# PS Eye - This brings in LIBUSB on Windows and Mac, but not Linux
+list(APPEND PSMOVESERVICE_SRC ${PSEYE_SRC})
+list(APPEND PSMOVE_SERVICE_INCL_DIRS ${PSEYE_INCLUDE_DIRS})
+list(APPEND PSMOVE_SERVICE_REQ_LIBS ${PSEYE_LIBRARIES})
+
+add_executable(PSMoveService ${PSMOVESERVICE_SRC})
+target_include_directories(PSMoveService PRIVATE ${PSMOVE_SERVICE_INCL_DIRS})
+target_link_libraries(PSMoveService PRIVATE ${PSMOVE_SERVICE_REQ_LIBS})
+
+# Install
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    install(TARGETS PSMoveService
+        CONFIGURATIONS Debug
+        RUNTIME DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
+        LIBRARY DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib
+        ARCHIVE DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib)
+    install(TARGETS PSMoveService
+        CONFIGURATIONS Release
+        RUNTIME DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
+        LIBRARY DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib
+        ARCHIVE DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib)        
+    IF(${ISWIN32})
+        install(DIRECTORY "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/"
+            CONFIGURATIONS Debug
+            DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
+            FILES_MATCHING PATTERN "*.dll")
+        install(DIRECTORY "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/"
+            CONFIGURATIONS Release
+            DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
+            FILES_MATCHING PATTERN "*.dll")            
+    ENDIF()#ISWIN32
+ELSE() #Linux/Darwin
+ENDIF()
+
+# On Windows builds we want to create an additional admin version of PSMS.
+# This is used for when we want to pair new controllers.
+# Part of the pairing process in Windows requires manually poking entries in the
+# "SYSTEM\CurrentControlSet\Services\HidBth\Parameters\Devices" registry key folder,
+# which only an admin account can do.
+# Since you can't change the permissions of an exe after it's started
+# and since relaunching a process as admin is un-reliable, having a second
+# admin version of the PSMS exe is the simplest option
+# https://stackoverflow.com/questions/19617955/c-run-program-as-administrator
+# https://blogs.msdn.microsoft.com/winsdk/2013/03/22/how-to-launch-a-process-as-a-full-administrator-when-uac-is-enabled/
+IF(MSVC)
+	# Create the new PSMS admin exe (same code as PSMS)
+	add_executable(PSMoveServiceAdmin ${PSMOVESERVICE_SRC})
+	target_include_directories(PSMoveServiceAdmin PRIVATE ${PSMOVE_SERVICE_INCL_DIRS})
+	target_link_libraries(PSMoveServiceAdmin ${PSMOVE_SERVICE_REQ_LIBS})
+	
+	# set the UAC level in the property sheet
+    set_target_properties(PSMoveServiceAdmin PROPERTIES LINK_FLAGS "/level='requireAdministrator' /uiAccess='false'")
+	
+    install(TARGETS PSMoveServiceAdmin
+        CONFIGURATIONS Debug
+        RUNTIME DESTINATION ${PSM_DEBUG_INSTALL_PATH}/bin
+        LIBRARY DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib
+        ARCHIVE DESTINATION ${PSM_DEBUG_INSTALL_PATH}/lib)
+    install(TARGETS PSMoveServiceAdmin
+        CONFIGURATIONS Release
+        RUNTIME DESTINATION ${PSM_RELEASE_INSTALL_PATH}/bin
+        LIBRARY DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib
+        ARCHIVE DESTINATION ${PSM_RELEASE_INSTALL_PATH}/lib)    	
+ENDIF()
+
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
+    IF(NOT(${CMAKE_C_SIZEOF_DATA_PTR} EQUAL 8))
+        IF(${CL_EYE_SDK_PATH} STREQUAL "CL_EYE_SDK_PATH-NOTFOUND")
+            #If the developer does not have CLEyeMulticam.dll on their system,
+            #copy it to the correct directory to prevent crashes.
+            #Windows service binaries should be distributed with this DLL.
+            #It will be up to CLEYE SDK users to delete this version of the DLL
+            #to use their system version.
+            add_custom_command(TARGET PSMoveService POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                    "${ROOT_DIR}/thirdparty/CLEYE/x86/bin/CLEyeMulticam.dll"
+                    $<TARGET_FILE_DIR:PSMoveService>)
+        ENDIF()
+    ENDIF()
+ENDIF()#ISWIN32 and CL_EYE_SDK_PATH-NOTFOUND
diff --git a/src/psmoveservice/Device/View/ServerTrackerView.cpp b/src/psmoveservice/Device/View/ServerTrackerView.cpp
index 86ac842e..b054702f 100644
--- a/src/psmoveservice/Device/View/ServerTrackerView.cpp
+++ b/src/psmoveservice/Device/View/ServerTrackerView.cpp
@@ -542,8 +542,8 @@ class OpenCVBufferState
             t_opencv_int_contour_list contours;
             cv::findContours(gsLowerROI,
                              contours,
-                             CV_RETR_EXTERNAL,
-                             CV_CHAIN_APPROX_SIMPLE,  //CV_CHAIN_APPROX_NONE?
+                             cv::RETR_EXTERNAL,
+                             cv::CHAIN_APPROX_SIMPLE,  //CV_CHAIN_APPROX_NONE?
                              ofs);
 
             // Compute the area of each contour
diff --git a/src/psmoveservice/PSMoveTracker/PS3EyeTracker.cpp b/src/psmoveservice/PSMoveTracker/PS3EyeTracker.cpp
index 33208de8..27a3258f 100644
--- a/src/psmoveservice/PSMoveTracker/PS3EyeTracker.cpp
+++ b/src/psmoveservice/PSMoveTracker/PS3EyeTracker.cpp
@@ -298,7 +298,7 @@ bool PS3EyeTracker::open() // Opens the first HID device for the tracker
 bool PS3EyeTracker::matchesDeviceEnumerator(const DeviceEnumerator *enumerator) const
 {
     // Down-cast the enumerator so we can use the correct get_path.
-    const TrackerDeviceEnumerator *pEnum = static_cast<const TrackerDeviceEnumerator *>(enumerator);
+    const auto *pEnum = dynamic_cast<const TrackerDeviceEnumerator *>(enumerator);
 
     bool matches = false;
 
@@ -314,7 +314,7 @@ bool PS3EyeTracker::matchesDeviceEnumerator(const DeviceEnumerator *enumerator)
 
 bool PS3EyeTracker::open(const DeviceEnumerator *enumerator)
 {
-    const TrackerDeviceEnumerator *tracker_enumerator = static_cast<const TrackerDeviceEnumerator *>(enumerator);
+    const auto *tracker_enumerator = dynamic_cast<const TrackerDeviceEnumerator *>(enumerator);
     const char *cur_dev_path = tracker_enumerator->get_path();
 
     bool bSuccess = false;
@@ -446,7 +446,7 @@ CommonDeviceState::eDeviceType PS3EyeTracker::getDeviceType() const
 
 const CommonDeviceState *PS3EyeTracker::getState(int lookBack) const
 {
-    const int queueSize = static_cast<int>(TrackerStates.size());
+    const auto queueSize = static_cast<int>(TrackerStates.size());
     const CommonDeviceState * result =
         (lookBack < queueSize) ? &TrackerStates.at(queueSize - lookBack - 1) : nullptr;
 
@@ -473,31 +473,50 @@ bool PS3EyeTracker::getVideoFrameDimensions(
 
     if (out_width != nullptr)
     {
-        int width = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FRAME_WIDTH));
+        auto width = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FRAME_WIDTH));
 
         if (out_stride != nullptr)
         {
-            int format = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FORMAT));
+            // We need to determine the number of bytes per pixel.
+            // which VideoCapture->get() property?
+            // CAP_PROP_FOURCC: 4-character code of codec. See http://www.fourcc.org/codecs.php
+            // CAP_PROP_MODE: Backend-specific value indicating the current capture mode.
+            // CAP_PROP_FORMAT: Get the Format of the Mat objects returned by VideoCapture::retrieve()
+            // --> CV_MAKETYPE(IPL2CV_DEPTH(frame.depth), frame.nChannels)
+
+            auto format = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FORMAT));
             int bytes_per_pixel;
 
             if (format != -1)
             {
-                switch (format)
+                // format is from an enum, with entries structured as
+                // CV_N(S|U)CK where N is the depth, Signed or Unsigned, K is the number of channels per pixel.
+                // https://stackoverflow.com/questions/14364563/minmaxloc-datatype/14365886#14365886
+                int chans_per_pixel = (format >> CV_CN_SHIFT) + 1;
+                int mat_depth = CV_MAT_DEPTH(format);
+                int bytes_per_chan;
+                switch (mat_depth)
                 {
-                case cv::CAP_MODE_BGR:
-                case cv::CAP_MODE_RGB:
-                    bytes_per_pixel = 3;
+                case CV_8U:
+                case CV_8S:
+                    bytes_per_chan = 1;
                     break;
-                case cv::CAP_MODE_YUYV:
-                    bytes_per_pixel = 2;
+                case CV_16U:
+                case CV_16S:
+                    bytes_per_chan = 2;
                     break;
-                case cv::CAP_MODE_GRAY:
-                    bytes_per_pixel = 1;
+                case CV_32S:
+                case CV_32F:
+                    bytes_per_chan = 3;
+                    break;
+                case CV_64F:
+                    bytes_per_chan = 4;
                     break;
                 default:
                     assert(false && "Unknown video format?");
                     break;
                 }
+                bytes_per_pixel = bytes_per_chan * chans_per_pixel;
             }
             else
             {
@@ -514,7 +533,7 @@ bool PS3EyeTracker::getVideoFrameDimensions(
 
     if (out_height != nullptr)
     {
-        int height = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FRAME_HEIGHT));
+        auto height = static_cast<int>(VideoCapture->get(cv::CAP_PROP_FRAME_HEIGHT));
 
         *out_height = height;
     }
@@ -706,7 +725,7 @@ void PS3EyeTracker::gatherTrackerOptions(
     PSMoveProtocol::Response_ResultTrackerSettings* settings) const
 {
     PSMoveProtocol::OptionSet *optionSet = settings->add_option_sets();
-    
+
     optionSet->set_option_name(OPTION_FOV_SETTING);
     optionSet->add_option_strings(OPTION_FOV_RED_DOT);
     optionSet->add_option_strings(OPTION_FOV_BLUE_DOT);
@@ -719,8 +738,8 @@ bool PS3EyeTracker::setOptionIndex(
 {
     bool bValidOption = false;
 
-    if (option_name == OPTION_FOV_SETTING && 
-        option_index >= 0 && 
+    if (option_name == OPTION_FOV_SETTING &&
+        option_index >= 0 &&
         option_index < PS3EyeTrackerConfig::eFOVSetting::MAX_FOV_SETTINGS)
     {
         cfg.fovSetting = static_cast<PS3EyeTrackerConfig::eFOVSetting>(option_index);
@@ -733,7 +752,7 @@ bool PS3EyeTracker::setOptionIndex(
 }
 
 bool PS3EyeTracker::getOptionIndex(
-    const std::string &option_name, 
+    const std::string &option_name,
     int &out_option_index) const
 {
     bool bValidOption = false;
@@ -748,7 +767,7 @@ bool PS3EyeTracker::getOptionIndex(
 }
 
 void PS3EyeTracker::gatherTrackingColorPresets(
-	const std::string &controller_serial, 
+	const std::string &controller_serial,
     PSMoveProtocol::Response_ResultTrackerSettings* settings) const
 {
 	const CommonHSVColorRangeTable *table= cfg.getColorRangeTable(controller_serial);
@@ -756,7 +775,7 @@ void PS3EyeTracker::gatherTrackingColorPresets(
     for (int list_index = 0; list_index < MAX_TRACKING_COLOR_TYPES; ++list_index)
     {
         const CommonHSVColorRange &hsvRange = table->color_presets[list_index];
-        const eCommonTrackingColorID colorType = static_cast<eCommonTrackingColorID>(list_index);
+        const auto colorType = static_cast<eCommonTrackingColorID>(list_index);
 
         PSMoveProtocol::TrackingColorPreset *colorPreset= settings->add_color_presets();
         colorPreset->set_color_type(static_cast<PSMoveProtocol::TrackingColorType>(colorType));
@@ -770,8 +789,8 @@ void PS3EyeTracker::gatherTrackingColorPresets(
 }
 
 void PS3EyeTracker::setTrackingColorPreset(
-	const std::string &controller_serial, 
-    eCommonTrackingColorID color, 
+	const std::string &controller_serial,
+    eCommonTrackingColorID color,
     const CommonHSVColorRange *preset)
 {
 //    cfg.ColorPresets[color] = *preset; // from generic_camera conflict
@@ -782,8 +801,8 @@ void PS3EyeTracker::setTrackingColorPreset(
 }
 
 void PS3EyeTracker::getTrackingColorPreset(
-	const std::string &controller_serial, 
-    eCommonTrackingColorID color, 
+	const std::string &controller_serial,
+    eCommonTrackingColorID color,
     CommonHSVColorRange *out_preset) const
 {
 	const CommonHSVColorRangeTable *table= cfg.getColorRangeTable(controller_serial);
diff --git a/src/psmoveservice/PSMoveTracker/PSEye/PSEyeVideoCapture.cpp b/src/psmoveservice/PSMoveTracker/PSEye/PSEyeVideoCapture.cpp
index a51ead29..61bacbb6 100644
--- a/src/psmoveservice/PSMoveTracker/PSEye/PSEyeVideoCapture.cpp
+++ b/src/psmoveservice/PSMoveTracker/PSEye/PSEyeVideoCapture.cpp
@@ -39,7 +39,7 @@ enum
 class cv::IVideoCapture
 {
 public:
-    virtual ~IVideoCapture() {}
+    virtual ~IVideoCapture() = default;
     virtual double getProperty(int) const { return 0; }
     virtual bool setProperty(int, double) { return false; }
     virtual bool grabFrame() = 0;
@@ -516,17 +516,13 @@ bool PSEyeVideoCapture::open(int index)
     }
 
 	// PS3EYE-specific camera capture if available, else use base class open()
-
-    //###HipsterSloth $TODO
-    // Disabling the OpenCV camera open fallback.
-    // We don't officially support anything but the PS3Eye camera at the moment
-    // and it's currently confusing debugging other peoples camera issues with 
-    // this code path in place (random web cams getting opened)
-    //if (!isOpened())
-    //{
-    //    std::cout << "Attempting cv::VideoCapture::open(index)" << std::endl;
-    //    return cv::VideoCapture::open(index);
-    //}
+#ifdef ENABLE_WEBCAM
+    if (!isOpened())
+    {
+        std::cout << "Attempting cv::VideoCapture::open(index)" << std::endl;
+        return cv::VideoCapture::open(index);
+    }
+#endif
 
     return isOpened();
 }
@@ -612,6 +608,7 @@ double PSEyeVideoCapture::get(int propId) const
         }
     }
 #endif
+    // propId from cv::VideoCaptureProperties
     return cv::VideoCapture::get(propId);
 }
 
diff --git a/src/psmoveservice/Platform/BluetoothQueriesLinux.cpp b/src/psmoveservice/Platform/BluetoothQueriesLinux.cpp
index 69e662a5..37c538ce 100644
--- a/src/psmoveservice/Platform/BluetoothQueriesLinux.cpp
+++ b/src/psmoveservice/Platform/BluetoothQueriesLinux.cpp
@@ -8,11 +8,22 @@
 #include <assert.h>
 #include <sstream>
 #include <iomanip>
+#include <vector>
 
 
 //-- Queries -----
 bool bluetooth_get_host_address(std::string &out_address)
 {
     bool bSuccess = true;
+
+    bdaddr_t btaddr;
+    char pszaddr[18];
+
+    // Assume only one bt adapter.
+    int dev_id = hci_get_route(NULL);
+    hci_devba(dev_id, &btaddr);
+    ba2str(&btaddr, pszaddr);
+    out_address.assign(pszaddr);
+
     return bSuccess;
 }
\ No newline at end of file
diff --git a/src/psmoveservice/Platform/BluetoothRequestsLinux.cpp b/src/psmoveservice/Platform/BluetoothRequestsLinux.cpp
index 19d250ce..a6baae87 100644
--- a/src/psmoveservice/Platform/BluetoothRequestsLinux.cpp
+++ b/src/psmoveservice/Platform/BluetoothRequestsLinux.cpp
@@ -323,6 +323,46 @@ AsyncBluetoothPairDeviceRequest::start()
     bool success= true;
     const int controller_id= m_controllerView->getDeviceID();
 
+    // Reset the pairing device state
+    BluetoothPairDeviceState *state= reinterpret_cast<BluetoothPairDeviceState *>(m_internal_state);
+    state->initialize(controller_id);
+    state->bUsesAuthentication= m_controllerView->getUsesBluetoothAuthentication();
+    state->controller_serial_string= m_controllerView->getSerial();
+    state->controller_device_type= m_controllerView->getControllerDeviceType();
+
+    // Make sure the controller we're working with is a USB connection
+    if (success && m_controllerView->getIsOpen() && m_controllerView->getIsBluetooth())
+    {
+        SERVER_LOG_ERROR("AsyncBluetoothPairDeviceRequest")
+                << "Controller " << controller_id
+                << " isn't an open USB device";
+        success= false;
+    }
+
+    // Find the bluetooth address of the host adapter
+    if (success)
+    {
+        success= AsyncBluetoothPairDeviceRequest__findBluetoothRadio(state);
+    }
+
+    // Assign this host address on the controller.
+    // NOTE: This needs to be done on the main thread since the controller view isn't thread safe.
+    if (success)
+    {
+        success= AsyncBluetoothPairDeviceRequest__registerHostAddress(m_controllerView, state);
+    }
+
+    // Kick off the worker thread to do the rest of the work
+    if (success)
+    {
+
+    }
+
+    if (success)
+    {
+        m_status = AsyncBluetoothRequest::running;
+    }
+
     if (!success)
     {
         m_status = AsyncBluetoothRequest::failed;
@@ -357,4 +397,40 @@ AsyncBluetoothPairDeviceRequest::getDescription()
     description << "[Pair] ID: " << m_controllerView->getDeviceID() << " Conn: " << m_connectionId;
 
     return description.str();
+}
+
+//-- AsyncBluetoothPairDeviceRequest State Machine -----
+static bool
+AsyncBluetoothPairDeviceRequest__findBluetoothRadio(BluetoothPairDeviceState *state)
+{
+    assert(state->isMainThread());
+    bool bSuccess= true;
+
+    return bSuccess;
+}
+
+static bool
+AsyncBluetoothPairDeviceRequest__registerHostAddress(
+        ServerControllerViewPtr &controllerView,
+        BluetoothPairDeviceState *state)
+{
+    assert(state->isMainThread());
+    const int controller_id= controllerView->getDeviceID();
+    bool bSuccess= true;
+
+    if (controllerView->setHostBluetoothAddress(state->host_address_string))
+    {
+        SERVER_LOG_INFO("AsyncBluetoothPairDeviceRequest")
+                << "Assigned host address " << state->host_address_string
+                << " to controller id " << controller_id;
+    }
+    else
+    {
+        SERVER_LOG_ERROR("AsyncBluetoothPairDeviceRequest")
+                << "Failed to set host address " << state->host_address_string
+                << " on controller id " << controller_id;
+        bSuccess= false;
+    }
+
+    return bSuccess;
 }
\ No newline at end of file
diff --git a/src/psmoveservice/Platform/PlatformDeviceAPILinux.cpp b/src/psmoveservice/Platform/PlatformDeviceAPILinux.cpp
new file mode 100644
index 00000000..79e34c43
--- /dev/null
+++ b/src/psmoveservice/Platform/PlatformDeviceAPILinux.cpp
@@ -0,0 +1,79 @@
+// -- include -----
+#include "PlatformDeviceAPILinux.h"
+#include "ServerLog.h"
+
+#include <assert.h>
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+
+//-- constants -----
+const char *k_reg_property_driver_desc = "DriverDesc";
+const char *k_reg_property_driver_version = "DriverVersion";
+const char *k_reg_property_matching_device_id = "MatchingDeviceId";
+const char *k_reg_property_provider_name = "ProviderName";
+const char *k_reg_property_vendor = "Vendor";
+
+
+// -- globals ----
+IDeviceHotplugListener *g_hotplug_broadcaster = nullptr;
+
+//-- private definitions -----
+
+
+// -- definitions -----
+PlatformDeviceAPILinux::PlatformDeviceAPILinux()
+{
+
+}
+
+PlatformDeviceAPILinux::~PlatformDeviceAPILinux()
+{
+
+}
+
+// System
+bool PlatformDeviceAPILinux::startup(IDeviceHotplugListener *broadcaster)
+{
+	bool bSuccess = true;
+
+	return bSuccess;
+}
+
+void PlatformDeviceAPILinux::poll()
+{
+
+}
+
+void PlatformDeviceAPILinux::shutdown()
+{
+
+}
+
+// Events
+void PlatformDeviceAPILinux::handle_bluetooth_request_started()
+{
+
+}
+
+void PlatformDeviceAPILinux::handle_bluetooth_request_finished()
+{
+
+}
+
+// Queries
+bool PlatformDeviceAPILinux::get_device_property(
+	const DeviceClass deviceClass,
+	const int vendor_id,
+	const int product_id,
+	const char *property_name,
+	char *buffer,
+	const int buffer_size)
+{
+	bool success = false;
+
+
+	return success;
+}
diff --git a/src/psmoveservice/Platform/PlatformDeviceAPILinux.h b/src/psmoveservice/Platform/PlatformDeviceAPILinux.h
new file mode 100644
index 00000000..2bb6abbb
--- /dev/null
+++ b/src/psmoveservice/Platform/PlatformDeviceAPILinux.h
@@ -0,0 +1,33 @@
+#ifndef PLATFORM_DEVICE_API_LINUX_H
+#define PLATFORM_DEVICE_API_LINUX_H
+
+// -- include -----
+#include "DevicePlatformInterface.h"
+
+// -- definitions -----
+class PlatformDeviceAPILinux : public IPlatformDeviceAPI
+{
+public:
+	PlatformDeviceAPILinux();
+	virtual ~PlatformDeviceAPILinux();
+
+	// System
+	bool startup(IDeviceHotplugListener *broadcaster) override;
+	void poll() override;
+	void shutdown() override;
+
+	// Events
+	void handle_bluetooth_request_started() override;
+	void handle_bluetooth_request_finished() override;
+
+	// Queries
+	bool get_device_property(
+		const DeviceClass deviceClass,
+		const int vendor_id,
+		const int product_id,
+		const char *property_name,
+		char *buffer,
+		const int buffer_size) override;
+};
+
+#endif // PLATFORM_DEVICE_API_LINUX_H
diff --git a/src/psmoveservice/Server/PSMoveService.cpp b/src/psmoveservice/Server/PSMoveService.cpp
index 8dc0da0c..c47b4827 100644
--- a/src/psmoveservice/Server/PSMoveService.cpp
+++ b/src/psmoveservice/Server/PSMoveService.cpp
@@ -37,8 +37,8 @@ class PSMoveServiceImpl
 {
 public:
     PSMoveServiceImpl()
-        : m_io_service()
-        , m_signals(m_io_service)
+        : m_io_context()
+        , m_signals(m_io_context)
         , m_usb_device_manager()
         , m_device_manager()
         , m_request_handler(&m_device_manager)
@@ -179,7 +179,7 @@ class PSMoveServiceImpl
 		*/
         if (success)
         {
-            if (!m_network_manager.startup(&m_io_service, &m_request_handler))
+            if (!m_network_manager.startup(&m_io_context, &m_request_handler))
             {
                 SERVER_LOG_FATAL("PSMoveService") << "Failed to initialize the service network manager";
                 success= false;
@@ -243,8 +243,8 @@ class PSMoveServiceImpl
     }
 
 private:   
-    // The io_service used to perform asynchronous operations.
-    boost::asio::io_service m_io_service;
+    // The io_context used to perform asynchronous operations.
+    boost::asio::io_context m_io_context;
        
     // The signal_set is used to register for process termination notifications.
     boost::asio::signal_set m_signals;
diff --git a/src/psmoveservice/Server/ServerNetworkManager.cpp b/src/psmoveservice/Server/ServerNetworkManager.cpp
index 950bdf7e..8e019a9e 100644
--- a/src/psmoveservice/Server/ServerNetworkManager.cpp
+++ b/src/psmoveservice/Server/ServerNetworkManager.cpp
@@ -98,14 +98,14 @@ class ClientConnection : public boost::enable_shared_from_this<ClientConnection>
 
     static ClientConnectionPtr create(
         IServerNetworkEventListener* network_event_listener,
-        asio::io_service& io_service_ref,
+        asio::io_context& io_context_ref,
         udp::socket& udp_socket_ref, 
         ServerRequestHandler &request_handler_ref)
     {
         return ClientConnectionPtr(
             new ClientConnection(
                 network_event_listener, 
-                io_service_ref, 
+                io_context_ref,
                 udp_socket_ref, 
                 request_handler_ref));
     }
@@ -232,7 +232,7 @@ class ClientConnection : public boost::enable_shared_from_this<ClientConnection>
                     write_in_progress= true;
 
                     // Start an asynchronous operation to send a heartbeat message.
-                    // NOTE: Even if the write completes immediate, the callback will only be called from io_service::poll()
+                    // NOTE: Even if the write completes immediate, the callback will only be called from io_context::poll()
                     boost::asio::async_write(
                         m_tcp_socket, 
                         boost::asio::buffer(m_response_write_buffer),
@@ -280,7 +280,7 @@ class ClientConnection : public boost::enable_shared_from_this<ClientConnection>
                         write_in_progress= true;
 
                         // Start an asynchronous operation to send the data frame
-                        // NOTE: Even if the write completes immediate, the callback will only be called from io_service::poll()
+                        // NOTE: Even if the write completes immediate, the callback will only be called from io_context::poll()
                         m_udp_socket_ref.async_send_to(
                             boost::asio::buffer(m_output_dataframe_buffer, sizeof(m_output_dataframe_buffer)),
                             m_udp_remote_endpoint,
@@ -334,13 +334,13 @@ class ClientConnection : public boost::enable_shared_from_this<ClientConnection>
 
     ClientConnection(
         IServerNetworkEventListener *network_event_listener,
-        asio::io_service& io_service_ref,
+        asio::io_context& io_context_ref,
         udp::socket& udp_socket_ref , 
         ServerRequestHandler &request_handler_ref)
         : m_network_event_listener(network_event_listener)
         , m_connection_id(next_connection_id)
         , m_request_handler_ref(request_handler_ref)
-        , m_tcp_socket(io_service_ref)
+        , m_tcp_socket(io_context_ref)
         , m_udp_socket_ref(udp_socket_ref)
         , m_udp_remote_endpoint()
         , m_is_udp_remote_endpoint_bound(false)
@@ -548,11 +548,11 @@ int ClientConnection::next_connection_id = 0;
 class ServerNetworkManagerImpl : public IServerNetworkEventListener
 {
 public:
-    ServerNetworkManagerImpl(asio::io_service &io_service, NetworkManagerConfig &cfg, ServerRequestHandler &requestHandler)
+    ServerNetworkManagerImpl(asio::io_context &io_context, NetworkManagerConfig &cfg, ServerRequestHandler &requestHandler)
         : m_request_handler_ref(requestHandler)
-        , m_io_service(io_service)
-        , m_tcp_acceptor(m_io_service, tcp::endpoint(tcp::v4(), cfg.server_port))
-        , m_udp_socket(m_io_service, udp::endpoint(udp::v4(), cfg.server_port))
+        , m_io_context(io_context)
+        , m_tcp_acceptor(m_io_context, tcp::endpoint(tcp::v4(), cfg.server_port))
+        , m_udp_socket(m_io_context, udp::endpoint(udp::v4(), cfg.server_port))
         , m_udp_connecting_remote_endpoint()
         , m_packed_input_dataframe(std::shared_ptr<PSMoveProtocol::DeviceInputDataFrame>(new PSMoveProtocol::DeviceInputDataFrame()))
         , m_udp_connection_result_write_buffer(false)
@@ -583,7 +583,7 @@ class ServerNetworkManagerImpl : public IServerNetworkEventListener
         ClientConnectionPtr new_connection = 
             ClientConnection::create(
                 this, 
-                m_tcp_acceptor.get_io_service(), 
+                m_tcp_acceptor.get_io_context(),
                 m_udp_socket, 
                 m_request_handler_ref);
 
@@ -617,7 +617,7 @@ class ServerNetworkManagerImpl : public IServerNetworkEventListener
             // * TCP request has finished reading
             // * TCP response has finished writing
             // * UDP data frame has finished writing
-            m_io_service.poll();
+            m_io_context.poll();
 
             // In the event that a UDP data frame write completed immediately,
             // we should start another UDP data frame write.
@@ -751,7 +751,7 @@ class ServerNetworkManagerImpl : public IServerNetworkEventListener
     ServerRequestHandler &m_request_handler_ref;
     
     // Core i/o functionality for TCP/UDP sockets
-    asio::io_service &m_io_service;
+    asio::io_context &m_io_context;
     
     // Handles waiting for and accepting new TCP connections
     tcp::acceptor m_tcp_acceptor;
@@ -990,12 +990,12 @@ ServerNetworkManager::~ServerNetworkManager()
 }
 
 bool ServerNetworkManager::startup(
-	boost::asio::io_service *io_service,
+	boost::asio::io_context *io_context,
     ServerRequestHandler *requestHandler)
 {    
     m_instance= this;
     
-	implementation_ptr= new ServerNetworkManagerImpl(*io_service, m_cfg, *requestHandler);
+	implementation_ptr= new ServerNetworkManagerImpl(*io_context, m_cfg, *requestHandler);
     implementation_ptr->start_connection_accept();
 
     return true;
diff --git a/src/psmoveservice/Server/ServerNetworkManager.h b/src/psmoveservice/Server/ServerNetworkManager.h
index 3cbe7eb1..8534406c 100644
--- a/src/psmoveservice/Server/ServerNetworkManager.h
+++ b/src/psmoveservice/Server/ServerNetworkManager.h
@@ -6,14 +6,14 @@
 #include "PSMoveConfig.h"
 
 //-- pre-declarations -----
-class ServerRequestHandler;
-
 namespace boost {
-    namespace asio {
-        class io_service;
-    }
+	namespace asio {
+		class io_context;
+	}
 }
 
+class ServerRequestHandler;
+
 //-- definitions -----
 class NetworkManagerConfig : public PSMoveConfig
 {
@@ -37,7 +37,7 @@ class ServerNetworkManager
 public:
     /// Used in PSMoveService::m_network_manager
     /**
-     \param io_service Uses default initializer of boost::asio::io_service
+     \param io_context Uses default initializer of boost::asio::io_context
      \param request_handler Default ServerRequestHandler(ControllerManager)
      */
     ServerNetworkManager();
@@ -49,7 +49,7 @@ class ServerNetworkManager
     /**
      Calls ServerNetworkManagerImpl::start_connection_accept()
      */
-    bool startup(boost::asio::io_service *io_service, ServerRequestHandler *request_handler);
+    bool startup(boost::asio::io_context *io_context, ServerRequestHandler *request_handler);
     
     /// Called last by PSMoveService::update()
     /**
diff --git a/src/psmoveservice/Server/ServerRequestHandler.cpp b/src/psmoveservice/Server/ServerRequestHandler.cpp
index 0e309200..66bc6644 100644
--- a/src/psmoveservice/Server/ServerRequestHandler.cpp
+++ b/src/psmoveservice/Server/ServerRequestHandler.cpp
@@ -50,11 +50,11 @@ struct RequestConnectionState
     HMDStreamInfo active_hmd_stream_info[HMDManager::k_max_devices];
 
     RequestConnectionState()
-        : connection_id(-1)
-        , active_controller_streams()
-        , active_tracker_streams()
-        , active_hmd_streams()
-        , pending_bluetooth_request(nullptr)
+            : connection_id(-1)
+            , active_controller_streams()
+            , active_tracker_streams()
+            , active_hmd_streams()
+            , pending_bluetooth_request(nullptr)
     {
         for (int index = 0; index < ControllerManager::k_max_devices; ++index)
         {
@@ -65,7 +65,7 @@ struct RequestConnectionState
         {
             active_tracker_stream_info[index].Clear();
         }
-        
+
         for (int index = 0; index < HMDManager::k_max_devices; ++index)
         {
             active_hmd_stream_info[index].Clear();
@@ -89,8 +89,8 @@ class ServerRequestHandlerImpl
 {
 public:
     ServerRequestHandlerImpl(DeviceManager &deviceManager)
-        : m_device_manager(deviceManager)
-        , m_connection_state_map()
+            : m_device_manager(deviceManager)
+            , m_connection_state_map()
     {
     }
 
@@ -132,31 +132,32 @@ class ServerRequestHandlerImpl
 
                 connection_state->pending_bluetooth_request->update();
 
-                switch(connection_state->pending_bluetooth_request->getStatusCode())
+                AsyncBluetoothRequest::eStatusCode status = connection_state->pending_bluetooth_request->getStatusCode();
+                switch(status)
                 {
-                case AsyncBluetoothRequest::running:
+                    case AsyncBluetoothRequest::running:
                     {
                         // Don't delete. Still have work to do
                         delete_request= false;
                     } break;
-                case AsyncBluetoothRequest::succeeded:
+                    case AsyncBluetoothRequest::succeeded:
                     {
-                        SERVER_LOG_INFO("ServerRequestHandler") 
-                            << "Async bluetooth request(" 
-                            << connection_state->pending_bluetooth_request->getDescription() 
-                            << ") completed.";
+                        SERVER_LOG_INFO("ServerRequestHandler")
+                                << "Async bluetooth request("
+                                << connection_state->pending_bluetooth_request->getDescription()
+                                << ") completed.";
                         delete_request= true;
                     } break;
-                case AsyncBluetoothRequest::failed:
+                    case AsyncBluetoothRequest::failed:
                     {
-                        SERVER_LOG_ERROR("ServerRequestHandler") 
-                            << "Async bluetooth request(" 
-                            << connection_state->pending_bluetooth_request->getDescription() 
-                            << ") failed!";
+                        SERVER_LOG_ERROR("ServerRequestHandler")
+                                << "Async bluetooth request("
+                                << connection_state->pending_bluetooth_request->getDescription()
+                                << ") failed!";
                         delete_request= true;
                     } break;
-                default:
-                    assert(0 && "unreachable");
+                    default:
+                        assert(0 && "unreachable");
                 }
 
                 if (delete_request)
@@ -258,7 +259,7 @@ class ServerRequestHandlerImpl
                 handle_request__set_controller_hand(context, response);
                 break;
 
-            // Tracker Requests
+                // Tracker Requests
             case PSMoveProtocol::Request_RequestType_GET_TRACKER_LIST:
                 response = new PSMoveProtocol::Response;
                 handle_request__get_tracker_list(context, response);
@@ -332,7 +333,7 @@ class ServerRequestHandlerImpl
                 handle_request__get_tracking_space_settings(context, response);
                 break;
 
-            // HMD Requests
+                // HMD Requests
             case PSMoveProtocol::Request_RequestType_GET_HMD_LIST:
                 response = new PSMoveProtocol::Response;
                 handle_request__get_hmd_list(context, response);
@@ -374,7 +375,7 @@ class ServerRequestHandlerImpl
                 handle_request__set_hmd_data_stream_tracker_index(context, response);
                 break;
 
-            // General Service Requests
+                // General Service Requests
             case PSMoveProtocol::Request_RequestType_GET_SERVICE_VERSION:
                 response = new PSMoveProtocol::Response;
                 handle_request__get_service_version(context, response);
@@ -399,7 +400,7 @@ class ServerRequestHandlerImpl
 
         switch (data_frame->device_category())
         {
-        case PSMoveProtocol::DeviceInputDataFrame::DeviceCategory::DeviceInputDataFrame_DeviceCategory_CONTROLLER:
+            case PSMoveProtocol::DeviceInputDataFrame::DeviceCategory::DeviceInputDataFrame_DeviceCategory_CONTROLLER:
             {
                 handle_data_frame__controller_packet(connection_state, data_frame);
             } break;
@@ -458,7 +459,7 @@ class ServerRequestHandlerImpl
                 }
             }
 
-            
+
             for (int tracker_id = 0; tracker_id < TrackerManager::k_max_devices; ++tracker_id)
             {
                 // Restore any overridden camera settings from the config
@@ -499,8 +500,8 @@ class ServerRequestHandlerImpl
     }
 
     void publish_controller_data_frame(
-         ServerControllerView *controller_view, 
-         ServerRequestHandler::t_generate_controller_data_frame_for_stream callback)
+            ServerControllerView *controller_view,
+            ServerRequestHandler::t_generate_controller_data_frame_for_stream callback)
     {
         int controller_id= controller_view->getDeviceID();
 
@@ -513,7 +514,7 @@ class ServerRequestHandlerImpl
             if (connection_state->active_controller_streams.test(controller_id))
             {
                 const ControllerStreamInfo &streamInfo=
-                    connection_state->active_controller_stream_info[controller_id];
+                        connection_state->active_controller_stream_info[controller_id];
 
                 // Fill out a data frame specific to this stream using the given callback
                 DeviceOutputDataFramePtr data_frame(new PSMoveProtocol::DeviceOutputDataFrame);
@@ -526,7 +527,7 @@ class ServerRequestHandlerImpl
     }
 
     void publish_tracker_data_frame(
-        class ServerTrackerView *tracker_view,
+            class ServerTrackerView *tracker_view,
             ServerRequestHandler::t_generate_tracker_data_frame_for_stream callback)
     {
         int tracker_id = tracker_view->getDeviceID();
@@ -540,7 +541,7 @@ class ServerRequestHandlerImpl
             if (connection_state->active_tracker_streams.test(tracker_id))
             {
                 const TrackerStreamInfo &streamInfo =
-                    connection_state->active_tracker_stream_info[tracker_id];
+                        connection_state->active_tracker_stream_info[tracker_id];
 
                 // Fill out a data frame specific to this stream using the given callback
                 DeviceOutputDataFramePtr data_frame(new PSMoveProtocol::DeviceOutputDataFrame);
@@ -553,8 +554,8 @@ class ServerRequestHandlerImpl
     }
 
     void publish_hmd_data_frame(
-        class ServerHMDView *hmd_view,
-        ServerRequestHandler::t_generate_hmd_data_frame_for_stream callback)
+            class ServerHMDView *hmd_view,
+            ServerRequestHandler::t_generate_hmd_data_frame_for_stream callback)
     {
         int hmd_id = hmd_view->getDeviceID();
 
@@ -567,7 +568,7 @@ class ServerRequestHandlerImpl
             if (connection_state->active_hmd_streams.test(hmd_id))
             {
                 const HMDStreamInfo &streamInfo =
-                    connection_state->active_hmd_stream_info[hmd_id];
+                        connection_state->active_hmd_stream_info[hmd_id];
 
                 // Fill out a data frame specific to this stream using the given callback
                 DeviceOutputDataFramePtr data_frame(new PSMoveProtocol::DeviceOutputDataFrame);
@@ -577,7 +578,7 @@ class ServerRequestHandlerImpl
                 ServerNetworkManager::get_instance()->send_device_data_frame(connection_id, data_frame);
             }
         }
-    }    
+    }
 
 protected:
     RequestConnectionStatePtr FindOrCreateConnectionState(int connection_id)
@@ -608,7 +609,7 @@ class ServerRequestHandlerImpl
         if (ServerUtility::is_index_valid(controller_id, m_device_manager.getControllerViewMaxCount()))
         {
             ServerControllerViewPtr controller_view_ptr= m_device_manager.getControllerViewPtr(controller_id);
-            
+
             if (controller_view_ptr->getIsOpen())
             {
                 controller_view= controller_view_ptr.get();
@@ -619,11 +620,11 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_controller_list(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const PSMoveProtocol::Request_RequestGetControllerList& request =
-            context.request->request_get_controller_list();
+                context.request->request_get_controller_list();
         PSMoveProtocol::Response_ResultControllerList* list= response->mutable_result_controller_list();
 
         response->set_type(PSMoveProtocol::Response_ResponseType_CONTROLLER_LIST);
@@ -651,7 +652,7 @@ class ServerRequestHandlerImpl
                 std::string orientation_filter = "";
                 std::string position_filter = "";
                 std::string gyro_gain_setting = "";
-				std::string controller_hand= "";
+                std::string controller_hand= "";
 
                 float prediction_time = 0.f;
 
@@ -659,7 +660,7 @@ class ServerRequestHandlerImpl
 
                 switch(controller_view->getControllerDeviceType())
                 {
-                case CommonControllerState::PSMove:
+                    case CommonControllerState::PSMove:
                     {
                         const PSMoveController *controller = controller_view->castCheckedConst<PSMoveController>();
                         const PSMoveControllerConfig *config = controller->getConfig();
@@ -669,22 +670,22 @@ class ServerRequestHandlerImpl
                         firmware_version = config->firmware_version;
                         firmware_revision = config->firmware_revision;
                         prediction_time = config->prediction_time;
-						controller_hand= config->hand;
+                        controller_hand= config->hand;
                         has_magnetometer = controller->getSupportsMagnetometer();
 
                         controller_info->set_controller_type(PSMoveProtocol::PSMOVE);
                     }
-                    break;
-                case CommonControllerState::PSNavi:
+                        break;
+                    case CommonControllerState::PSNavi:
                     {
                         const PSNaviController *controller = controller_view->castCheckedConst<PSNaviController>();
                         const PSNaviControllerConfig &config = controller->getConfig();
 
                         controller_info->set_controller_type(PSMoveProtocol::PSNAVI);
-                        parent_controller_serial = config.attached_to_controller;					
+                        parent_controller_serial = config.attached_to_controller;
                     }
-                    break;
-                case CommonControllerState::PSDualShock4:
+                        break;
+                    case CommonControllerState::PSDualShock4:
                     {
                         const PSDualShock4Controller *controller = controller_view->castCheckedConst<PSDualShock4Controller>();
                         const PSDualShock4ControllerConfig *config = controller->getConfig();
@@ -723,12 +724,12 @@ class ServerRequestHandlerImpl
                         orientation_filter = config->orientation_filter_type;
                         position_filter = config->position_filter_type;
                         prediction_time = config->prediction_time;
-						controller_hand= config->hand;
+                        controller_hand= config->hand;
 
-                    controller_info->set_controller_type(PSMoveProtocol::PSDUALSHOCK4);
+                        controller_info->set_controller_type(PSMoveProtocol::PSDUALSHOCK4);
                     }
-                    break;
-                case CommonControllerState::VirtualController:
+                        break;
+                    case CommonControllerState::VirtualController:
                     {
                         const VirtualController *controller = controller_view->castCheckedConst<VirtualController>();
                         const VirtualControllerConfig *config = controller->getConfig();
@@ -738,20 +739,20 @@ class ServerRequestHandlerImpl
 
                         controller_info->set_controller_type(PSMoveProtocol::VIRTUALCONTROLLER);
                         gamepad_index= config->gamepad_index;
-						controller_hand= config->hand;
+                        controller_hand= config->hand;
                     }
-                    break;
-                default:
-                    assert(0 && "Unhandled controller type");
+                        break;
+                    default:
+                        assert(0 && "Unhandled controller type");
                 }
 
                 controller_info->set_controller_id(controller_id);
                 controller_info->set_connection_type(
-                    bIsNonUSB
-                    ? PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_BLUETOOTH
-                    : PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_USB);  
+                        bIsNonUSB
+                        ? PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_BLUETOOTH
+                        : PSMoveProtocol::Response_ResultControllerList_ControllerInfo_ConnectionType_USB);
                 controller_info->set_tracking_color_type(
-                    static_cast<PSMoveProtocol::TrackingColorType>(controller_view->getTrackingColorID()));
+                        static_cast<PSMoveProtocol::TrackingColorType>(controller_view->getTrackingColorID()));
                 controller_info->set_device_path(controller_view->getUSBDevicePath());
                 controller_info->set_device_serial(controller_view->getSerial());
                 controller_info->set_assigned_host_serial(controller_view->getAssignedHostBluetoothAddress());
@@ -765,12 +766,12 @@ class ServerRequestHandlerImpl
                 controller_info->set_prediction_time(prediction_time);
                 controller_info->set_gamepad_index(gamepad_index);
 
-				if (controller_hand == "Left")
-					controller_info->set_controller_hand(PSMoveProtocol::HAND_LEFT);
-				else if (controller_hand == "Right")
-					controller_info->set_controller_hand(PSMoveProtocol::HAND_RIGHT);
-				else
-					controller_info->set_controller_hand(PSMoveProtocol::HAND_ANY);
+                if (controller_hand == "Left")
+                    controller_info->set_controller_hand(PSMoveProtocol::HAND_LEFT);
+                else if (controller_hand == "Right")
+                    controller_info->set_controller_hand(PSMoveProtocol::HAND_RIGHT);
+                else
+                    controller_info->set_controller_hand(PSMoveProtocol::HAND_ANY);
             }
         }
 
@@ -778,11 +779,11 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__start_controller_data_stream(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const PSMoveProtocol::Request_RequestStartPSMoveDataStream& request=
-            context.request->request_start_psmove_data_stream();
+                context.request->request_start_psmove_data_stream();
         int controller_id= request.controller_id();
 
         response->set_type(PSMoveProtocol::Response_ResponseType_CONTROLLER_STREAM_STARTED);
@@ -795,7 +796,7 @@ class ServerRequestHandlerImpl
             if (controller_view->getIsStreamable())
             {
                 ControllerStreamInfo &streamInfo =
-                    context.connection_state->active_controller_stream_info[controller_id];
+                        context.connection_state->active_controller_stream_info[controller_id];
 
                 // The controller manager will always publish updates regardless of who is listening.
                 // All we have to do is keep track of which connections care about the updates.
@@ -811,24 +812,24 @@ class ServerRequestHandlerImpl
                 streamInfo.disable_roi = request.disable_roi();
 
                 SERVER_LOG_INFO("ServerRequestHandler") << "Start controller(" << controller_id << ") stream ("
-                    << "pos=" << streamInfo.include_position_data
-                    << ",phys=" << streamInfo.include_physics_data
-                    << ",raw_sens=" << streamInfo.include_raw_sensor_data
-                    << ",cal_sens=" << streamInfo.include_calibrated_sensor_data
-                    << ",trkr=" << streamInfo.include_raw_tracker_data
-                    << ",roi=" << streamInfo.disable_roi
-                    << ")";
+                                                        << "pos=" << streamInfo.include_position_data
+                                                        << ",phys=" << streamInfo.include_physics_data
+                                                        << ",raw_sens=" << streamInfo.include_raw_sensor_data
+                                                        << ",cal_sens=" << streamInfo.include_calibrated_sensor_data
+                                                        << ",trkr=" << streamInfo.include_raw_tracker_data
+                                                        << ",roi=" << streamInfo.disable_roi
+                                                        << ")";
 
                 if (streamInfo.include_position_data)
                 {
                     controller_view->startTracking();
                 }
-                
+
                 // Attach the initial state of the controller
                 {
                     auto *stream_started_response= response->mutable_result_controller_stream_started();
                     PSMoveProtocol::DeviceOutputDataFrame* data_frame= stream_started_response->mutable_initial_data_frame();
-                    
+
                     ServerControllerView::generate_controller_data_frame_for_stream(controller_view.get(), &streamInfo, data_frame);
                 }
 
@@ -854,8 +855,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__stop_controller_data_stream(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         int controller_id= context.request->request_stop_psmove_data_stream().controller_id();
 
@@ -863,7 +864,7 @@ class ServerRequestHandlerImpl
         {
             ServerControllerViewPtr controller_view = m_device_manager.getControllerViewPtr(controller_id);
             ControllerStreamInfo &streamInfo =
-                context.connection_state->active_controller_stream_info[controller_id];
+                    context.connection_state->active_controller_stream_info[controller_id];
 
             if (controller_view->getIsStreamable())
             {
@@ -901,8 +902,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__reset_orientation(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id= context.request->reset_orientation().controller_id();
         ServerControllerViewPtr controllerView = m_device_manager.getControllerViewPtr(controller_id);
@@ -917,13 +918,13 @@ class ServerRequestHandlerImpl
         {
             if (controllerView->recenterOrientation(q_pose))
             {
-            response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-        }
-        else
-        {
-            response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+            }
+            else
+            {
+                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+            }
         }
-    }
         else
         {
             response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
@@ -931,11 +932,11 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__unpair_controller(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int connection_id= context.connection_state->connection_id;
-        const int controller_id= context.request->unpair_controller().controller_id();        
+        const int controller_id= context.request->unpair_controller().controller_id();
 
         if (context.connection_state->pending_bluetooth_request == nullptr)
         {
@@ -943,50 +944,50 @@ class ServerRequestHandlerImpl
 
             if (controllerView->getIsOpen())
             {
-            context.connection_state->pending_bluetooth_request =
-                new AsyncBluetoothUnpairDeviceRequest(connection_id, controllerView);
+                context.connection_state->pending_bluetooth_request =
+                        new AsyncBluetoothUnpairDeviceRequest(connection_id, controllerView);
 
-            std::string description = context.connection_state->pending_bluetooth_request->getDescription();
+                std::string description = context.connection_state->pending_bluetooth_request->getDescription();
 
-            if (context.connection_state->pending_bluetooth_request->start())
-            {
-                SERVER_LOG_INFO("ServerRequestHandler") << "Async bluetooth request(" << description << ") started.";
+                if (context.connection_state->pending_bluetooth_request->start())
+                {
+                    SERVER_LOG_INFO("ServerRequestHandler") << "Async bluetooth request(" << description << ") started.";
 
-                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-            }
-            else
-            {
-                SERVER_LOG_ERROR("ServerRequestHandler") << "Async bluetooth request(" << description << ") failed to start!";
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+                }
+                else
+                {
+                    SERVER_LOG_ERROR("ServerRequestHandler") << "Async bluetooth request(" << description << ") failed to start!";
 
-                delete context.connection_state->pending_bluetooth_request;
-                context.connection_state->pending_bluetooth_request = nullptr;
+                    delete context.connection_state->pending_bluetooth_request;
+                    context.connection_state->pending_bluetooth_request = nullptr;
 
-                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+                }
             }
-        }
-        else
-        {
-            SERVER_LOG_ERROR("ServerRequestHandler") 
-                    << "Can't start unpair request. Controller not open. Controller ID: "
-                    << controller_id;
+            else
+            {
+                SERVER_LOG_ERROR("ServerRequestHandler")
+                        << "Can't start unpair request. Controller not open. Controller ID: "
+                        << controller_id;
             }
         }
         else
         {
-            SERVER_LOG_ERROR("ServerRequestHandler") 
-                << "Can't start unpair request due to existing request: " 
-                << context.connection_state->pending_bluetooth_request->getDescription();
+            SERVER_LOG_ERROR("ServerRequestHandler")
+                    << "Can't start unpair request due to existing request: "
+                    << context.connection_state->pending_bluetooth_request->getDescription();
 
             response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
         }
     }
 
     void handle_request__pair_controller(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int connection_id= context.connection_state->connection_id;
-        const int controller_id= context.request->pair_controller().controller_id();        
+        const int controller_id= context.request->pair_controller().controller_id();
 
         if (context.connection_state->pending_bluetooth_request == nullptr)
         {
@@ -994,64 +995,64 @@ class ServerRequestHandlerImpl
 
             if (controllerView->getIsOpen())
             {
-            context.connection_state->pending_bluetooth_request = 
-                new AsyncBluetoothPairDeviceRequest(connection_id, controllerView);
+                context.connection_state->pending_bluetooth_request =
+                        new AsyncBluetoothPairDeviceRequest(connection_id, controllerView);
 
-            if (context.connection_state->pending_bluetooth_request->start())
-            {
-                SERVER_LOG_INFO("ServerRequestHandler") 
-                    << "Async bluetooth request(" 
-                    << context.connection_state->pending_bluetooth_request->getDescription() 
-                    << ") started.";
+                if (context.connection_state->pending_bluetooth_request->start())
+                {
+                    SERVER_LOG_INFO("ServerRequestHandler")
+                            << "Async bluetooth request("
+                            << context.connection_state->pending_bluetooth_request->getDescription()
+                            << ") started.";
 
-                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-            }
-            else
-            {
-                SERVER_LOG_ERROR("ServerRequestHandler") 
-                    << "Async bluetooth request(" 
-                    << context.connection_state->pending_bluetooth_request->getDescription() 
-                    << ") failed to start!";
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+                }
+                else
+                {
+                    SERVER_LOG_ERROR("ServerRequestHandler")
+                            << "Async bluetooth request("
+                            << context.connection_state->pending_bluetooth_request->getDescription()
+                            << ") failed to start!";
 
-                delete context.connection_state->pending_bluetooth_request;
-                context.connection_state->pending_bluetooth_request= nullptr;
+                    delete context.connection_state->pending_bluetooth_request;
+                    context.connection_state->pending_bluetooth_request= nullptr;
 
-                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+                }
             }
-        }
-        else
-        {
-            SERVER_LOG_ERROR("ServerRequestHandler") 
-                    << "Can't start pair request. Controller not open. Controller ID: "
-                    << controller_id;
+            else
+            {
+                SERVER_LOG_ERROR("ServerRequestHandler")
+                        << "Can't start pair request. Controller not open. Controller ID: "
+                        << controller_id;
             }
         }
         else
         {
-            SERVER_LOG_ERROR("ServerRequestHandler") 
-                << "Can't start pair request due to existing request: " 
-                << context.connection_state->pending_bluetooth_request->getDescription();
+            SERVER_LOG_ERROR("ServerRequestHandler")
+                    << "Can't start pair request due to existing request: "
+                    << context.connection_state->pending_bluetooth_request->getDescription();
 
             response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
         }
     }
 
     void handle_request__cancel_bluetooth_request(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int connection_id= context.connection_state->connection_id;
-        const int controller_id= context.request->cancel_bluetooth_request().controller_id();        
+        const int controller_id= context.request->cancel_bluetooth_request().controller_id();
 
         if (context.connection_state->pending_bluetooth_request != nullptr)
         {
-            SERVER_LOG_INFO("ServerRequestHandler") 
-                << "Async bluetooth request(" 
-                << context.connection_state->pending_bluetooth_request->getDescription() 
-                << ") Canceled.";
+            SERVER_LOG_INFO("ServerRequestHandler")
+                    << "Async bluetooth request("
+                    << context.connection_state->pending_bluetooth_request->getDescription()
+                    << ") Canceled.";
 
             context.connection_state->pending_bluetooth_request->cancel(AsyncBluetoothRequest::userRequested);
-            
+
             response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
         }
         else
@@ -1063,17 +1064,17 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_led_tracking_color(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int connection_id = context.connection_state->connection_id;
         const int controller_id = context.request->set_led_tracking_color_request().controller_id();
         const eCommonTrackingColorID newColorID=
-            static_cast<eCommonTrackingColorID>(context.request->set_led_tracking_color_request().color_type());
+                static_cast<eCommonTrackingColorID>(context.request->set_led_tracking_color_request().color_type());
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
 
-        if (ControllerView && 
+        if (ControllerView &&
             ControllerView->getIsStreamable() &&
             (ControllerView->getControllerDeviceType() == CommonDeviceState::PSMove ||
              ControllerView->getControllerDeviceType() == CommonDeviceState::PSDualShock4 ||
@@ -1096,7 +1097,7 @@ class ServerRequestHandlerImpl
                     ControllerView->setTrackingColorID(newColorID);
                     response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
                 }
-                else 
+                else
                 {
                     if (oldColorID != eCommonTrackingColorID::INVALID_COLOR)
                     {
@@ -1118,8 +1119,8 @@ class ServerRequestHandlerImpl
     }
 
     inline void set_config_vector(
-        const PSMoveProtocol::FloatVector &source_vector,
-        CommonDeviceVector &target_vector)
+            const PSMoveProtocol::FloatVector &source_vector,
+            CommonDeviceVector &target_vector)
     {
         target_vector.i = source_vector.i();
         target_vector.j = source_vector.j();
@@ -1127,8 +1128,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_controller_magnetometer_calibration(
-        const RequestContext &context, 
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id= context.request->set_controller_magnetometer_calibration_request().controller_id();
 
@@ -1173,8 +1174,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_controller_accelerometer_calibration(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->set_controller_accelerometer_calibration_request().controller_id();
 
@@ -1192,8 +1193,8 @@ class ServerRequestHandlerImpl
                 // Save the noise radius in controller config
                 config.accelerometer_noise_radius= request.noise_radius();
                 config.accelerometer_variance = request.variance();
-                
-				controller->setConfig(&config);
+
+                controller->setConfig(&config);
 
                 ControllerView->resetPoseFilter();
 
@@ -1209,8 +1210,8 @@ class ServerRequestHandlerImpl
                 // Save the noise radius in controller config
                 config.accelerometer_noise_radius= request.noise_radius();
                 config.accelerometer_variance = request.variance();
-                
-				controller->setConfig(&config);
+
+                controller->setConfig(&config);
 
                 ControllerView->resetPoseFilter();
 
@@ -1228,8 +1229,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_controller_gyroscope_calibration(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->set_controller_gyroscope_calibration_request().controller_id();
 
@@ -1292,7 +1293,7 @@ class ServerRequestHandlerImpl
 
                 if (bChanged)
                 {
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
                 }
 
                 ControllerView->resetPoseFilter();
@@ -1305,14 +1306,14 @@ class ServerRequestHandlerImpl
                 PSMoveControllerConfig config = *controller->getConfig();
 
                 const PSMoveProtocol::Request_RequestSetControllerGyroscopeCalibration &request =
-                    context.request->set_controller_gyroscope_calibration_request();
+                        context.request->set_controller_gyroscope_calibration_request();
 
                 bool bChanged = false;
 
-				if (config.set_raw_gyro_bias(request.raw_bias().i(), request.raw_bias().j(), request.raw_bias().k()))
-				{
-					bChanged = true;
-				}
+                if (config.set_raw_gyro_bias(request.raw_bias().i(), request.raw_bias().j(), request.raw_bias().k()))
+                {
+                    bChanged = true;
+                }
 
                 if (request.drift() > 0.f)
                 {
@@ -1328,7 +1329,7 @@ class ServerRequestHandlerImpl
 
                 if (bChanged)
                 {
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
                 }
 
                 ControllerView->resetPoseFilter();
@@ -1347,14 +1348,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_optical_noise_calibration(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_optical_noise_calibration().controller_id();
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
         const PSMoveProtocol::Request_RequestSetOpticalNoiseCalibration &request =
-            context.request->request_set_optical_noise_calibration();
+                context.request->request_set_optical_noise_calibration();
 
         if (ControllerView && ControllerView->getIsOpen())
         {
@@ -1368,7 +1369,7 @@ class ServerRequestHandlerImpl
                 config.orientation_variance_exp_fit_a = request.orientation_variance_exp_fit_a();
                 config.orientation_variance_exp_fit_b = request.orientation_variance_exp_fit_b();
 
-				controller->setConfig(&config);
+                controller->setConfig(&config);
 
                 ControllerView->resetPoseFilter();
 
@@ -1414,14 +1415,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_orientation_filter(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_orientation_filter().controller_id();
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
         const PSMoveProtocol::Request_RequestSetOrientationFilter &request =
-            context.request->request_set_orientation_filter();
+                context.request->request_set_orientation_filter();
 
         if (ControllerView && ControllerView->getIsOpen())
         {
@@ -1433,8 +1434,8 @@ class ServerRequestHandlerImpl
                 if (config.orientation_filter_type != request.orientation_filter())
                 {
                     config.orientation_filter_type = request.orientation_filter();
-                    
-					controller->setConfig(&config);
+
+                    controller->setConfig(&config);
 
                     ControllerView->resetPoseFilter();
                 }
@@ -1450,7 +1451,7 @@ class ServerRequestHandlerImpl
                 {
                     config.orientation_filter_type = request.orientation_filter();
 
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
 
                     ControllerView->resetPoseFilter();
                 }
@@ -1469,14 +1470,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_position_filter(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_position_filter().controller_id();
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
         const PSMoveProtocol::Request_RequestSetPositionFilter &request =
-            context.request->request_set_position_filter();
+                context.request->request_set_position_filter();
 
         if (ControllerView && ControllerView->getIsOpen())
         {
@@ -1489,7 +1490,7 @@ class ServerRequestHandlerImpl
                 {
                     config.position_filter_type = request.position_filter();
 
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
 
                     ControllerView->resetPoseFilter();
                 }
@@ -1505,7 +1506,7 @@ class ServerRequestHandlerImpl
                 {
                     config.position_filter_type = request.position_filter();
 
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
 
                     ControllerView->resetPoseFilter();
                 }
@@ -1539,14 +1540,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_controller_prediction_time(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_controller_prediction_time().controller_id();
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
         const PSMoveProtocol::Request_RequestSetControllerPredictionTime &request =
-            context.request->request_set_controller_prediction_time();
+                context.request->request_set_controller_prediction_time();
 
         if (ControllerView && ControllerView->getIsOpen())
         {
@@ -1559,7 +1560,7 @@ class ServerRequestHandlerImpl
                 {
                     config.prediction_time = request.prediction_time();
 
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
                 }
 
                 response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
@@ -1573,7 +1574,7 @@ class ServerRequestHandlerImpl
                 {
                     config.prediction_time = request.prediction_time();
 
-					controller->setConfig(&config);
+                    controller->setConfig(&config);
                 }
 
                 response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
@@ -1603,8 +1604,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_attached_controller(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int child_controller_id = context.request->request_set_attached_controller().child_controller_id();
         const int parent_controller_id = context.request->request_set_attached_controller().parent_controller_id();
@@ -1616,7 +1617,7 @@ class ServerRequestHandlerImpl
             ParentControllerView && ParentControllerView->getIsOpen() &&
             ChildControllerView != ParentControllerView)
         {
-            if (ParentControllerView->getControllerDeviceType() == CommonDeviceState::PSMove && 
+            if (ParentControllerView->getControllerDeviceType() == CommonDeviceState::PSMove &&
                 ChildControllerView->getControllerDeviceType() == CommonDeviceState::PSNavi)
             {
                 const PSMoveController *psmove = ParentControllerView->castChecked<PSMoveController>();
@@ -1641,15 +1642,15 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_gamepad_index(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_gamepad_index().controller_id();
         const int gamepad_index = context.request->request_set_gamepad_index().gamepad_index();
 
         ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
 
-        if (ControllerView && 
+        if (ControllerView &&
             ControllerView->getIsOpen() &&
             ControllerView->getControllerDeviceType() == CommonDeviceState::VirtualController)
         {
@@ -1677,8 +1678,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_controller_data_stream_tracker_index(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int controller_id = context.request->request_set_controller_data_stream_tracker_index().controller_id();
         const int tracker_id = context.request->request_set_controller_data_stream_tracker_index().tracker_id();
@@ -1688,7 +1689,7 @@ class ServerRequestHandlerImpl
         {
             ServerControllerViewPtr controller_view = m_device_manager.getControllerViewPtr(controller_id);
             ControllerStreamInfo &streamInfo =
-                context.connection_state->active_controller_stream_info[controller_id];
+                    context.connection_state->active_controller_stream_info[controller_id];
 
             if (controller_view->getIsStreamable())
             {
@@ -1709,81 +1710,81 @@ class ServerRequestHandlerImpl
         }
     }
 
-	void handle_request__set_controller_hand(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
-	{
+    void handle_request__set_controller_hand(
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
+    {
         const int controller_id = context.request->request_set_controller_hand().controller_id();
         std::string hand;
 
-		switch (context.request->request_set_controller_hand().controller_hand())
-		{
-		case PSMoveProtocol::HAND_LEFT:
-			hand= "Left";
-			break;
-		case PSMoveProtocol::HAND_RIGHT:
-			hand= "Right";
-			break;
-		case PSMoveProtocol::HAND_ANY:
-		default:
-			hand= "Any";
-			break;
-		}
-		
-		ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
-
-        if (ControllerView && 
+        switch (context.request->request_set_controller_hand().controller_hand())
+        {
+            case PSMoveProtocol::HAND_LEFT:
+                hand= "Left";
+                break;
+            case PSMoveProtocol::HAND_RIGHT:
+                hand= "Right";
+                break;
+            case PSMoveProtocol::HAND_ANY:
+            default:
+                hand= "Any";
+                break;
+        }
+
+        ServerControllerViewPtr ControllerView = m_device_manager.getControllerViewPtr(controller_id);
+
+        if (ControllerView &&
             ControllerView->getIsOpen())
         {
-			switch (ControllerView->getControllerDeviceType())
-			{
-			case CommonDeviceState::PSMove:
-				{
-					PSMoveController *controller = ControllerView->castChecked<PSMoveController>();
-					PSMoveControllerConfig config = *controller->getConfig();
-
-					config.hand = hand;
-					controller->setConfig(&config);
-
-					response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-				}
-				break;
-			case CommonDeviceState::PSDualShock4:
-				{
-					PSDualShock4Controller *controller = ControllerView->castChecked<PSDualShock4Controller>();
-					PSDualShock4ControllerConfig config = *controller->getConfig();
-
-					config.hand = hand;
-					controller->setConfig(&config);
-
-					response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-				}
-				break;
-			case CommonDeviceState::VirtualController:
-				{
-					VirtualController *controller = ControllerView->castChecked<VirtualController>();
-					VirtualControllerConfig *config = controller->getConfigMutable();
-
-					config->hand = hand;
-					config->save();
-
-					response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-				}
-				break;
-			default:
-				response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
-			}
+            switch (ControllerView->getControllerDeviceType())
+            {
+                case CommonDeviceState::PSMove:
+                {
+                    PSMoveController *controller = ControllerView->castChecked<PSMoveController>();
+                    PSMoveControllerConfig config = *controller->getConfig();
+
+                    config.hand = hand;
+                    controller->setConfig(&config);
+
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+                }
+                    break;
+                case CommonDeviceState::PSDualShock4:
+                {
+                    PSDualShock4Controller *controller = ControllerView->castChecked<PSDualShock4Controller>();
+                    PSDualShock4ControllerConfig config = *controller->getConfig();
+
+                    config.hand = hand;
+                    controller->setConfig(&config);
+
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+                }
+                    break;
+                case CommonDeviceState::VirtualController:
+                {
+                    VirtualController *controller = ControllerView->castChecked<VirtualController>();
+                    VirtualControllerConfig *config = controller->getConfigMutable();
+
+                    config->hand = hand;
+                    config->save();
+
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+                }
+                    break;
+                default:
+                    response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
+            }
         }
         else
         {
             response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_ERROR);
         }
-	}
+    }
 
     // -- tracker requests -----
     inline void common_device_pose_to_protocol_pose(
-        const CommonDevicePose &pose, 
-        PSMoveProtocol::Pose *result)
+            const CommonDevicePose &pose,
+            PSMoveProtocol::Pose *result)
     {
         PSMoveProtocol::Orientation *orietation = result->mutable_orientation();
         PSMoveProtocol::Position *position = result->mutable_position();
@@ -1799,8 +1800,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_tracker_list(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         PSMoveProtocol::Response_ResultTrackerList* list = response->mutable_result_tracker_list();
 
@@ -1816,30 +1817,30 @@ class ServerRequestHandlerImpl
 
                 switch (tracker_view->getTrackerDeviceType())
                 {
-                case CommonControllerState::PS3EYE:
-                    tracker_info->set_tracker_type(PSMoveProtocol::PS3EYE);
-                    break;
-                default:
-                    assert(0 && "Unhandled tracker type");
+                    case CommonControllerState::PS3EYE:
+                        tracker_info->set_tracker_type(PSMoveProtocol::PS3EYE);
+                        break;
+                    default:
+                        assert(0 && "Unhandled tracker type");
                 }
 
                 switch (tracker_view->getTrackerDriverType())
                 {
-                case ITrackerInterface::Libusb:
-                    tracker_info->set_tracker_driver(PSMoveProtocol::LIBUSB);
-                    break;
-                case ITrackerInterface::CL:
-                    tracker_info->set_tracker_driver(PSMoveProtocol::CL_EYE);
-                    break;
-                case ITrackerInterface::CLMulti:
-                    tracker_info->set_tracker_driver(PSMoveProtocol::CL_EYE_MULTICAM);
-                    break;
-                    // PSMoveProtocol::ISIGHT?
-                case ITrackerInterface::Generic_Webcam:
-                    tracker_info->set_tracker_driver(PSMoveProtocol::GENERIC_WEBCAM);
-                    break;
-                default:
-                    assert(0 && "Unhandled tracker type");
+                    case ITrackerInterface::Libusb:
+                        tracker_info->set_tracker_driver(PSMoveProtocol::LIBUSB);
+                        break;
+                    case ITrackerInterface::CL:
+                        tracker_info->set_tracker_driver(PSMoveProtocol::CL_EYE);
+                        break;
+                    case ITrackerInterface::CLMulti:
+                        tracker_info->set_tracker_driver(PSMoveProtocol::CL_EYE_MULTICAM);
+                        break;
+                        // PSMoveProtocol::ISIGHT?
+                    case ITrackerInterface::Generic_Webcam:
+                        tracker_info->set_tracker_driver(PSMoveProtocol::GENERIC_WEBCAM);
+                        break;
+                    default:
+                        assert(0 && "Unhandled tracker type");
                 }
 
                 tracker_info->set_tracker_id(tracker_id);
@@ -1854,10 +1855,10 @@ class ServerRequestHandlerImpl
                     float distortionP1, distortionP2;
 
                     tracker_view->getCameraIntrinsics(
-                        focalLengthX, focalLengthY, 
-                        principalX, principalY,
-                        distortionK1, distortionK2, distortionK3,
-                        distortionP1, distortionP2);
+                            focalLengthX, focalLengthY,
+                            principalX, principalY,
+                            distortionK1, distortionK2, distortionK3,
+                            distortionP1, distortionP2);
                     tracker_view->getPixelDimensions(pixelWidth, pixelHeight);
 
                     tracker_info->mutable_tracker_focal_lengths()->set_x(focalLengthX);
@@ -1880,7 +1881,7 @@ class ServerRequestHandlerImpl
                 {
                     float hfov, vfov;
                     float zNear, zFar;
-                    
+
                     tracker_view->getFOV(hfov, vfov);
                     tracker_view->getZRange(zNear, zFar);
 
@@ -1895,7 +1896,7 @@ class ServerRequestHandlerImpl
                     CommonDevicePose pose= tracker_view->getTrackerPose();
 
                     common_device_pose_to_protocol_pose(pose, tracker_info->mutable_tracker_pose());
-                }                
+                }
             }
         }
 
@@ -1904,11 +1905,11 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__start_tracker_data_stream(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const PSMoveProtocol::Request_RequestStartTrackerDataStream& request =
-            context.request->request_start_tracker_data_stream();
+                context.request->request_start_tracker_data_stream();
         int tracker_id = request.tracker_id();
 
         if (ServerUtility::is_index_valid(tracker_id, m_device_manager.getTrackerViewMaxCount()))
@@ -1918,7 +1919,7 @@ class ServerRequestHandlerImpl
             if (tracker_view->getIsOpen())
             {
                 TrackerStreamInfo &streamInfo =
-                    context.connection_state->active_tracker_stream_info[tracker_id];
+                        context.connection_state->active_tracker_stream_info[tracker_id];
 
                 // The tracker manager will always publish updates regardless of who is listening.
                 // All we have to do is keep track of which connections care about the updates.
@@ -1946,8 +1947,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__stop_tracker_data_stream(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         int tracker_id = context.request->request_stop_tracker_data_stream().tracker_id();
 
@@ -1984,7 +1985,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_tracker_settings(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                              PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_get_tracker_settings().tracker_id();
 
@@ -1996,7 +1997,7 @@ class ServerRequestHandlerImpl
             if (tracker_view->getIsOpen())
             {
                 PSMoveProtocol::Response_ResultTrackerSettings* settings =
-                    response->mutable_result_tracker_settings();
+                        response->mutable_result_tracker_settings();
                 const int device_id = context.request->request_get_tracker_settings().device_id();
 
                 settings->set_frame_width(static_cast<float>(tracker_view->getFrameWidth()));
@@ -2008,13 +2009,13 @@ class ServerRequestHandlerImpl
 
                 switch (context.request->request_get_tracker_settings().device_category())
                 {
-                case PSMoveProtocol::Request_RequestGetTrackerSettings_DeviceCategory_CONTROLLER:
+                    case PSMoveProtocol::Request_RequestGetTrackerSettings_DeviceCategory_CONTROLLER:
                     {
                         ServerControllerView *controller_view = get_controller_view_or_null(device_id);
 
-                tracker_view->gatherTrackingColorPresets(controller_view, settings);
+                        tracker_view->gatherTrackingColorPresets(controller_view, settings);
                     } break;
-                case PSMoveProtocol::Request_RequestGetTrackerSettings_DeviceCategory_HMD:
+                    case PSMoveProtocol::Request_RequestGetTrackerSettings_DeviceCategory_HMD:
                     {
                         ServerHMDView *hmd_view = get_hmd_view_or_null(device_id);
 
@@ -2036,7 +2037,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_frame_width(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                                 PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_frame_width().tracker_id();
 
@@ -2050,7 +2051,7 @@ class ServerRequestHandlerImpl
                 const bool bSaveSetting = context.request->request_set_tracker_frame_width().save_setting();
                 const float desired_frame_width = context.request->request_set_tracker_frame_width().value();
                 PSMoveProtocol::Response_ResultSetTrackerFrameWidth* result_frame_width =
-                    response->mutable_result_set_tracker_frame_width();
+                        response->mutable_result_set_tracker_frame_width();
 
                 // Set the desired frame width on the tracker
                 tracker_view->setFrameWidth(desired_frame_width, bSaveSetting);
@@ -2082,7 +2083,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_frame_height(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                                  PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_frame_height().tracker_id();
 
@@ -2096,7 +2097,7 @@ class ServerRequestHandlerImpl
                 const bool bSaveSetting = context.request->request_set_tracker_frame_height().save_setting();
                 const float desired_frame_height = context.request->request_set_tracker_frame_height().value();
                 PSMoveProtocol::Response_ResultSetTrackerFrameHeight* result_frame_height =
-                    response->mutable_result_set_tracker_frame_height();
+                        response->mutable_result_set_tracker_frame_height();
 
                 // Set the desired frame height on the tracker
                 tracker_view->setFrameHeight(desired_frame_height, bSaveSetting);
@@ -2128,7 +2129,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_frame_rate(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                                PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_frame_rate().tracker_id();
 
@@ -2142,7 +2143,7 @@ class ServerRequestHandlerImpl
                 const bool bSaveSetting = context.request->request_set_tracker_frame_rate().save_setting();
                 const float desired_frame_rate = context.request->request_set_tracker_frame_rate().value();
                 PSMoveProtocol::Response_ResultSetTrackerFrameRate* result_frame_rate =
-                    response->mutable_result_set_tracker_frame_rate();
+                        response->mutable_result_set_tracker_frame_rate();
 
                 // Set the desired frame rate on the tracker
                 tracker_view->setFrameRate(desired_frame_rate, bSaveSetting);
@@ -2174,7 +2175,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_exposure(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                              PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_exposure().tracker_id();
 
@@ -2188,7 +2189,7 @@ class ServerRequestHandlerImpl
                 const bool bSaveSetting= context.request->request_set_tracker_exposure().save_setting();
                 const float desired_exposure = context.request->request_set_tracker_exposure().value();
                 PSMoveProtocol::Response_ResultSetTrackerExposure* result_exposure =
-                    response->mutable_result_set_tracker_exposure();
+                        response->mutable_result_set_tracker_exposure();
 
                 // Set the desired exposure on the tracker
                 tracker_view->setExposure(desired_exposure, bSaveSetting);
@@ -2220,7 +2221,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_gain(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                          PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_gain().tracker_id();
 
@@ -2234,7 +2235,7 @@ class ServerRequestHandlerImpl
                 const bool bSaveSetting = context.request->request_set_tracker_gain().save_setting();
                 const double desired_gain = context.request->request_set_tracker_gain().value();
                 PSMoveProtocol::Response_ResultSetTrackerGain* result_gain =
-                    response->mutable_result_set_tracker_gain();
+                        response->mutable_result_set_tracker_gain();
 
                 // Set the desired gain on the tracker
                 tracker_view->setGain(desired_gain, bSaveSetting);
@@ -2266,7 +2267,7 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_option(const RequestContext &context,
-        PSMoveProtocol::Response *response)
+                                            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_gain().tracker_id();
 
@@ -2280,7 +2281,7 @@ class ServerRequestHandlerImpl
                 const std::string &option_name = context.request->request_set_tracker_option().option_name();
                 const int desired_option_index = context.request->request_set_tracker_option().option_index();
                 PSMoveProtocol::Response_ResultSetTrackerOption* result_gain =
-                    response->mutable_result_set_tracker_option();
+                        response->mutable_result_set_tracker_option();
 
                 // Set the desired gain on the tracker
                 if (tracker_view->setOptionIndex(option_name, desired_option_index))
@@ -2313,8 +2314,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_color_preset(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_color_preset().tracker_id();
 
@@ -2329,9 +2330,9 @@ class ServerRequestHandlerImpl
                 const int device_id= context.request->request_set_tracker_color_preset().device_id();
 
                 const PSMoveProtocol::TrackingColorPreset &colorPreset =
-                    context.request->request_set_tracker_color_preset().color_preset();
+                        context.request->request_set_tracker_color_preset().color_preset();
                 const eCommonTrackingColorID colorType=
-                    static_cast<eCommonTrackingColorID>(colorPreset.color_type());
+                        static_cast<eCommonTrackingColorID>(colorPreset.color_type());
 
                 // Set the color preset on the tracker
                 CommonHSVColorRange inHSVColorRange;
@@ -2346,7 +2347,7 @@ class ServerRequestHandlerImpl
 
                     switch (device_category)
                     {
-                    case PSMoveProtocol::Request_RequestSetTrackerColorPreset_DeviceCategory_CONTROLLER:
+                        case PSMoveProtocol::Request_RequestSetTrackerColorPreset_DeviceCategory_CONTROLLER:
                         {
                             ServerControllerView *controller_view = get_controller_view_or_null(device_id);
 
@@ -2355,7 +2356,7 @@ class ServerRequestHandlerImpl
                             // Read back what actually got set
                             tracker_view->getControllerTrackingColorPreset(controller_view, colorType, &outHSVColorRange);
                         } break;
-                    case PSMoveProtocol::Request_RequestSetTrackerColorPreset_DeviceCategory_HMD:
+                        case PSMoveProtocol::Request_RequestSetTrackerColorPreset_DeviceCategory_HMD:
                         {
                             ServerHMDView *hmd_view = get_hmd_view_or_null(device_id);
 
@@ -2364,14 +2365,14 @@ class ServerRequestHandlerImpl
                             // Read back what actually got set
                             tracker_view->getHMDTrackingColorPreset(hmd_view, colorType, &outHSVColorRange);
                         } break;
-                }
+                    }
 //                    tracker_view->saveSettings(); // Carried over from old generic_camera
                 }
 
                 // Get the resulting preset from the tracker
                 {
                     PSMoveProtocol::Response_ResultSetTrackerColorPreset *result =
-                        response->mutable_result_set_tracker_color_preset();
+                            response->mutable_result_set_tracker_color_preset();
                     result->set_tracker_id(tracker_id);
 
                     PSMoveProtocol::TrackingColorPreset *presetResult = result->mutable_new_color_preset();
@@ -2414,8 +2415,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_pose(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_pose().tracker_id();
         if (ServerUtility::is_index_valid(tracker_id, m_device_manager.getTrackerViewMaxCount()))
@@ -2423,8 +2424,8 @@ class ServerRequestHandlerImpl
             ServerTrackerViewPtr tracker_view = m_device_manager.getTrackerViewPtr(tracker_id);
             if (tracker_view->getIsOpen())
             {
-                const PSMoveProtocol::Pose &srcPose = 
-                    context.request->request_set_tracker_pose().pose();
+                const PSMoveProtocol::Pose &srcPose =
+                        context.request->request_set_tracker_pose().pose();
                 CommonDevicePose destPose = protocol_pose_to_common_device_pose(srcPose);
 
                 tracker_view->setTrackerPose(&destPose);
@@ -2444,8 +2445,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_tracker_intrinsics(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_set_tracker_intrinsics().tracker_id();
         if (ServerUtility::is_index_valid(tracker_id, m_device_manager.getTrackerViewMaxCount()))
@@ -2456,10 +2457,10 @@ class ServerRequestHandlerImpl
                 const auto &intrinsics= context.request->request_set_tracker_intrinsics();
 
                 tracker_view->setCameraIntrinsics(
-                    intrinsics.tracker_focal_lengths().x(), intrinsics.tracker_focal_lengths().y(),
-                    intrinsics.tracker_principal_point().x(), intrinsics.tracker_principal_point().y(),
-                    intrinsics.tracker_k1(), intrinsics.tracker_k2(), intrinsics.tracker_k3(),
-                    intrinsics.tracker_p1(), intrinsics.tracker_p2());
+                        intrinsics.tracker_focal_lengths().x(), intrinsics.tracker_focal_lengths().y(),
+                        intrinsics.tracker_principal_point().x(), intrinsics.tracker_principal_point().y(),
+                        intrinsics.tracker_k1(), intrinsics.tracker_k2(), intrinsics.tracker_k3(),
+                        intrinsics.tracker_p1(), intrinsics.tracker_p2());
                 tracker_view->saveSettings();
 
                 response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
@@ -2476,8 +2477,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__save_tracker_profile(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_save_tracker_profile().tracker_id();
 
@@ -2501,9 +2502,9 @@ class ServerRequestHandlerImpl
                 for (int preset_index = 0; preset_index < eCommonTrackingColorID::MAX_TRACKING_COLOR_TYPES; ++preset_index)
                 {
                     tracker_view->getControllerTrackingColorPreset(
-                        controller_view,
-                        static_cast<eCommonTrackingColorID>(preset_index),
-                        &trackerProfile.color_preset_table.color_presets[preset_index]);
+                            controller_view,
+                            static_cast<eCommonTrackingColorID>(preset_index),
+                            &trackerProfile.color_preset_table.color_presets[preset_index]);
                 }
 
                 m_device_manager.m_tracker_manager->saveDefaultTrackerProfile(&trackerProfile);
@@ -2522,8 +2523,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__apply_tracker_profile(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_apply_tracker_profile().tracker_id();
 
@@ -2537,9 +2538,9 @@ class ServerRequestHandlerImpl
                 const int controller_id= context.request->request_apply_tracker_profile().controller_id();
                 ServerControllerView *controller_view= get_controller_view_or_null(controller_id);
 
-                const TrackerProfile *trackerProfile = 
-                    m_device_manager.m_tracker_manager->getDefaultTrackerProfile();
-    
+                const TrackerProfile *trackerProfile =
+                        m_device_manager.m_tracker_manager->getDefaultTrackerProfile();
+
                 // Apply the profile to the tracker
                 tracker_view->setFrameWidth(trackerProfile->frame_width, true);
                 //tracker_view->setFrameHeight(trackerProfile->frame_height, true);
@@ -2557,7 +2558,7 @@ class ServerRequestHandlerImpl
                 // Send the profile application result to the client
                 {
                     PSMoveProtocol::Response_ResultTrackerSettings* settings =
-                        response->mutable_result_tracker_settings();
+                            response->mutable_result_tracker_settings();
 
                     settings->set_frame_width(static_cast<float>(tracker_view->getFrameWidth()));
                     settings->set_frame_height(static_cast<float>(tracker_view->getFrameHeight()));
@@ -2584,8 +2585,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__reload_tracker_settings(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int tracker_id = context.request->request_apply_tracker_profile().tracker_id();
 
@@ -2595,7 +2596,7 @@ class ServerRequestHandlerImpl
         {
             ServerTrackerViewPtr tracker_view = m_device_manager.getTrackerViewPtr(tracker_id);
             if (tracker_view->getIsOpen())
-            {   
+            {
                 tracker_view->loadSettings();
                 response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
             }
@@ -2611,8 +2612,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__search_for_new_trackers(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         // The video polling threads tend to stall out when we are polling for new devices via libusb.
         // Until we have a better solution, best to just shut down all of the trackers
@@ -2623,8 +2624,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_tracking_space_settings(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         PSMoveProtocol::Response_ResultTrackingSpaceSettings* settings = response->mutable_result_tracking_space_settings();
 
@@ -2652,8 +2653,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_hmd_list(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         PSMoveProtocol::Response_ResultHMDList* list = response->mutable_result_hmd_list();
 
@@ -2669,7 +2670,7 @@ class ServerRequestHandlerImpl
 
                 switch (hmd_view->getHMDDeviceType())
                 {
-                case CommonHMDState::Morpheus:
+                    case CommonHMDState::Morpheus:
                     {
                         const MorpheusHMD *morpheusHMD= hmd_view->castCheckedConst<MorpheusHMD>();
                         const MorpheusHMDConfig *config= morpheusHMD->getConfig();
@@ -2679,8 +2680,8 @@ class ServerRequestHandlerImpl
                         hmd_info->set_orientation_filter(config->orientation_filter_type);
                         hmd_info->set_position_filter(config->position_filter_type);
                     }
-                    break;
-                case CommonHMDState::VirtualHMD:
+                        break;
+                    case CommonHMDState::VirtualHMD:
                     {
                         const VirtualHMD *virtualHMD= hmd_view->castCheckedConst<VirtualHMD>();
                         const VirtualHMDConfig *config= virtualHMD->getConfig();
@@ -2689,9 +2690,9 @@ class ServerRequestHandlerImpl
                         hmd_info->set_prediction_time(config->prediction_time);
                         hmd_info->set_position_filter(config->position_filter_type);
                     }
-                    break;
-                default:
-                    assert(0 && "Unhandled tracker type");
+                        break;
+                    default:
+                        assert(0 && "Unhandled tracker type");
                 }
 
                 hmd_info->set_hmd_id(hmd_id);
@@ -2704,11 +2705,11 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__start_hmd_data_stream(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const PSMoveProtocol::Request_RequestStartHmdDataStream& request =
-            context.request->request_start_hmd_data_stream();
+                context.request->request_start_hmd_data_stream();
         int hmd_id = request.hmd_id();
 
         if (ServerUtility::is_index_valid(hmd_id, m_device_manager.getHMDViewMaxCount()))
@@ -2718,7 +2719,7 @@ class ServerRequestHandlerImpl
             if (hmd_view->getIsOpen())
             {
                 HMDStreamInfo &streamInfo =
-                    context.connection_state->active_hmd_stream_info[hmd_id];
+                        context.connection_state->active_hmd_stream_info[hmd_id];
 
                 // The hmd manager will always publish updates regardless of who is listening.
                 // All we have to do is keep track of which connections care about the updates.
@@ -2734,13 +2735,13 @@ class ServerRequestHandlerImpl
                 streamInfo.disable_roi = request.disable_roi();
 
                 SERVER_LOG_INFO("ServerRequestHandler") << "Start hmd(" << hmd_id << ") stream ("
-                    << "pos=" << streamInfo.include_position_data
-                    << ",phys=" << streamInfo.include_physics_data
-                    << ",raw_sens=" << streamInfo.include_raw_sensor_data
-                    << ",cal_sens=" << streamInfo.include_calibrated_sensor_data
-                    << ",trkr=" << streamInfo.include_raw_tracker_data
-                    << ",roi=" << streamInfo.disable_roi
-                    << ")";
+                                                        << "pos=" << streamInfo.include_position_data
+                                                        << ",phys=" << streamInfo.include_physics_data
+                                                        << ",raw_sens=" << streamInfo.include_raw_sensor_data
+                                                        << ",cal_sens=" << streamInfo.include_calibrated_sensor_data
+                                                        << ",trkr=" << streamInfo.include_raw_tracker_data
+                                                        << ",roi=" << streamInfo.disable_roi
+                                                        << ")";
 
                 if (streamInfo.disable_roi)
                 {
@@ -2757,8 +2758,8 @@ class ServerRequestHandlerImpl
                 }
 
                 // Return the name of the shared memory block the video frames will be written to
-        response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
-    }
+                response->set_result_code(PSMoveProtocol::Response_ResultCode_RESULT_OK);
+            }
             else
             {
                 // Device not opened
@@ -2772,8 +2773,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__stop_hmd_data_stream(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         int hmd_id = context.request->request_stop_hmd_data_stream().hmd_id();
 
@@ -2814,17 +2815,17 @@ class ServerRequestHandlerImpl
 
 
     void handle_request__set_hmd_led_tracking_color(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int connection_id = context.connection_state->connection_id;
         const int hmd_id = context.request->set_hmd_led_tracking_color_request().hmd_id();
         const eCommonTrackingColorID newColorID=
-            static_cast<eCommonTrackingColorID>(context.request->set_hmd_led_tracking_color_request().color_type());
+                static_cast<eCommonTrackingColorID>(context.request->set_hmd_led_tracking_color_request().color_type());
 
         ServerHMDViewPtr HmdView = m_device_manager.getHMDViewPtr(hmd_id);
 
-        if (HmdView && 
+        if (HmdView &&
             HmdView->getHMDDeviceType() == CommonDeviceState::VirtualHMD)
         {
             const eCommonTrackingColorID oldColorID = HmdView->getTrackingColorID();
@@ -2866,8 +2867,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_accelerometer_calibration(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->set_hmd_accelerometer_calibration_request().hmd_id();
 
@@ -2907,8 +2908,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_gyroscope_calibration(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->set_hmd_accelerometer_calibration_request().hmd_id();
 
@@ -2938,14 +2939,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_orientation_filter(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->request_set_hmd_orientation_filter().hmd_id();
 
         ServerHMDViewPtr HmdView = m_device_manager.getHMDViewPtr(hmd_id);
         const PSMoveProtocol::Request_RequestSetHMDOrientationFilter &request =
-            context.request->request_set_hmd_orientation_filter();
+                context.request->request_set_hmd_orientation_filter();
 
         if (HmdView && HmdView->getIsOpen())
         {
@@ -2976,14 +2977,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_position_filter(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->request_set_hmd_position_filter().hmd_id();
 
         ServerHMDViewPtr HmdView = m_device_manager.getHMDViewPtr(hmd_id);
         const PSMoveProtocol::Request_RequestSetHMDPositionFilter &request =
-            context.request->request_set_hmd_position_filter();
+                context.request->request_set_hmd_position_filter();
 
         if (HmdView && HmdView->getIsOpen())
         {
@@ -3029,14 +3030,14 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_prediction_time(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->request_set_hmd_prediction_time().hmd_id();
 
         ServerHMDViewPtr HmdView = m_device_manager.getHMDViewPtr(hmd_id);
         const PSMoveProtocol::Request_RequestSetHMDPredictionTime &request =
-            context.request->request_set_hmd_prediction_time();
+                context.request->request_set_hmd_prediction_time();
 
         if (HmdView && HmdView->getIsOpen())
         {
@@ -3078,8 +3079,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__set_hmd_data_stream_tracker_index(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         const int hmd_id = context.request->request_set_hmd_data_stream_tracker_index().hmd_id();
         const int tracker_id = context.request->request_set_hmd_data_stream_tracker_index().tracker_id();
@@ -3089,7 +3090,7 @@ class ServerRequestHandlerImpl
         {
             ServerHMDViewPtr hmd_view = m_device_manager.getHMDViewPtr(hmd_id);
             HMDStreamInfo &streamInfo =
-                context.connection_state->active_hmd_stream_info[hmd_id];
+                    context.connection_state->active_hmd_stream_info[hmd_id];
 
             SERVER_LOG_INFO("ServerRequestHandler") << "Set hmd(" << hmd_id << ") stream tracker id: " << tracker_id;
 
@@ -3104,8 +3105,8 @@ class ServerRequestHandlerImpl
     }
 
     void handle_request__get_service_version(
-        const RequestContext &context,
-        PSMoveProtocol::Response *response)
+            const RequestContext &context,
+            PSMoveProtocol::Response *response)
     {
         PSMoveProtocol::Response_ResultServiceVersion* version_info = response->mutable_result_service_version();
 
@@ -3118,8 +3119,8 @@ class ServerRequestHandlerImpl
 
     // -- Data Frame Updates -----
     void handle_data_frame__controller_packet(
-        RequestConnectionStatePtr connection_state,
-        DeviceInputDataFramePtr data_frame)
+            RequestConnectionStatePtr connection_state,
+            DeviceInputDataFramePtr data_frame)
     {
         const auto &controllerDataPacket = data_frame->controller_data_packet();
         const int controller_id = controllerDataPacket.controller_id();
@@ -3131,7 +3132,7 @@ class ServerRequestHandlerImpl
 
             // Don't consider this data frame if the controller isn't in a streamable connection
             // or if the sequence number is old
-            if (controller_view->getIsStreamable() && 
+            if (controller_view->getIsStreamable() &&
                 controllerDataPacket.sequence_num() > streamInfo.last_data_input_sequence_number)
             {
                 // Remember the last sequence number we received from this connection
@@ -3139,7 +3140,7 @@ class ServerRequestHandlerImpl
 
                 switch (controller_view->getControllerDeviceType())
                 {
-                case CommonDeviceState::eDeviceType::PSMove:
+                    case CommonDeviceState::eDeviceType::PSMove:
                     {
                         const auto &psmove_state= controllerDataPacket.psmove_state();
 
@@ -3163,7 +3164,7 @@ class ServerRequestHandlerImpl
                                     controller_view->clearLEDOverride();
                                 }
                             }
-                            // Otherwise we are setting the override to a new color
+                                // Otherwise we are setting the override to a new color
                             else
                             {
                                 // Sets the bulb LED color to some new override color
@@ -3176,11 +3177,11 @@ class ServerRequestHandlerImpl
                             streamInfo.led_override_active= controller_view->getIsLEDOverrideActive();
                         }
                     } break;
-                case CommonDeviceState::eDeviceType::PSNavi:
+                    case CommonDeviceState::eDeviceType::PSNavi:
                     {
                         // Nothing to update...
                     } break;
-                case CommonDeviceState::eDeviceType::PSDualShock4:
+                    case CommonDeviceState::eDeviceType::PSDualShock4:
                     {
                         const auto &psmove_state= controllerDataPacket.psdualshock4_state();
 
@@ -3206,7 +3207,7 @@ class ServerRequestHandlerImpl
                                     controller_view->clearLEDOverride();
                                 }
                             }
-                            // Otherwise we are setting the override to a new color
+                                // Otherwise we are setting the override to a new color
                             else
                             {
                                 // Sets the bulb LED color to some new override color
@@ -3233,7 +3234,7 @@ class ServerRequestHandlerImpl
 ServerRequestHandler *ServerRequestHandler::m_instance = NULL;
 
 ServerRequestHandler::ServerRequestHandler(DeviceManager *deviceManager)
-    : m_implementation_ptr(new ServerRequestHandlerImpl(*deviceManager))
+        : m_implementation_ptr(new ServerRequestHandlerImpl(*deviceManager))
 {
 
 }
@@ -3285,22 +3286,22 @@ void ServerRequestHandler::handle_client_connection_stopped(int connection_id)
 }
 
 void ServerRequestHandler::publish_controller_data_frame(
-    ServerControllerView *controller_view, 
-    t_generate_controller_data_frame_for_stream callback)
+        ServerControllerView *controller_view,
+        t_generate_controller_data_frame_for_stream callback)
 {
     return m_implementation_ptr->publish_controller_data_frame(controller_view, callback);
 }
 
 void ServerRequestHandler::publish_tracker_data_frame(
-    class ServerTrackerView *tracker_view,
-    t_generate_tracker_data_frame_for_stream callback)
+        class ServerTrackerView *tracker_view,
+        t_generate_tracker_data_frame_for_stream callback)
 {
     return m_implementation_ptr->publish_tracker_data_frame(tracker_view, callback);
 }
 
 void ServerRequestHandler::publish_hmd_data_frame(
-    class ServerHMDView *hmd_view,
-    t_generate_hmd_data_frame_for_stream callback)
+        class ServerHMDView *hmd_view,
+        t_generate_hmd_data_frame_for_stream callback)
 {
     return m_implementation_ptr->publish_hmd_data_frame(hmd_view, callback);
 }
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index b974d2d1..0b787ca6 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -50,9 +50,6 @@ list(APPEND TEST_CAMERA_SRC
 add_executable(test_camera ${CMAKE_CURRENT_LIST_DIR}/test_camera.cpp ${TEST_CAMERA_SRC})
 target_include_directories(test_camera PUBLIC ${TEST_CAMERA_INCL_DIRS})
 target_link_libraries(test_camera ${PLATFORM_LIBS} ${TEST_CAMERA_REQ_LIBS})
-IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-    add_dependencies(test_camera opencv)
-ENDIF()
 SET_TARGET_PROPERTIES(test_camera PROPERTIES FOLDER Test)
     
 # The test_camera_parallel app
@@ -60,9 +57,6 @@ IF((${CMAKE_SYSTEM_NAME} MATCHES "Windows") OR (${CMAKE_SYSTEM_NAME} MATCHES "Da
     add_executable(test_camera_parallel ${CMAKE_CURRENT_LIST_DIR}/test_camera_parallel.cpp ${TEST_CAMERA_SRC})
     target_include_directories(test_camera_parallel PUBLIC ${TEST_CAMERA_INCL_DIRS})
     target_link_libraries(test_camera_parallel ${PLATFORM_LIBS} ${TEST_CAMERA_REQ_LIBS})
-    IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-        add_dependencies(test_camera_parallel opencv)
-    ENDIF()
     SET_TARGET_PROPERTIES(test_camera_parallel PROPERTIES FOLDER Test)
 ENDIF()
 
@@ -121,7 +115,7 @@ SET(TEST_PSMOVE_REQ_LIBS)
 # hidapi
 list(APPEND TEST_PSMOVE_INCL_DIRS ${HIDAPI_INCLUDE_DIRS})
 list(APPEND TEST_PSMOVE_SRC ${HIDAPI_SRC})
-list(APPEND TEST_PSMOVE_REQ_LIBS ${HIDAPI_LIBS})
+list(APPEND TEST_PSMOVE_REQ_LIBS ${HIDAPI_LIBRARIES})
 
 # libusb
 find_package(USB1 REQUIRED)
@@ -131,6 +125,7 @@ list(APPEND TEST_PSMOVE_REQ_LIBS ${LIBUSB_LIBRARIES})
 #Bluetooth
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
     # Why not Windows?
+	# list(APPEND TEST_PSMOVE_SRC ${ROOT_DIR}/src/psmoveservice/Platform/BluetoothQueriesWin32.cpp)
 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     list(APPEND TEST_PSMOVE_SRC ${ROOT_DIR}/src/psmoveservice/Platform/BluetoothQueriesOSX.mm)
 ELSE()
@@ -201,6 +196,7 @@ list(APPEND TEST_PSMOVE_SRC
     ${ROOT_DIR}/src/psmoveservice/Utils/WorkerThread.cpp)
 
 # psmoveprotocol
+# list(APPEND TEST_PSMOVE_REQ_LIBS protobuf::libprotoc protobuf::libprotobuf)
 list(APPEND TEST_PSMOVE_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol)
 list(APPEND TEST_PSMOVE_REQ_LIBS PSMoveProtocol)
 
@@ -237,7 +233,7 @@ SET(TEST_NAVI_REQ_LIBS)
 # hidapi
 list(APPEND TEST_NAVI_INCL_DIRS ${HIDAPI_INCLUDE_DIRS})
 list(APPEND TEST_NAVI_SRC ${HIDAPI_SRC})
-list(APPEND TEST_NAVI_REQ_LIBS ${HIDAPI_LIBS})
+list(APPEND TEST_NAVI_REQ_LIBS ${HIDAPI_LIBRARIES})
 
 # libusb
 find_package(USB1 REQUIRED)
@@ -316,6 +312,7 @@ list(APPEND TEST_NAVI_SRC
     ${ROOT_DIR}/src/psmoveservice/Utils/WorkerThread.cpp)
 
 # psmoveprotocol
+# list(APPEND TEST_NAVI_REQ_LIBS protobuf::libprotoc protobuf::libprotobuf)
 list(APPEND TEST_NAVI_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol)
 list(APPEND TEST_NAVI_REQ_LIBS PSMoveProtocol)
 
@@ -360,7 +357,7 @@ ENDIF()
 # hidapi
 list(APPEND TEST_DS4_CTRLR_INCL_DIRS ${HIDAPI_INCLUDE_DIRS})
 list(APPEND TEST_DS4_CTRLR_SRC ${HIDAPI_SRC})
-list(APPEND TEST_DS4_CTRLR_REQ_LIBS ${HIDAPI_LIBS})
+list(APPEND TEST_DS4_CTRLR_REQ_LIBS ${HIDAPI_LIBRARIES})
 
 # libusb
 find_package(USB1 REQUIRED)
@@ -440,6 +437,7 @@ list(APPEND TEST_DS4_CTRLR_SRC
     ${ROOT_DIR}/src/psmoveservice/Utils/WorkerThread.cpp)
 
 # psmoveprotocol
+# list(APPEND TEST_DS4_CTRLR_REQ_LIBS protobuf::libprotoc protobuf::libprotobuf)
 list(APPEND TEST_DS4_CTRLR_INCL_DIRS ${ROOT_DIR}/src/psmoveprotocol)
 list(APPEND TEST_DS4_CTRLR_REQ_LIBS PSMoveProtocol)
 
diff --git a/src/tests/test_camera.cpp b/src/tests/test_camera.cpp
index c4049ecc..a8e838df 100644
--- a/src/tests/test_camera.cpp
+++ b/src/tests/test_camera.cpp
@@ -47,10 +47,10 @@ int main(int, char**)
 	std::cout << "Please enter the initial frame width for the cameras:\n";
 	std::cin >> frame_width_init;
 
-    // Open all available cameras (up to 4 max)
+    // Open all available cameras (up to PSMOVESERVICE_MAX_TRACKER_COUNT max)
 	for (int camera_index = 0; camera_index < PSMOVESERVICE_MAX_TRACKER_COUNT; ++camera_index)
 	{
-        PSEyeVideoCapture *camera = new PSEyeVideoCapture(camera_index); // open the default camera
+        auto *camera = new PSEyeVideoCapture(camera_index); // open the default camera
 
         if (camera->isOpened())
         {
@@ -66,6 +66,11 @@ int main(int, char**)
 			int last_frames = 0;
 
             camera_states.push_back({ camera, identifier, last_ticks, last_frames });
+
+            // Print some additional details.
+			int format = static_cast<int>(camera->get(cv::CAP_PROP_FORMAT));
+			std::cout << "CAP_PROP_FORMAT: " << format << std::endl;
+			std::cout << "Channels per pixel: " << (format >> CV_CN_SHIFT) + 1 << std::endl;
         }
         else
         {
@@ -82,7 +87,7 @@ int main(int, char**)
         }
     );
 
-    bool bKeepRunning = camera_states.size() > 0;
+    bool bKeepRunning = !camera_states.empty();
     while (bKeepRunning)
     {
         // Render each camera frame in it's own window
@@ -242,9 +247,7 @@ int main(int, char**)
                     std::cout << state.identifier << ": Value of " << prop_str << " changed by " << val_diff << " and is now " << val << std::endl;
                 }
             );
-        }
-		else if (std::find(known_keys_check.begin(), known_keys_check.end(), wk) != known_keys_check.end())
-		{
+        } else if (std::find(known_keys_check.begin(), known_keys_check.end(), wk) != known_keys_check.end()) {
 			int cap_prop = CV_CAP_PROP_FPS;
 			std::string prop_str("CV_CAP_PROP_FPS");
 
@@ -308,24 +311,23 @@ int main(int, char**)
 				camera_states.begin(),
 				camera_states.end(),
 				[&camera_states, &cap_prop, &prop_str, &wk](camera_state &state) {
-				
-				double val = state.camera->get(cap_prop);
-				auto now_ticks = std::chrono::high_resolution_clock::now();
-				switch (wk)
-				{
-				case 32:
-					std::cout << state.identifier << ": Fame rate is set to " << val << " and was actually " 
-						<< (1000 * state.last_frames / (float(std::chrono::duration<double, std::milli>(now_ticks - state.last_ticks).count()))) << " fps" << std::endl;
-					state.last_ticks = now_ticks;
-					state.last_frames = 0;
-					break;
-				default:
-					std::cout << state.identifier << ": Value of " << prop_str << " is " << val << std::endl;
+				    double val = state.camera->get(cap_prop);
+				    auto now_ticks = std::chrono::high_resolution_clock::now();
+				    switch (wk)
+				    {
+				        case 32:
+				            std::cout << state.identifier << ": Fame rate is set to " << val << " and was actually "
+				            << (1000 * state.last_frames / (float(std::chrono::duration<double, std::milli>(now_ticks - state.last_ticks).count()))) << " fps" << std::endl;
+				            state.last_ticks = now_ticks;
+				            state.last_frames = 0;
+				            break;
+                        default:
+                            std::cout << state.identifier << ": Value of " << prop_str << " is " << val << std::endl;
+				    }
 				}
-			}
-			);
+            );
 		}
-        else if (wk > 0)
+        else if (wk > 0 && wk != 255)
         {
             std::cout << "Unknown key has code " << wk << std::endl;
         }
diff --git a/thirdparty/SDL2 b/thirdparty/SDL2
deleted file mode 160000
index ebcd2e89..00000000
--- a/thirdparty/SDL2
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit ebcd2e8914bd29363cf1b6b3fa4f5f3d3aaf2ad3
diff --git a/thirdparty/eigen b/thirdparty/eigen
deleted file mode 160000
index 1f05f515..00000000
--- a/thirdparty/eigen
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 1f05f51517ec4fd91eed711e0f89e97a7c028c0e
diff --git a/thirdparty/glm/copying.txt b/thirdparty/glm/copying.txt
deleted file mode 100644
index 124698cc..00000000
--- a/thirdparty/glm/copying.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (c) 2005 - 2012 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.
diff --git a/thirdparty/glm/glm/core/_detail.hpp b/thirdparty/glm/glm/core/_detail.hpp
deleted file mode 100644
index b842dea2..00000000
--- a/thirdparty/glm/glm/core/_detail.hpp
+++ /dev/null
@@ -1,468 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/_detail.hpp
-/// @date 2008-07-24 / 2011-06-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_detail
-#define glm_core_detail
-
-#include "setup.hpp"
-#include <cassert>
-#if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
-#include <cstdint>
-#endif
-
-namespace glm{
-namespace detail
-{
-	class half;
-
-#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 | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
-	__extension__ typedef signed long long		sint64;
-	__extension__ typedef unsigned long long	uint64;
-#elif(GLM_COMPILER & GLM_COMPILER_BC)
-	typedef Int64								sint64;
-	typedef Uint64								uint64;
-#else//unknown compiler
-	typedef signed long	long					sint64;
-	typedef unsigned long long					uint64;
-#endif//GLM_COMPILER
-
-	template<bool C>
-	struct If
-	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
-		{
-			return functor(val);
-		}
-	};
-
-	template<>
-	struct If<false>
-	{
-		template<typename F, typename T>
-		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
-		{
-			return val;
-		}
-	};
-
-	//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();
-
-	union uif32
-	{
-		GLM_FUNC_QUALIFIER uif32() :
-			i(0)
-		{}
-
-		GLM_FUNC_QUALIFIER uif32(float f) :
-			f(f)
-		{}
-
-		GLM_FUNC_QUALIFIER uif32(unsigned int i) :
-			i(i)
-		{}
-
-		float f;
-		unsigned int i;
-	};
-
-	union uif64
-	{
-		GLM_FUNC_QUALIFIER uif64() :
-			i(0)
-		{}
-
-		GLM_FUNC_QUALIFIER uif64(double f) :
-			f(f)
-		{}
-
-		GLM_FUNC_QUALIFIER uif64(uint64 i) :
-			i(i)
-		{}
-
-		double f;
-		uint64 i;
-	};
-
-	typedef uif32 uif;
-
-	//////////////////
-	// int
-
-	template <typename T>
-	struct is_int
-	{
-		enum is_int_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_INT(T)	\
-	template <>					\
-	struct is_int<T>			\
-	{							\
-		enum is_int_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//////////////////
-	// uint
-
-	template <typename T>
-	struct is_uint
-	{
-		enum is_uint_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_UINT(T)	\
-	template <>					\
-	struct is_uint<T>			\
-	{							\
-		enum is_uint_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//GLM_DETAIL_IS_UINT(unsigned long long)
-
-	//////////////////
-	// float
-
-	template <typename T>
-	struct is_float
-	{
-		enum is_float_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_FLOAT(T)	\
-	template <>					\
-	struct is_float<T>			\
-	{							\
-		enum is_float_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	GLM_DETAIL_IS_FLOAT(detail::half);
-	GLM_DETAIL_IS_FLOAT(float);
-	GLM_DETAIL_IS_FLOAT(double);
-	GLM_DETAIL_IS_FLOAT(long double);
-
-	//////////////////
-	// bool
-
-	template <typename T>
-	struct is_bool
-	{
-		enum is_bool_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-	
-	template <>
-	struct is_bool<bool>
-	{
-		enum is_bool_enum
-		{
-			_YES = 1,
-			_NO = 0
-		};
-	};
-	
-	//////////////////
-	// vector
-
-	template <typename T>
-	struct is_vector
-	{
-		enum is_vector_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#	define GLM_DETAIL_IS_VECTOR(TYPE) \
-		template <typename T> \
-		struct is_vector<TYPE<T> > \
-		{ \
-			enum is_vector_enum \
-			{ \
-				_YES = 1, \
-				_NO = 0 \
-			}; \
-		}
-
-	//////////////////
-	// matrix
-
-	template <typename T>
-	struct is_matrix
-	{
-		enum is_matrix_enum
-		{
-			_YES = 0,
-			_NO = 1
-		};
-	};
-
-#define GLM_DETAIL_IS_MATRIX(T)	\
-	template <>					\
-	struct is_matrix			\
-	{							\
-		enum is_matrix_enum		\
-		{						\
-			_YES = 1,			\
-			_NO = 0				\
-		};						\
-	}
-
-	//////////////////
-	// type
-
-	template <typename T>
-	struct type
-	{
-		enum type_enum
-		{
-			is_float = is_float<T>::_YES,
-			is_int = is_int<T>::_YES,
-			is_uint = is_uint<T>::_YES,
-			is_bool = is_bool<T>::_YES
-		};
-	};
-	
-	//////////////////
-	// type
-	
-	typedef signed char							int8;
-	typedef signed short						int16;
-	typedef signed int							int32;
-	typedef detail::sint64						int64;
-	
-	typedef unsigned char						uint8;
-	typedef unsigned short						uint16;
-	typedef unsigned int						uint32;
-	typedef detail::uint64						uint64;
-	
-	typedef detail::half						float16;
-	typedef float								float32;
-	typedef double								float64;
-	
-	//////////////////
-	// float_or_int_trait 
-
-	struct float_or_int_value
-	{
-		enum
-		{
-			GLM_ERROR,
-			GLM_FLOAT,
-			GLM_INT
-		};
-	};
-
-	template <typename T>
-	struct float_or_int_trait
-	{
-		enum{ID = float_or_int_value::GLM_ERROR};
-	};
-
-	template <>
-	struct float_or_int_trait<int8>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int16>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int32>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<int64>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint8>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint16>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint32>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<uint64>
-	{
-		enum{ID = float_or_int_value::GLM_INT};
-	};
-
-	template <>
-	struct float_or_int_trait<float16>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-	template <>
-	struct float_or_int_trait<float32>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-	template <>
-	struct float_or_int_trait<float64>
-	{
-		enum{ID = float_or_int_value::GLM_FLOAT};
-	};
-
-}//namespace detail
-}//namespace glm
-
-#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-#	define GLM_DEPRECATED __declspec(deprecated)
-#	define GLM_ALIGN(x) __declspec(align(x)) 
-#	define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct 
-#	define GLM_RESTRICT __declspec(restrict)
-#	define GLM_RESTRICT_VAR __restrict
-#elif((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31))
-#	define GLM_DEPRECATED __attribute__((__deprecated__))
-#	define GLM_ALIGN(x) __attribute__((aligned(x)))
-#	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
-#	if(GLM_COMPILER >= GLM_COMPILER_GCC33)
-#		define GLM_RESTRICT __restrict__
-#		define GLM_RESTRICT_VAR __restrict__
-#	else
-#		define GLM_RESTRICT
-#		define GLM_RESTRICT_VAR
-#	endif
-#	define GLM_RESTRICT __restrict__
-#	define GLM_RESTRICT_VAR __restrict__
-#else
-#	define GLM_DEPRECATED
-#	define GLM_ALIGN
-#	define GLM_ALIGNED_STRUCT(x) 
-#	define GLM_RESTRICT
-#	define GLM_RESTRICT_VAR
-#endif//GLM_COMPILER
-
-#endif//glm_core_detail
diff --git a/thirdparty/glm/glm/core/_fixes.hpp b/thirdparty/glm/glm/core/_fixes.hpp
deleted file mode 100644
index 1b4dddaa..00000000
--- a/thirdparty/glm/glm/core/_fixes.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/_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
-
diff --git a/thirdparty/glm/glm/core/_swizzle.hpp b/thirdparty/glm/glm/core/_swizzle.hpp
deleted file mode 100644
index 61be1d6b..00000000
--- a/thirdparty/glm/glm/core/_swizzle.hpp
+++ /dev/null
@@ -1,837 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/_swizzle.hpp
-/// @date 2006-04-20 / 2011-02-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_swizzle
-#define glm_core_swizzle
-
-#include "_swizzle_func.hpp"
-
-namespace glm
-{
-	enum comp
-	{
-		X = 0,
-		R = 0,
-		S = 0,
-		Y = 1,
-		G = 1,
-		T = 1,
-		Z = 2,
-		B = 2,
-		P = 2,
-		W = 3,
-		A = 3,
-		Q = 3
-	};
-}//namespace glm
-
-namespace glm{
-namespace detail
-{
-    // Internal class for implementing swizzle operators
-    template <typename T, int N>
-    struct _swizzle_base0
-    {
-        typedef T       value_type;
-
-    protected:
-        value_type&         elem   (size_t i)       { return (reinterpret_cast<value_type*>(_buffer))[i]; }
-        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, typename V, int E0, int E1, int E2, int E3, int N>
-    struct _swizzle_base1 : public _swizzle_base0<T,N>
-    {
-    };
-
-    template <typename T, typename V, int E0, int E1>
-    struct _swizzle_base1<T,V,E0,E1,-1,-2,2> : public _swizzle_base0<T,2>
-    {
-        V operator ()()  const { return V(this->elem(E0), this->elem(E1)); }
-    };
-
-    template <typename T, typename V, int E0, int E1, int E2>
-    struct _swizzle_base1<T,V,E0,E1,E2,-1,3> : public _swizzle_base0<T,3>
-    {
-        V operator ()()  const { return V(this->elem(E0), this->elem(E1), this->elem(E2)); }
-    };
-
-    template <typename T, typename V, int E0, int E1, int E2, int E3>
-    struct _swizzle_base1<T,V,E0,E1,E2,E3,4> : public _swizzle_base0<T,4>
-    { 
-        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, typename VecType, int N, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
-    struct _swizzle_base2 : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
-    {
-		typedef VecType vec_type;
-		typedef ValueType value_type;
-
-		_swizzle_base2& operator= (const ValueType& t)
-		{
-			for (int i = 0; i < N; ++i)
-				(*this)[i] = t;
-			return *this;
-		}
-
-		_swizzle_base2& operator= (const VecType& that)
-		{
-			struct op { 
-				void operator() (value_type& e, value_type& t) { e = t; } 
-			};
-			_apply_op(that, op());
-			return *this;
-		}
-
-		void operator -= (const VecType& that)
-		{
-			struct op { 
-				void operator() (value_type& e, value_type& t) { e -= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		void operator += (const VecType& that)
-		{
-			struct op { 
-				void operator() (value_type& e, value_type& t) { e += t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		void operator *= (const VecType& that)
-		{
-			struct op { 
-				void operator() (value_type& e, value_type& t) { e *= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		void operator /= (const VecType& that)
-		{
-			struct op { 
-				void operator() (value_type& e, value_type& t) { e /= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		value_type& operator[]  (size_t i)
-		{
-			static const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-		value_type  operator[]  (size_t i) const
-		{
-			static const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-	protected:
-		template <typename T>
-		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, typename VecType, int N, int E0, int E1, int E2, int E3>
-	struct _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,1> : public _swizzle_base1<ValueType,VecType,E0,E1,E2,E3,N>
-	{
-		typedef VecType         vec_type;        
-		typedef ValueType       value_type;
-
-		struct Stub {};
-		_swizzle_base2& operator= (Stub const &) {}
-
-		value_type  operator[]  (size_t i) const
-		{
-			static const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		} 
-	};
-
-	template <int N,typename ValueType, typename VecType, int E0,int E1,int E2,int E3>
-	struct swizzle : public _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)>
-	{
-		typedef _swizzle_base2<ValueType,VecType,N,E0,E1,E2,E3,(E0==E1||E0==E2||E0==E3||E1==E2||E1==E3||E2==E3)> base_type;
-
-		using base_type::operator=;
-
-		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, typename V, int E0, int E1, int E2, int E3>
-#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, typename V, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
-#define _GLM_SWIZZLE_TYPE1       glm::detail::swizzle<N,T,V,E0,E1,E2,E3>
-#define _GLM_SWIZZLE_TYPE2       glm::detail::swizzle<N,T,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                                                          \
-	V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
-	{                                                                               \
-		return a() OPERAND b();                                                     \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const V& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	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                                                          \
-	V operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	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                                                          \
-	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                                                                                      \
-	typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
-	{                                                                                                           \
-		return FUNCTION(a(), b);                                                                                \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	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                                                                                                    \
-	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                                                                                                    \
-	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                                                                                                    \
-	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                                                                                                    \
-	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,E0,E1) \
-	struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; }; 
-
-#define _GLM_SWIZZLE2_3_MEMBERS(T,P2,E0,E1) \
-	struct { glm::detail::swizzle<3,T,P2,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P2,1,1,1,-1> E1 ## E1 ## E1; };  
-
-#define _GLM_SWIZZLE2_4_MEMBERS(T,P2,E0,E1) \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; };  
-
-#define _GLM_SWIZZLE3_2_MEMBERS(T,P2,E0,E1,E2) \
-	struct { glm::detail::swizzle<2,T,P2,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,0,2,-1,-2> E0 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,1,-1,-2> E1 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,1,2,-1,-2> E1 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,0,-1,-2> E2 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,1,-1,-2> E2 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P2,2,2,-1,-2> E2 ## E2; }; 
-
-#define _GLM_SWIZZLE3_3_MEMBERS(T,P,E0,E1,E2) \
-	struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; };
-
-#define _GLM_SWIZZLE3_4_MEMBERS(T,P2,E0,E1,E2) \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P2,2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
-
-#define _GLM_SWIZZLE4_2_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<2,T,P,0,0,-1,-2> E0 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,0,1,-1,-2> E0 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,0,2,-1,-2> E0 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,0,3,-1,-2> E0 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,1,0,-1,-2> E1 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,1,1,-1,-2> E1 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,1,2,-1,-2> E1 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,1,3,-1,-2> E1 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,2,0,-1,-2> E2 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,2,1,-1,-2> E2 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,2,2,-1,-2> E2 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,2,3,-1,-2> E2 ## E3; }; \
-	struct { glm::detail::swizzle<2,T,P,3,0,-1,-2> E3 ## E0; }; \
-	struct { glm::detail::swizzle<2,T,P,3,1,-1,-2> E3 ## E1; }; \
-	struct { glm::detail::swizzle<2,T,P,3,2,-1,-2> E3 ## E2; }; \
-	struct { glm::detail::swizzle<2,T,P,3,3,-1,-2> E3 ## E3; }; 
-
-#define _GLM_SWIZZLE4_3_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<3,T,P,0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,0,3,-1> E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,1,3,-1> E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,2,3,-1> E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,0,-1> E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,1,-1> E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,2,-1> E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,0,3,3,-1> E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,0,3,-1> E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,1,3,-1> E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,2,3,-1> E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,0,-1> E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,1,-1> E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,2,-1> E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,1,3,3,-1> E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,0,3,-1> E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,1,3,-1> E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,2,-1> E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,2,3,-1> E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,0,-1> E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,1,-1> E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,2,-1> E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,2,3,3,-1> E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,0,-1> E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,1,-1> E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,2,-1> E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,0,3,-1> E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,0,-1> E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,1,-1> E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,2,-1> E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,1,3,-1> E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,0,-1> E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,1,-1> E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,2,-1> E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,2,3,-1> E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,0,-1> E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,1,-1> E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,2,-1> E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<3,T,P,3,3,3,-1> E3 ## E3 ## E3; };  
-
-#define _GLM_SWIZZLE4_4_MEMBERS(T,P,E0,E1,E2,E3) \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
-	struct { glm::detail::swizzle<4,T,P,3,3,3,3> E3 ## E3 ## E3 ## E3; }; 
-
-#endif//glm_core_swizzle
diff --git a/thirdparty/glm/glm/core/_swizzle_func.hpp b/thirdparty/glm/glm/core/_swizzle_func.hpp
deleted file mode 100644
index 255a3ec9..00000000
--- a/thirdparty/glm/glm/core/_swizzle_func.hpp
+++ /dev/null
@@ -1,787 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/_swizzle_func.hpp
-/// @date 2011-10-16 / 2011-10-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_swizzle_func
-#define glm_core_swizzle_func
-
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
-	SWIZZLED_TYPE<TMPL_TYPE> A ## B ## C ## D() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC2_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC3_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C); \
-	}
-
-#define GLM_SWIZZLE_GEN_VEC4_ENTRY_DEF(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B, C, D) \
-	template <typename TMPL_TYPE> \
-	SWIZZLED_TYPE<TMPL_TYPE> CLASS_TYPE<TMPL_TYPE>::A ## B ## C ## D() CONST \
-	{ \
-		return SWIZZLED_TYPE<TMPL_TYPE>(this->A, this->B, this->C, this->D); \
-	}
-
-#define GLM_MUTABLE
-
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, x, y) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, r, g) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(TMPL_TYPE, 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, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B)
-
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, s, t, q)
-
-//GLM_SWIZZLE_GEN_REF_FROM_VEC3(valType, detail::vec3, detail::ref2, detail::ref3)
-
-#define GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, GLM_MUTABLE, D, C)
-
-#define GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B)
-
-#define GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, , D, B, C, A)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_REF4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
-
-#define GLM_SWIZZLE_GEN_REF_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
-
-//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, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC2_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC2(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(TMPL_TYPE, 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, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC3_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC3(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q)
-
-//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, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C) \
-	GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC3_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, A, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, B, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, C, D, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, A, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, B, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, C, D, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, A, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, B, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, A) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, B) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, C) \
-	GLM_SWIZZLE_GEN_VEC4_ENTRY(TMPL_TYPE, CLASS_TYPE, SWIZZLED_TYPE, const, D, D, D, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC2_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC3_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC3_TYPE, A, B, C, D) \
-	GLM_SWIZZLE_GEN_VEC4_FROM_VEC4_SWIZZLE(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC4_TYPE, A, B, C, D)
-
-#define GLM_SWIZZLE_GEN_VEC_FROM_VEC4(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, x, y, z, w) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, r, g, b, a) \
-	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, q, p)
-
-//GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
-
-#endif//glm_core_swizzle_func
diff --git a/thirdparty/glm/glm/core/_vectorize.hpp b/thirdparty/glm/glm/core/_vectorize.hpp
deleted file mode 100644
index e69d8091..00000000
--- a/thirdparty/glm/glm/core/_vectorize.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/_vectorize.hpp
-/// @date 2011-10-14 / 2011-10-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#define VECTORIZE2_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec2<T> func( \
-		detail::tvec2<T> const & v) \
-    { \
-        return detail::tvec2<T>( \
-            func(v.x), \
-            func(v.y)); \
-    }
-
-#define VECTORIZE3_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec3<T> func( \
-		detail::tvec3<T> const & v) \
-    { \
-        return detail::tvec3<T>( \
-            func(v.x), \
-            func(v.y), \
-            func(v.z)); \
-    }
-
-#define VECTORIZE4_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec4<T> func( \
-		detail::tvec4<T> const & v) \
-    { \
-        return detail::tvec4<T>( \
-            func(v.x), \
-            func(v.y), \
-            func(v.z), \
-            func(v.w)); \
-    }
-
-#define VECTORIZE_VEC(func) \
-	VECTORIZE2_VEC(func) \
-	VECTORIZE3_VEC(func) \
-	VECTORIZE4_VEC(func)
-
-#define VECTORIZE2_VEC_SCA(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec2<T> func \
-	( \
-		detail::tvec2<T> const & x,  \
-		typename detail::tvec2<T>::value_type const & y \
-	) \
-    { \
-        return detail::tvec2<T>( \
-            func(x.x, y), \
-            func(x.y, y)); \
-    }
-
-#define VECTORIZE3_VEC_SCA(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec3<T> func \
-	( \
-		detail::tvec3<T> const & x,  \
-		typename detail::tvec3<T>::value_type const & y \
-	) \
-    { \
-        return detail::tvec3<T>( \
-            func(x.x, y), \
-            func(x.y, y), \
-            func(x.z, y)); \
-    }
-
-#define VECTORIZE4_VEC_SCA(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec4<T> func \
-	( \
-		detail::tvec4<T> const & x,  \
-		typename detail::tvec4<T>::value_type const & y \
-	) \
-    { \
-        return detail::tvec4<T>( \
-            func(x.x, y), \
-            func(x.y, y), \
-            func(x.z, y), \
-            func(x.w, y)); \
-    }
-
-#define VECTORIZE_VEC_SCA(func) \
-	VECTORIZE2_VEC_SCA(func) \
-	VECTORIZE3_VEC_SCA(func) \
-	VECTORIZE4_VEC_SCA(func)
-
-#define VECTORIZE2_VEC_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec2<T> func \
-	( \
-		detail::tvec2<T> const & x,  \
-		detail::tvec2<T> const & y \
-	) \
-    { \
-        return detail::tvec2<T>( \
-            func(x.x, y.x), \
-            func(x.y, y.y)); \
-    }
-
-#define VECTORIZE3_VEC_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec3<T> func \
-	( \
-		detail::tvec3<T> const & x,  \
-		detail::tvec3<T> const & y \
-	) \
-    { \
-        return detail::tvec3<T>( \
-            func(x.x, y.x), \
-            func(x.y, y.y), \
-            func(x.z, y.z)); \
-    }
-
-#define VECTORIZE4_VEC_VEC(func) \
-    template <typename T> \
-    GLM_FUNC_QUALIFIER detail::tvec4<T> func \
-	( \
-		detail::tvec4<T> const & x,  \
-		detail::tvec4<T> const & y \
-	) \
-    { \
-        return detail::tvec4<T>( \
-            func(x.x, y.x), \
-            func(x.y, y.y), \
-            func(x.z, y.z), \
-            func(x.w, y.w)); \
-    }
-
-#define VECTORIZE_VEC_VEC(func) \
-	VECTORIZE2_VEC_VEC(func) \
-	VECTORIZE3_VEC_VEC(func) \
-	VECTORIZE4_VEC_VEC(func)
diff --git a/thirdparty/glm/glm/core/dummy.cpp b/thirdparty/glm/glm/core/dummy.cpp
deleted file mode 100644
index 443c072f..00000000
--- a/thirdparty/glm/glm/core/dummy.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/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.hpp"
-#include "../ext.hpp"
-
-//#error "GLM is a header only library"
-
-int main()
-{
-
-}
diff --git a/thirdparty/glm/glm/core/func_common.hpp b/thirdparty/glm/glm/core/func_common.hpp
deleted file mode 100644
index 3c268190..00000000
--- a/thirdparty/glm/glm/core/func_common.hpp
+++ /dev/null
@@ -1,428 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_common
-#define GLM_CORE_func_common GLM_VERSION
-
-#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> 
-	genType abs(genType 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 genType> 
-	genType sign(genType 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 genType> 
-	genType floor(genType 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 genType> 
-	genType trunc(genType 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 genType> 
-	genType round(genType 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 genType> 
-	genType roundEven(genType 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 genType> 
-	genType ceil(genType 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> 
-	genType fract(genType 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> 
-	genType mod(
-		genType const & x, 
-		genType const & y);
-
-	/// 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> 
-	genType mod(
-		genType const & x, 
-		typename genType::value_type 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> 
-	genType modf(
-		genType const & 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> 
-	genType min(
-		genType const & x, 
-		genType const & y);
-
-	template <typename genType> 
-	genType min(
-		genType const & x, 
-		typename genType::value_type 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> 
-	genType max(
-		genType const & x, 
-		genType const & y);
-
-	template <typename genType> 
-	genType max(
-		genType const & x, 
-		typename genType::value_type 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> 
-	genType clamp(
-		genType const & x, 
-		genType const & minVal, 
-		genType const & maxVal); 
-
-	template <typename genType> 
-	genType clamp(
-		genType const & x, 
-		typename genType::value_type const & minVal, 
-		typename genType::value_type const & maxVal); 
-
-	//! @return 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].
-	//! 
-	//! @return 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 genTypeT, typename genTypeU> 
-	genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
-
-	//! 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 <typename genType> 
-	genType step(
-		genType const & edge, 
-		genType const & x);
-
-	template <typename genType> 
-	genType step(
-		typename genType::value_type const & edge, 
-		genType 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> 
-	genType smoothstep(
-		genType const & edge0, 
-		genType const & edge1, 
-		genType const & x);
-
-	template <typename genType> 
-	genType smoothstep(
-		typename genType::value_type const & edge0, 
-		typename genType::value_type const & edge1, 
-		genType 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.
-    /// 
-	/// @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 genType> 
-	typename genType::bool_type isnan(genType 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 genType> 
-	typename genType::bool_type isinf(genType const & x);
-
-	/// Returns a signed integer value representing
-	/// the encoding of a floating-point value. The floatingpoint
-	/// value's bit-level representation is preserved.
-	///
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genIType Signed integer scalar or vector types.
-    /// 
-    /// @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 <typename genType, typename genIType>
-	genIType floatBitsToInt(genType const & value);
-
-	/// Returns a unsigned integer value representing
-	/// the encoding of a floating-point value. The floatingpoint
-	/// value's bit-level representation is preserved.
-	///
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genUType Unsigned integer scalar or vector types.
-    /// 
-    /// @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 <typename genType, typename genUType>
-	genUType floatBitsToUint(genType const & value);
-
-	/// 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.
-    /// 
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genIType Signed integer scalar or vector types.
-	/// 
-    /// @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>
-	/// 
-	/// @todo Clarify this declaration, we don't need to actually specify the return type
-	template <typename genType, typename genIType>
-	genType intBitsToFloat(genIType const & value);
-        
-    /// 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.
-    /// 
-	/// @tparam genType Single-precision floating-point scalar or vector types.
-	/// @tparam genUType Unsigned integer scalar or vector types.
-    /// 
-    /// @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>
-	/// 
-	/// @todo Clarify this declaration, we don't need to actually specify the return type
-    template <typename genType, typename genUType>
-    genType uintBitsToFloat(genUType const & value);
-        
-	/// 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>
-	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>
-	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>
-	genType ldexp(genType const & x, genIType const & exp);
-
-	/// @}
-}//namespace glm
-
-#include "func_common.inl"
-
-#endif//GLM_CORE_func_common
diff --git a/thirdparty/glm/glm/core/func_common.inl b/thirdparty/glm/glm/core/func_common.inl
deleted file mode 100644
index 0fe59277..00000000
--- a/thirdparty/glm/glm/core/func_common.inl
+++ /dev/null
@@ -1,1187 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_common.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-
-namespace glm{
-namespace detail
-{
-    template <typename genFIType, bool /*signed*/>
-    struct Abs_
-    {};
-
-    template <typename genFIType>
-    struct Abs_<genFIType, true>
-    {
-        static genFIType get(genFIType const & x)
-        {
-            GLM_STATIC_ASSERT(
-                detail::type<genFIType>::is_float || 
-                detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs");
-            return x >= genFIType(0) ? x : -x;
-			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
-        }
-    };
-
-    template <typename genFIType>
-    struct Abs_<genFIType, false>
-    {
-        static genFIType get(genFIType const & x)
-        {
-            GLM_STATIC_ASSERT(
-					detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs");
-            return x;
-        }
-    };
-}//namespace detail
-
-	// abs
-	template <typename genFIType>
-    GLM_FUNC_QUALIFIER genFIType abs
-	(
-		genFIType const & x
-	)
-    {
-		return detail::Abs_<genFIType, std::numeric_limits<genFIType>::is_signed>::get(x);
-    }
-
-	VECTORIZE_VEC(abs)
-
-    // sign
-	//Try something like based on x >> 31 to get the sign bit
-    template <typename genFIType> 
-	GLM_FUNC_QUALIFIER genFIType sign
-	(
-		genFIType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(
-			detail::type<genFIType>::is_float || 
-			detail::type<genFIType>::is_int, "'sign' only accept signed inputs");
-        
-		genFIType result;
-		if(x > genFIType(0))
-            result = genFIType(1);
-        else if(x < genFIType(0))
-            result = genFIType(-1);
-        else
-            result = genFIType(0);
-        return result;
-	}
-	
-	VECTORIZE_VEC(sign)
-
-    // floor
-    template <>
-	GLM_FUNC_QUALIFIER detail::half floor<detail::half>(detail::half const & x)
-    {
-        return detail::half(::std::floor(float(x)));
-    }
-
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType floor(genType const & x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'floor' only accept floating-point inputs");
-
-        return ::std::floor(x);
-    }
-
-	VECTORIZE_VEC(floor)
-
-    // trunc
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType trunc(genType const & x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'trunc' only accept floating-point inputs");
-        return x < 0 ? -floor(-x) : floor(x);
-    }
-
-	VECTORIZE_VEC(trunc)
-
-    // round
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType round(genType const& x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'round' only accept floating-point inputs");
-
-		if(x < 0)
-			return genType(int(x - genType(0.5)));
-		return genType(int(x + genType(0.5)));
-    }
-
-	VECTORIZE_VEC(round)
-
-/*
-    // roundEven
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs");
-
-		return genType(int(x + genType(int(x) % 2)));
-    }
-*/
-	
-    // roundEven
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType roundEven(genType const & x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs");
-		
-		int Integer = int(x);
-		genType IntegerPart = genType(Integer);
-		genType FractionalPart = fract(x);
-
-		if(FractionalPart > genType(0.5) || FractionalPart < genType(0.5))
-		{
-			return round(x);
-		}
-		else if((Integer % 2) == 0)
-		{
-			return IntegerPart;
-		}
-		else if(x <= genType(0)) // Work around... 
-		{
-			return IntegerPart - 1;
-		}
-		else
-		{
-			return IntegerPart + 1;
-		}
-		//else // Bug on MinGW 4.5.2
-		//{
-		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
-		//}
-	}
-	
-	VECTORIZE_VEC(roundEven)
-
-    // ceil
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType ceil(genType const & x)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'ceil' only accept floating-point inputs");
-
-        return ::std::ceil(x);
-    }
-
-	VECTORIZE_VEC(ceil)
-
-    // fract
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType fract
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'fract' only accept floating-point inputs");
-
-        return x - ::std::floor(x);
-    }
-
-	VECTORIZE_VEC(fract)
-
-    // mod
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType mod
-	(
-		genType const & x, 
-		genType const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mod' only accept floating-point inputs");
-
-        return x - y * floor(x / y);
-    }
-
-	VECTORIZE_VEC_SCA(mod)
-	VECTORIZE_VEC_VEC(mod)
-
-    // modf
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType modf
-	(
-		genType const & x, 
-		genType & i
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'modf' only accept floating-point inputs");
-
-		return std::modf(x, &i);
-    }
-
-    template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec2<valType> modf
-	(
-		detail::tvec2<valType> const & x, 
-		detail::tvec2<valType> & i
-	)
-    {
-        return detail::tvec2<valType>(
-            modf(x.x, i.x),
-            modf(x.y, i.y));
-    }
-
-    template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec3<valType> modf
-	(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> & i
-	)
-    {
-        return detail::tvec3<valType>(
-            modf(x.x, i.x),
-            modf(x.y, i.y),
-            modf(x.z, i.z));
-    }
-
-    template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec4<valType> modf
-	(
-		detail::tvec4<valType> const & x, 
-		detail::tvec4<valType> & i
-	)
-    {
-        return detail::tvec4<valType>(
-            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 const & x, 
-		genType const & y
-	)
-    {
-		GLM_STATIC_ASSERT(
-			detail::type<genType>::is_float || 
-			detail::type<genType>::is_int ||
-			detail::type<genType>::is_uint, "'min' only accept numbers");
-
-        return x < y ? x : y;
-    }
-
-	VECTORIZE_VEC_SCA(min)
-	VECTORIZE_VEC_VEC(min)
-
-    // max
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType max
-	(
-		genType const & x, 
-		genType const & y
-	)
-    {
-		GLM_STATIC_ASSERT(
-			detail::type<genType>::is_float || 
-			detail::type<genType>::is_int ||
-			detail::type<genType>::is_uint, "'max' only accept numbers");
-
-		return x > y ? x : y;
-    }
-
-	VECTORIZE_VEC_SCA(max)
-	VECTORIZE_VEC_VEC(max)
-
-    // clamp
-    template <typename valType>
-    GLM_FUNC_QUALIFIER valType clamp
-	(
-		valType const & x, 
-		valType const & minVal, 
-		valType const & maxVal
-	)
-    {
-		GLM_STATIC_ASSERT(
-			detail::type<valType>::is_float || 
-			detail::type<valType>::is_int ||
-			detail::type<valType>::is_uint, "'clamp' only accept numbers");
-		
-		// Old implementation, less predictable branching
-		//if(x >= maxVal) return maxVal; 
-        //if(x <= minVal) return minVal;
-	    //return x;
-		return max(min(x, maxVal), minVal);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
-	(
-		detail::tvec2<T> const & x, 
-		typename detail::tvec2<T>::value_type const & minVal, 
-		typename detail::tvec2<T>::value_type const & maxVal
-	)
-    {
-        return detail::tvec2<T>(
-            clamp(x.x, minVal, maxVal),
-            clamp(x.y, minVal, maxVal));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
-	(
-		detail::tvec3<T> const & x, 
-		typename detail::tvec3<T>::value_type const & minVal, 
-		typename detail::tvec3<T>::value_type const & maxVal
-	)
-    {
-        return detail::tvec3<T>(
-            clamp(x.x, minVal, maxVal),
-            clamp(x.y, minVal, maxVal),
-            clamp(x.z, minVal, maxVal));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
-	(
-		detail::tvec4<T> const & x, 
-		typename detail::tvec4<T>::value_type const & minVal, 
-		typename detail::tvec4<T>::value_type const & maxVal
-	)
-    {
-        return detail::tvec4<T>(
-            clamp(x.x, minVal, maxVal),
-            clamp(x.y, minVal, maxVal),
-            clamp(x.z, minVal, maxVal),
-            clamp(x.w, minVal, maxVal));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & minVal, 
-		detail::tvec2<T> const & maxVal
-	)
-    {
-        return detail::tvec2<T>(
-            clamp(x.x, minVal.x, maxVal.x),
-            clamp(x.y, minVal.y, maxVal.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & minVal, 
-		detail::tvec3<T> const & maxVal
-	)
-    {
-        return detail::tvec3<T>(
-            clamp(x.x, minVal.x, maxVal.x),
-            clamp(x.y, minVal.y, maxVal.y),
-            clamp(x.z, minVal.z, maxVal.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & minVal, 
-		detail::tvec4<T> const & maxVal
-	)
-    {
-        return detail::tvec4<T>(
-            clamp(x.x, minVal.x, maxVal.x),
-            clamp(x.y, minVal.y, maxVal.y),
-            clamp(x.z, minVal.z, maxVal.z),
-            clamp(x.w, minVal.w, maxVal.w));
-    }
-
-	// mix
-	template <typename genTypeT, typename genTypeU>
-	GLM_FUNC_QUALIFIER genTypeT mix
-	(
-		genTypeT const & x, 
-		genTypeT const & y, 
-		genTypeU const & a
-	)
-	{
-		// It could be a vector too
-		//GLM_STATIC_ASSERT(
-		//	detail::type<genTypeT>::is_float && 
-		//	detail::type<genTypeU>::is_float);
-
-		//return x + a * (y - x);
-		return genTypeT(genTypeU(x) + a * genTypeU(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
-	(
-		detail::tvec2<valTypeA> const & x, 
-		detail::tvec2<valTypeA> const & y, 
-		valTypeB const & a
-	)
-	{
-		return detail::tvec2<valTypeA>(
-			detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
-	(
-		detail::tvec3<valTypeA> const & x, 
-		detail::tvec3<valTypeA> const & y, 
-		valTypeB const & a
-	)
-	{
-		return detail::tvec3<valTypeA>(
-			detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
-	(
-		detail::tvec4<valTypeA> const & x, 
-		detail::tvec4<valTypeA> const & y, 
-		valTypeB const & a
-	)
-	{
-		return detail::tvec4<valTypeA>(
-			detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
-	(
-		detail::tvec2<valTypeA> const & x, 
-		detail::tvec2<valTypeA> const & y, 
-		detail::tvec2<valTypeB> const & a
-	)
-	{
-		return detail::tvec2<valTypeA>(
-			detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
-	(
-		detail::tvec3<valTypeA> const & x, 
-		detail::tvec3<valTypeA> const & y, 
-		detail::tvec3<valTypeB> const & a
-	)
-	{
-		return detail::tvec3<valTypeA>(
-			detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
-	}
-
-	template <typename valTypeA, typename valTypeB>
-	GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
-	(
-		detail::tvec4<valTypeA> const & x, 
-		detail::tvec4<valTypeA> const & y, 
-		detail::tvec4<valTypeB> const & a
-	)
-	{
-		return detail::tvec4<valTypeA>(
-			detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
-	}
-
-	//template <typename genTypeT>
-	//GLM_FUNC_QUALIFIER genTypeT mix
-	//(
-	//	genTypeT const & x, 
-	//	genTypeT const & y, 
-	//	float const & a
-	//)
-	//{
-	//	// It could be a vector too
-	//	//GLM_STATIC_ASSERT(
-	//	//	detail::type<genTypeT>::is_float && 
-	//	//	detail::type<genTypeU>::is_float);
-
-	//	return x + a * (y - x);
-	//}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType mix
-	(
-		genType const & x, 
-		genType const & y, 
-		bool const & a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
-
-		return a ? y : x;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> mix
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		typename detail::tvec2<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec2<T> result;
-		for
-		(
-			typename detail::tvec2<T>::size_type i = 0; 
-			i < detail::tvec2<T>::value_size(); 
-			++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> mix
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		typename detail::tvec3<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec3<T> result;
-		for
-		(
-			typename detail::tvec3<T>::size_type i = 0; 
-			i < detail::tvec3<T>::value_size(); 
-			++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> mix
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		typename detail::tvec4<T>::bool_type a
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
-
-		detail::tvec4<T> result;
-		for
-		(
-			typename detail::tvec4<T>::size_type i = 0; 
-			i < detail::tvec4<T>::value_size(); 
-			++i
-		)
-		{
-			result[i] = a[i] ? y[i] : x[i];
-		}
-		return result;
-	}
-
-	// step
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType step
-	(
-		genType const & edge, 
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
-
-        return x < edge ? genType(0) : genType(1);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> step
-	(
-		typename detail::tvec2<T>::value_type const & edge, 
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            x.x < edge ? T(0) : T(1),
-            x.y < edge ? T(0) : T(1));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> step
-	(
-		typename detail::tvec3<T>::value_type const & edge, 
-		detail::tvec3<T> const & x
-	)
-    {
-		return detail::tvec3<T>(
-			x.x < edge ? T(0) : T(1),
-			x.y < edge ? T(0) : T(1),
-			x.z < edge ? T(0) : T(1));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> step
-	(
-		typename detail::tvec4<T>::value_type const & edge, 
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            x.x < edge ? T(0) : T(1),
-            x.y < edge ? T(0) : T(1),
-            x.z < edge ? T(0) : T(1),
-            x.w < edge ? T(0) : T(1));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> step
-	(
-		detail::tvec2<T> const & edge, 
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            x.x < edge.x ? T(0) : T(1),
-            x.y < edge.y ? T(0) : T(1));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> step
-	(
-		detail::tvec3<T> const & edge, 
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            x.x < edge.x ? T(0) : T(1),
-            x.y < edge.y ? T(0) : T(1),
-            x.z < edge.z ? T(0) : T(1));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> step
-	(
-		detail::tvec4<T> const & edge, 
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            x.x < edge.x ? T(0) : T(1),
-            x.y < edge.y ? T(0) : T(1),
-            x.z < edge.z ? T(0) : T(1),
-            x.w < edge.w ? T(0) : T(1));
-    }
-
-    // smoothstep
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType smoothstep
-	(
-		genType const & edge0, 
-		genType const & edge1, 
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
-
-        genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1));
-        return tmp * tmp * (genType(3) - genType(2) * tmp);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
-	(
-		typename detail::tvec2<T>::value_type const & edge0, 
-		typename detail::tvec2<T>::value_type const & edge1, 
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            smoothstep(edge0, edge1, x.x),
-            smoothstep(edge0, edge1, x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
-	(
-		typename detail::tvec3<T>::value_type const & edge0, 
-		typename detail::tvec3<T>::value_type const & edge1, 
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            smoothstep(edge0, edge1, x.x),
-            smoothstep(edge0, edge1, x.y),
-            smoothstep(edge0, edge1, x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
-	(
-		typename detail::tvec4<T>::value_type const & edge0, 
-		typename detail::tvec4<T>::value_type const & edge1, 
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            smoothstep(edge0, edge1, x.x),
-            smoothstep(edge0, edge1, x.y),
-            smoothstep(edge0, edge1, x.z),
-            smoothstep(edge0, edge1, x.w));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
-	(
-		detail::tvec2<T> const & edge0, 
-		detail::tvec2<T> const & edge1, 
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            smoothstep(edge0.x, edge1.x, x.x),
-            smoothstep(edge0.y, edge1.y, x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
-	(
-		detail::tvec3<T> const & edge0, 
-		detail::tvec3<T> const & edge1, 
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            smoothstep(edge0.x, edge1.x, x.x),
-            smoothstep(edge0.y, edge1.y, x.y),
-            smoothstep(edge0.z, edge1.z, x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
-	(
-		detail::tvec4<T> const & edge0, 
-		detail::tvec4<T> const & edge1, 
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            smoothstep(edge0.x, edge1.x, x.x),
-            smoothstep(edge0.y, edge1.y, x.y),
-            smoothstep(edge0.z, edge1.z, x.z),
-            smoothstep(edge0.w, edge1.w, x.w));
-    }
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER bool isnan(genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isnan' only accept floating-point inputs");
-
-#       if(GLM_COMPILER & GLM_COMPILER_VC)
-            return _isnan(x) != 0;
-#       elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#           if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-                return _isnan(x) != 0;
-#           else
-                return std::isnan(x) != 0;
-#           endif
-#       else
-            return std::isnan(x) != 0;
-#       endif
-	}
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isnan
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return typename detail::tvec2<T>::bool_type(
-            isnan(x.x),
-            isnan(x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isnan
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return typename detail::tvec3<T>::bool_type(
-            isnan(x.x),
-            isnan(x.y),
-            isnan(x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isnan
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return typename detail::tvec4<T>::bool_type(
-            isnan(x.x),
-            isnan(x.y),
-            isnan(x.z),
-            isnan(x.w));
-    }
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER bool isinf(
-		genType const & x)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs");
-
-#       if(GLM_COMPILER & GLM_COMPILER_VC)
-            return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-#       elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#           if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-                return _isinf(x) != 0;
-#           else
-                return std::isinf(x) != 0;
-#           endif
-#       else
-            return std::isinf(x) != 0;
-#       endif
-	}
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isinf
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return typename detail::tvec2<T>::bool_type(
-            isinf(x.x),
-            isinf(x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isinf
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return typename detail::tvec3<T>::bool_type(
-            isinf(x.x),
-            isinf(x.y),
-            isinf(x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isinf
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return typename detail::tvec4<T>::bool_type(
-            isinf(x.x),
-            isinf(x.y),
-            isinf(x.z),
-            isinf(x.w));
-    }
-
-	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & value)
-	{
-		union
-		{
-			float f;
-			int i;
-		} fi;
-
-		fi.f = value;
-		return fi.i;
-	}
-
-    GLM_FUNC_QUALIFIER detail::tvec2<int> floatBitsToInt
-	(
-		detail::tvec2<float> const & value
-	)
-    {
-        return detail::tvec2<int>(
-            floatBitsToInt(value.x),
-            floatBitsToInt(value.y));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec3<int> floatBitsToInt
-	(
-		detail::tvec3<float> const & value
-	)
-    {
-        return detail::tvec3<int>(
-            floatBitsToInt(value.x),
-			floatBitsToInt(value.y),
-			floatBitsToInt(value.z));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec4<int> floatBitsToInt
-	(
-		detail::tvec4<float> const & value
-	)
-    {
-        return detail::tvec4<int>(
-            floatBitsToInt(value.x),
-			floatBitsToInt(value.y),
-			floatBitsToInt(value.z),
-			floatBitsToInt(value.w));
-    }
-
-	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & value)
-	{
-		union
-		{
-			float f;
-			uint u;
-		} fu;
-
-		fu.f = value;
-		return fu.u;
-	}
-
-    GLM_FUNC_QUALIFIER detail::tvec2<uint> floatBitsToUint
-	(
-		detail::tvec2<float> const & value
-	)
-    {
-        return detail::tvec2<uint>(
-            floatBitsToUint(value.x),
-            floatBitsToUint(value.y));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec3<uint> floatBitsToUint
-	(
-		detail::tvec3<float> const & value
-	)
-    {
-        return detail::tvec3<uint>(
-            floatBitsToUint(value.x),
-			floatBitsToUint(value.y),
-			floatBitsToUint(value.z));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec4<uint> floatBitsToUint
-	(
-		detail::tvec4<float> const & value
-	)
-    {
-        return detail::tvec4<uint>(
-            floatBitsToUint(value.x),
-			floatBitsToUint(value.y),
-			floatBitsToUint(value.z),
-			floatBitsToUint(value.w));
-    }
-
-	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & value)
-	{
-		union
-		{
-			float f;
-			int i;
-		} fi;
-
-		fi.i = value;
-		return fi.f;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<float> intBitsToFloat
-
-	(
-		detail::tvec2<int> const & value
-	)
-    {
-        return detail::tvec2<float>(
-            intBitsToFloat(value.x),
-            intBitsToFloat(value.y));
-    }
-
-	GLM_FUNC_QUALIFIER detail::tvec3<float> intBitsToFloat
-	(
-		detail::tvec3<int> const & value
-	)
-    {
-        return detail::tvec3<float>(
-            intBitsToFloat(value.x),
-			intBitsToFloat(value.y),
-			intBitsToFloat(value.z));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec4<float> intBitsToFloat
-	(
-		detail::tvec4<int> const & value
-	)
-    {
-        return detail::tvec4<float>(
-            intBitsToFloat(value.x),
-			intBitsToFloat(value.y),
-			intBitsToFloat(value.z),
-			intBitsToFloat(value.w));
-    }
-
-    GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & value)
-    {
-        union
-        {
-            float f;
-            uint u;
-        } fu;
-
-        fu.u = value;
-        return fu.f;
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec2<float> uintBitsToFloat
-	(
-		detail::tvec2<uint> const & value
-	)
-    {
-        return detail::tvec2<float>(
-            uintBitsToFloat(value.x),
-            uintBitsToFloat(value.y));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec3<float> uintBitsToFloat
-	(
-		detail::tvec3<uint> const & value
-	)
-    {
-        return detail::tvec3<float>(
-            uintBitsToFloat(value.x),
-			uintBitsToFloat(value.y),
-			uintBitsToFloat(value.z));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec4<float> uintBitsToFloat
-	(
-		detail::tvec4<uint> const & value
-	)
-    {
-        return detail::tvec4<float>(
-            uintBitsToFloat(value.x),
-			uintBitsToFloat(value.y),
-			uintBitsToFloat(value.z),
-			uintBitsToFloat(value.w));
-    }
-
-	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 const & x, 
-		int & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> frexp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> frexp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> frexp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<int> & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ldexp
-	(
-		genType const & x, 
-		int const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> ldexp
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> ldexp
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> ldexp
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<int> const & exp
-	)
-	{
-		return std::frexp(x, exp);
-	}
-
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_exponential.hpp b/thirdparty/glm/glm/core/func_exponential.hpp
deleted file mode 100644
index 69399e86..00000000
--- a/thirdparty/glm/glm/core/func_exponential.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_exponential
-#define glm_core_func_exponential GLM_VERSION
-
-namespace glm
-{
-	/// @addtogroup core_func_exponential
-	/// @{
-
-	/// Returns x raised to the y power. 
-	///
-	/// @param x pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
-	/// @param y 
-	/// @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 genType> 
-	genType pow(genType const & x, genType const & y);
-
-	/// Returns the natural exponentiation of x, i.e., e^x.
-	///
-	/// @param x exp function is defined for input values of x 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 genType> 
-	genType exp(genType const & x);
-
-	/// Returns the natural logarithm of x, i.e., 
-	/// returns the value y which satisfies the equation x = e^y. 
-	/// Results are undefined if x <= 0.
-	///
-	/// @param x log function is defined for input values of x 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 genType> 
-	genType log(genType const & x);
-
-	/// Returns 2 raised to the x power.
-	/// 
-	/// @param x exp2 function is defined for input values of x 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 genType> 
-	genType exp2(genType const & x);
-
-	/// Returns the base 2 log of x, i.e., returns the value y, 
-	/// which satisfies the equation x = 2 ^ y.
-    /// 
-	/// @param x log2 function is defined for input values of x 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 genType> 
-	genType log2(genType const & x);
-
-	/// Returns the positive square root of x.
-    /// 
-	/// @param x sqrt function is defined for input values of x 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> 
-	genType sqrt(genType const & x);
-    
-	/// Returns the reciprocal of the positive square root of x.
-    /// 
-	/// @param x inversesqrt function is defined for input values of x 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 genType> 
-	genType inversesqrt(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_exponential.inl"
-
-#endif//glm_core_func_exponential
diff --git a/thirdparty/glm/glm/core/func_exponential.inl b/thirdparty/glm/glm/core/func_exponential.inl
deleted file mode 100644
index 5ad49b7b..00000000
--- a/thirdparty/glm/glm/core/func_exponential.inl
+++ /dev/null
@@ -1,157 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-
-namespace glm
-{
-    // pow
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType pow
-	(
-		genType const & x, 
-		genType const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'pow' only accept floating-point input");
-
-        return ::std::pow(x, y);
-    }
-
-	VECTORIZE_VEC_VEC(pow)
-
-    // exp
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType exp
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp' only accept floating-point input");
-
-        return ::std::exp(x);
-    }
-
-	VECTORIZE_VEC(exp)
-
-    // log
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType log
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log' only accept floating-point input");
-
-        return ::std::log(x);
-    }
-
-	VECTORIZE_VEC(log)
-
-    //exp2, ln2 = 0.69314718055994530941723212145818f
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType exp2
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp2' only accept floating-point input");
-
-        return ::std::exp(genType(0.69314718055994530941723212145818) * x);
-    }
-
-	VECTORIZE_VEC(exp2)
-
-namespace _detail
-{
-	template <int _PATH = detail::float_or_int_value::GLM_ERROR>
-	struct _compute_log2
-	{
-		template <typename T>
-		T operator() (T const & Value) const;
-/*
-		{
-			GLM_STATIC_ASSERT(0, "'log2' parameter has an invalid template parameter type. GLM core features only supports floating-point types, include <glm/gtx/integer.hpp> for integer types support. Others types are not supported.");
-			return Value;
-		}
-*/
-	};
-
-	template <>
-	struct _compute_log2<detail::float_or_int_value::GLM_FLOAT>
-	{
-		template <typename T>
-		T operator() (T const & Value) const
-		{
-			return T(::std::log(Value)) / T(0.69314718055994530941723212145818);
-		}
-	};
-    
-}//namespace _detail
-
-    // log2, ln2 = 0.69314718055994530941723212145818f
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType log2
-	(
-		genType const & x
-	)
-    {
-		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
-		return _detail::_compute_log2<detail::float_or_int_trait<genType>::ID>()(x);
-    }
-
-	VECTORIZE_VEC(log2)
-
-    // sqrt
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType sqrt
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sqrt' only accept floating-point input");
-
-        return genType(::std::sqrt(x));
-    }
-
-	VECTORIZE_VEC(sqrt)
-
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType inversesqrt
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
-
-        return genType(1) / ::std::sqrt(x);
-    }
-
-	VECTORIZE_VEC(inversesqrt)
-
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_geometric.hpp b/thirdparty/glm/glm/core/func_geometric.hpp
deleted file mode 100644
index d24a9c86..00000000
--- a/thirdparty/glm/glm/core/func_geometric.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_geometric
-#define glm_core_func_geometric GLM_VERSION
-
-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 genType> 
-        typename genType::value_type length(
-		genType 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 genType> 
-	typename genType::value_type distance(
-		genType const & p0, 
-		genType 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 genType> 
-	typename genType::value_type dot(
-		genType const & x, 
-		genType 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 valType> 
-	detail::tvec3<valType> cross(
-		detail::tvec3<valType> const & x, 
-		detail::tvec3<valType> const & y);
-
-	/// Returns a vector in the same direction as x but with length of 1.
-    /// 
-    /// @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 genType> 
-	genType normalize(
-		genType 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 genType> 
-	genType faceforward(
-		genType const & N, 
-		genType const & I, 
-		genType 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> 
-	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 genType> 
-	genType refract(
-		genType const & I, 
-		genType const & N, 
-		typename genType::value_type const & eta);
-
-	/// @}
-}//namespace glm
-
-#include "func_geometric.inl"
-
-#endif//glm_core_func_geometric
diff --git a/thirdparty/glm/glm/core/func_geometric.inl b/thirdparty/glm/glm/core/func_geometric.inl
deleted file mode 100644
index ccc5bbc5..00000000
--- a/thirdparty/glm/glm/core/func_geometric.inl
+++ /dev/null
@@ -1,324 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_geometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-
-namespace glm
-{
-    // length
-    template <typename genType>
-	GLM_FUNC_QUALIFIER genType length
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'length' only accept floating-point inputs");
-
-        genType sqr = x * x;
-        return sqrt(sqr);
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type length
-	(
-		detail::tvec2<T> const & v
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-        typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
-        return sqrt(sqr);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type length
-	(
-		detail::tvec3<T> const & v
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-        typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
-        return sqrt(sqr);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type length
-	(
-		detail::tvec4<T> const & v
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
-
-        typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
-        return sqrt(sqr);
-    }
-
-    // distance
-	template <typename genType>
-    GLM_FUNC_QUALIFIER genType distance
-	(
-		genType const & p0, 
-		genType const & p1
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-    }
- 
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type distance
-	(
-		detail::tvec2<T> const & p0,
-		detail::tvec2<T> const & p1
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-        return length(p1 - p0);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type distance
-	(
-		detail::tvec3<T> const & p0,
-		detail::tvec3<T> const & p1
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type distance
-	(
-		detail::tvec4<T> const & p0,
-		detail::tvec4<T> const & p1
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-    }
-
-	// dot
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType dot
-	(
-		genType const & x, 
-		genType const & y
-        
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");
-
-		return x * y;
-	}
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type dot
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-		return x.x * y.x + x.y * y.y;
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-		return x.x * y.x + x.y * y.y + x.z * y.z;
-    }
-/* // SSE3
-    GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
-    {
-	    float Result;
-	    __asm
-        {
-		    mov		esi, x
-		    mov		edi, y
-		    movaps	xmm0, [esi]
-		    mulps	xmm0, [edi]
-		    haddps(	_xmm0, _xmm0 )
-		    haddps(	_xmm0, _xmm0 )
-		    movss	Result, xmm0
-	    }
-	    return Result;
-    }
-*/
-    template <typename T>
-    GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
-
-        return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
-    }
-
-    // cross
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> cross
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'cross' only accept floating-point inputs");
-
-        return detail::tvec3<T>(
-            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(detail::type<genType>::is_float, "'normalize' only accept floating-point inputs");
-
-        return x < genType(0) ? genType(-1) : genType(1);
-    }
-
-    // According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> normalize
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-		
-		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
-	    return x * inversesqrt(sqr);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> normalize
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-
-		typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
-	    return x * inversesqrt(sqr);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> normalize
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
-		
-		typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-	    return x * inversesqrt(sqr);
-    }
-
-    // faceforward
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward
-	(
-		genType const & N, 
-		genType const & I, 
-		genType const & Nref
-	)
-	{
-		return dot(Nref, I) < 0 ? N : -N;
-	}
-
-	// reflect
-	template <typename genType>
-	genType reflect
-	(
-		genType const & I, 
-		genType const & N
-	)
-	{
-		return I - N * dot(N, I) * genType(2);
-	}
-
-    // refract
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType refract
-	(
-		genType const & I, 
-		genType const & N, 
-		genType const & eta
-	)
-    {
-		//It could be a vector
-		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
-
-        genType dotValue = dot(N, I);
-        genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
-        if(k < genType(0))
-            return genType(0);
-        else
-            return eta * I - (eta * dotValue + sqrt(k)) * N;
-    }
-
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType refract
-	(
-		genType const & I, 
-		genType const & N, 
-		typename genType::value_type const & eta
-	)
-    {
-		//It could be a vector
-		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
-
-        typename genType::value_type dotValue = dot(N, I);
-        typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
-        if(k < typename genType::value_type(0))
-            return genType(0);
-        else
-            return eta * I - (eta * dotValue + sqrt(k)) * N;
-    }
-
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_integer.hpp b/thirdparty/glm/glm/core/func_integer.hpp
deleted file mode 100644
index c9ae0c09..00000000
--- a/thirdparty/glm/glm/core/func_integer.hpp
+++ /dev/null
@@ -1,201 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_integer
-#define glm_core_func_integer GLM_VERSION
-
-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 <typename genUType>
-	genUType uaddCarry(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & 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 <typename genUType>
-	genUType usubBorrow(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & 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 <typename genUType>
-	void umulExtended(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & msb, 
-		genUType & 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 <typename genIType>
-	void imulExtended(
-		genIType const & x, 
-		genIType const & y, 
-		genIType & msb, 
-		genIType & 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 genIUType 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 genIUType>
-	genIUType bitfieldExtract(
-		genIUType const & Value, 
-		int const & Offset, 
-		int const & 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 genIUType 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 genIUType>
-	genIUType bitfieldInsert(
-		genIUType const & Base, 
-		genIUType const & Insert, 
-		int const & Offset, 
-		int const & 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 genIUType 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 genIUType>
-	genIUType bitfieldReverse(genIUType const & value);
-		
-	/// Returns the number of bits set to 1 in the binary representation of value.
-	///
-	/// @tparam genIUType 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>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
-
-	/// 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 genIUType Signed or unsigned integer scalar or vector 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>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
-
-	/// 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 genIUType Signed or unsigned integer scalar or vector 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>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
-	template <typename T, template <typename> class genIUType>
-	typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
-
-	/// @}
-}//namespace glm
-
-#include "func_integer.inl"
-
-#endif//glm_core_func_integer
-
diff --git a/thirdparty/glm/glm/core/func_integer.inl b/thirdparty/glm/glm/core/func_integer.inl
deleted file mode 100644
index 5de9fcbf..00000000
--- a/thirdparty/glm/glm/core/func_integer.inl
+++ /dev/null
@@ -1,602 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_integer.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#include <intrin.h>
-#pragma intrinsic(_BitScanReverse)
-#endif
-
-namespace glm
-{
-	// uaddCarry
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER genUType uaddCarry
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & Carry
-	)
-	{
-		detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
-		genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
-		Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
-		return Result;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & Carry
-	)
-	{
-		return detail::tvec2<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & Carry
-	)
-	{
-		return detail::tvec3<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & Carry
-	)
-	{
-		return detail::tvec4<T>(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]),
-			uaddCarry(x[3], y[3], Carry[3]));
-	}
-
-	// usubBorrow
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER genUType usubBorrow
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & Borrow
-	)
-	{
-		Borrow = x >= y ? 0 : 1;
-		if(x > y)
-			return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
-		else
-			return genUType(detail::highp_int_t(1) << detail::highp_int_t(32) + detail::highp_int_t(x) - detail::highp_int_t(y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & Borrow
-	)
-	{
-		return detail::tvec2<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & Borrow
-	)
-	{
-		return detail::tvec3<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & Borrow
-	)
-	{
-		return detail::tvec4<T>(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]),
-			usubBorrow(x[3], y[3], Borrow[3]));
-	}
-
-	// umulExtended
-	template <typename genUType>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		genUType const & x, 
-		genUType const & y, 
-		genUType & msb, 
-		genUType & lsb
-	)
-	{
-		detail::highp_uint_t ValueX64 = x;
-		detail::highp_uint_t ValueY64 = y;
-		detail::highp_uint_t Value64 = ValueX64 * ValueY64;
-		msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-		lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & msb, 
-		detail::tvec2<T> & lsb
-	)
-	{
-		return detail::tvec2<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & msb, 
-		detail::tvec3<T> & lsb
-	)
-	{
-		return detail::tvec3<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb),
-			umulExtended(x[2], y[2], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & msb, 
-		detail::tvec4<T> & lsb
-	)
-	{
-		return detail::tvec4<T>(
-			umulExtended(x[0], y[0], msb, lsb),
-			umulExtended(x[1], y[1], msb, lsb),
-			umulExtended(x[2], y[2], msb, lsb),
-			umulExtended(x[3], y[3], msb, lsb));
-	}
-
-	// imulExtended
-	template <typename genIType>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		genIType const & x, 
-		genIType const & y, 
-		genIType & msb, 
-		genIType & lsb
-	)
-	{
-		detail::highp_int_t ValueX64 = x;
-		detail::highp_int_t ValueY64 = y;
-		detail::highp_int_t Value64 = ValueX64 * ValueY64;
-		msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-		lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
-	(
-		detail::tvec2<T> const & x, 
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> & msb, 
-		detail::tvec2<T> & lsb
-	)
-	{
-		return detail::tvec2<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
-	(
-		detail::tvec3<T> const & x, 
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> & msb, 
-		detail::tvec3<T> & lsb
-	)
-	{
-		return detail::tvec3<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb),
-			imulExtended(x[2], y[2], msb, lsb));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
-	(
-		detail::tvec4<T> const & x, 
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> & msb, 
-		detail::tvec4<T> & lsb
-	)
-	{
-		return detail::tvec4<T>(
-			imulExtended(x[0], y[0], msb, lsb),
-			imulExtended(x[1], y[1], msb, lsb),
-			imulExtended(x[2], y[2], msb, lsb),
-			imulExtended(x[3], y[3], msb, lsb));
-	}
-
-	// bitfieldExtract
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
-	(
-		genIUType const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		int GenSize = int(sizeof(genIUType)) << int(3);
-
-		assert(Offset + Bits <= GenSize);
-
-		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
-		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
-
-		return ShiftBack;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
-	(
-		detail::tvec2<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
-	(
-		detail::tvec3<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
-	(
-		detail::tvec4<T> const & Value, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits),
-			bitfieldExtract(Value[3], Offset, Bits));
-	}
-
-	// bitfieldInsert
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
-	(
-		genIUType const & Base, 
-		genIUType const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
-		assert(Offset + Bits <= sizeof(genIUType));
-
-		if(Bits == 0)
-			return Base;
-
-		genIUType Mask = 0;
-		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
-			Mask |= (1 << Bit);
-
-		return (Base & ~Mask) | (Insert & Mask);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
-	(
-		detail::tvec2<T> const & Base, 
-		detail::tvec2<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
-	(
-		detail::tvec3<T> const & Base, 
-		detail::tvec3<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
-	(
-		detail::tvec4<T> const & Base, 
-		detail::tvec4<T> const & Insert, 
-		int const & Offset, 
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
-			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
-	}
-
-	// bitfieldReverse
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
-
-		genIUType Out = 0;
-		std::size_t BitSize = sizeof(genIUType) * 8;
-		for(std::size_t i = 0; i < BitSize; ++i)
-			if(Value & (genIUType(1) << i))
-				Out |= genIUType(1) << (BitSize - 1 - i);
-		return Out;
-	}	
-
-	VECTORIZE_VEC(bitfieldReverse)
-
-	// bitCount
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
-
-		int Count = 0;
-		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
-		{
-			if(Value & (1 << i))
-				++Count;
-		}
-		return Count;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			bitCount(value[0]),
-			bitCount(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]),
-			bitCount(value[3]));
-	}
-
-	// findLSB
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findLSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		genIUType Bit;
-		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
-		return Bit;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			findLSB(value[0]),
-			findLSB(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]),
-			findLSB(value[3]));
-	}
-
-	// findMSB
-#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		unsigned long Result(0);
-		_BitScanReverse(&Result, Value); 
-		return int(Result);
-	}
-
-#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		return __builtin_clz(Value);
-	}
-
-#else
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		genIUType bit = genIUType(-1);
-		for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
-		return bit;
-	}
-#endif//(GLM_COMPILER)
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
-	(
-		detail::tvec2<T> const & value
-	)
-	{
-		return detail::tvec2<int>(
-			findMSB(value[0]),
-			findMSB(value[1]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
-	(
-		detail::tvec3<T> const & value
-	)
-	{
-		return detail::tvec3<int>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
-	(
-		detail::tvec4<T> const & value
-	)
-	{
-		return detail::tvec4<int>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]),
-			findMSB(value[3]));
-	}
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_matrix.hpp b/thirdparty/glm/glm/core/func_matrix.hpp
deleted file mode 100644
index 41acf596..00000000
--- a/thirdparty/glm/glm/core/func_matrix.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_matrix
-#define GLM_CORE_func_matrix GLM_VERSION
-
-namespace glm
-{
-	/// @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 matType> 
-	matType matrixCompMult(
-		matType const & x, 
-		matType 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>
-	/// 
-	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
-    template <typename vecType, typename matType> 
-	matType outerProduct(
-		vecType const & c, 
-		vecType 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>	
-    template <typename matType> 
-	typename matType::transpose_type transpose(
-		matType const & x);
-	
-	/// Return the determinant of a mat2 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 valType> 
-	typename detail::tmat2x2<valType>::value_type determinant(
-		detail::tmat2x2<valType> const & m);
-
-	/// Return the determinant of a mat3 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 valType> 
-	typename detail::tmat3x3<valType>::value_type determinant(
-		detail::tmat3x3<valType> const & m);
-
-	/// Return the determinant of a mat4 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 valType> 
-	typename detail::tmat4x4<valType>::value_type determinant(
-		detail::tmat4x4<valType> const & m);
-
-	/// Return the inverse of a mat2 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 valType> 
-	detail::tmat2x2<valType> inverse(
-		detail::tmat2x2<valType> const & m);
-
-	/// Return the inverse of a mat3 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 valType> 
-	detail::tmat3x3<valType> inverse(
-		detail::tmat3x3<valType> const & m);
-
-	/// Return the inverse of a mat4 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 valType> 
-	detail::tmat4x4<valType> inverse(
-		detail::tmat4x4<valType> const & m);
-
-	/// @}
-}//namespace glm
-
-#include "func_matrix.inl"
-
-#endif//GLM_CORE_func_matrix
diff --git a/thirdparty/glm/glm/core/func_matrix.inl b/thirdparty/glm/glm/core/func_matrix.inl
deleted file mode 100644
index 3d8ab4f8..00000000
--- a/thirdparty/glm/glm/core/func_matrix.inl
+++ /dev/null
@@ -1,584 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_matrix.inl
-/// @date 2008-03-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-
-namespace glm
-{
-	// matrixCompMult
-	template <typename matType>
-	GLM_FUNC_QUALIFIER matType matrixCompMult
-	(
-		matType const & x, 
-		matType const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float, "'matrixCompMult' only accept floating-point inputs");
-
-		matType result(matType::null);
-		for(typename matType::size_type i = 0; i < matType::row_size(); ++i)
-			result[i] = x[i] * y[i];
-		return result;
-	}
-
-	// outerProduct
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
-		m[0][0] = c[0] * r[0];
-		m[0][1] = c[1] * r[0];
-		m[1][0] = c[0] * r[1];
-		m[1][1] = c[1] * r[1];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
-		for(typename detail::tmat3x3<T>::size_type i(0); i < m.length(); ++i)
-			m[i] = c * r[i];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
-		for(typename detail::tmat4x4<T>::size_type i(0); i < m.length(); ++i)
-			m[i] = c * r[i];
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x3<T> m(detail::tmat2x3<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x2<T> m(detail::tmat3x2<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec2<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat2x4<T> m(detail::tmat2x4<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[0][3] = c.w * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[1][3] = c.w * r.y;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> outerProduct
-	(
-		detail::tvec2<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x2<T> m(detail::tmat4x2<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[3][0] = c.x * r.w;
-		m[3][1] = c.y * r.w;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> outerProduct
-	(
-		detail::tvec4<T> const & c, 
-		detail::tvec3<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat3x4<T> m(detail::tmat3x4<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[0][3] = c.w * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[1][3] = c.w * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[2][2] = c.z * r.z;
-		m[2][3] = c.w * r.z;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> outerProduct
-	(
-		detail::tvec3<T> const & c, 
-		detail::tvec4<T> const & r
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
-
-		detail::tmat4x3<T> m(detail::tmat4x3<T>::null);
-		m[0][0] = c.x * r.x;
-		m[0][1] = c.y * r.x;
-		m[0][2] = c.z * r.x;
-		m[1][0] = c.x * r.y;
-		m[1][1] = c.y * r.y;
-		m[1][2] = c.z * r.y;
-		m[2][0] = c.x * r.z;
-		m[2][1] = c.y * r.z;
-		m[2][2] = c.z * r.z;
-		m[3][0] = c.x * r.w;
-		m[3][1] = c.y * r.w;
-		m[3][2] = c.z * r.w;
-		return m;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
-		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 <typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
-	(
-		detail::tmat3x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
-	(
-		detail::tmat2x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> transpose
-	(
-		detail::tmat4x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> transpose
-	(
-		detail::tmat2x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> transpose
-	(
-		detail::tmat4x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> transpose
-	(
-		detail::tmat3x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
-
-		detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
-		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>
-	GLM_FUNC_QUALIFIER typename detail::tmat2x2<T>::value_type determinant
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		return m[0][0] * m[1][1] - m[1][0] * m[0][1];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename detail::tmat3x3<T>::value_type determinant
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		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>
-	GLM_FUNC_QUALIFIER typename detail::tmat4x4<T>::value_type determinant
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
-
-		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];
-
-		detail::tvec4<T> 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];
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> inverse
-	(
-		detail::tmat2x2<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-			
-		//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-		T Determinant = determinant(m);
-
-		detail::tmat2x2<T> Inverse(
-			+ m[1][1] / Determinant,
-			- m[0][1] / Determinant, 
-			- m[1][0] / Determinant,
-			+ m[0][0] / Determinant);
-
-		return Inverse;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> inverse
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-
-		//valType Determinant = 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]);
-
-		T Determinant = determinant(m);
-
-		detail::tmat3x3<T> Inverse(detail::tmat3x3<T>::null);
-		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
-		Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
-		Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
-		Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
-		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
-		Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
-		Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-		Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
-		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
-		Inverse /= Determinant;
-
-		return Inverse;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> inverse
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
-
-		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		detail::tvec4<T> const SignA(+1, -1, +1, -1);
-		detail::tvec4<T> const SignB(-1, +1, -1, +1);
-
-		detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
-		detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
-		detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
-		detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
-		detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
-		detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
-
-		detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-		detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-		detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-		detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-
-		detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-		detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-		detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-		detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
-
-		detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
-
-		detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-
-		T Determinant = glm::dot(m[0], Row0);
-
-		Inverse /= Determinant;
-	    
-		return Inverse;
-	}
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_noise.hpp b/thirdparty/glm/glm/core/func_noise.hpp
deleted file mode 100644
index 296554e1..00000000
--- a/thirdparty/glm/glm/core/func_noise.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_func_noise
-#define glm_core_func_noise GLM_VERSION
-
-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>
-	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>
-	detail::tvec2<typename genType::value_type> 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>
-	detail::tvec3<typename genType::value_type> 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>
-	detail::tvec4<typename genType::value_type> noise4(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_noise.inl"
-
-#endif//glm_core_func_noise
diff --git a/thirdparty/glm/glm/core/func_noise.inl b/thirdparty/glm/glm/core/func_noise.inl
deleted file mode 100644
index af197e41..00000000
--- a/thirdparty/glm/glm/core/func_noise.inl
+++ /dev/null
@@ -1,364 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_noise.inl
-/// @date 2008-08-01 / 2011-09-27
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(T const & x)
-	{
-		return noise1(glm::detail::tvec2<T>(x, T(0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(T const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(T const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(T const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)),
-			noise1(x + T(2.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(glm::detail::tvec2<T> const & v)
-	{
-		detail::tvec4<T> const C = detail::tvec4<T>(
-													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
-		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
-		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(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;
-		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(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 ;
-		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
-		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
-		
-		// Permutations
-		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T> p = permute(
-									 permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
-									 + i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
-		
-		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
-														   dot(x0, x0), 
-														   dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
-														   dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(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)
-		
-		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T> h = abs(x) - T(0.5);
-		detail::tvec3<T> ox = floor(x + T(0.5));
-		detail::tvec3<T> a0 = x - ox;
-		
-		// Normalise gradients implicitly by scaling m
-		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
-		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
-		
-		// Compute final noise value at P
-		detail::tvec3<T> 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>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T> const & v)
-	{ 
-		detail::tvec2<T> const C(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T> const D(0.0, 0.5, 1.0, 2.0);
-		
-		// First corner
-		detail::tvec3<T> i(floor(v + dot(v, detail::tvec3<T>(C.y))));
-		detail::tvec3<T> x0(v - i + dot(i, detail::tvec3<T>(C.x)));
-		
-		// Other corners
-		detail::tvec3<T> g(step(detail::tvec3<T>(x0.y, x0.z, x0.x), x0));
-		detail::tvec3<T> l(T(1) - g);
-		detail::tvec3<T> i1(min(g, detail::tvec3<T>(l.z, l.x, l.y)));
-		detail::tvec3<T> i2(max(g, detail::tvec3<T>(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;
-		detail::tvec3<T> x1(x0 - i1 + C.x);
-		detail::tvec3<T> x2(x0 - i2 + C.y); // 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T> x3(x0 - D.y);      // -1.0+3.0*C.x = -0.5 = -D.y
-		
-		// Permutations
-		i = mod289(i); 
-		detail::tvec4<T> p(permute(permute(permute( 
-												   i.z + detail::tvec4<T>(T(0), i1.z, i2.z, T(1))) + 
-										   i.y + detail::tvec4<T>(T(0), i1.y, i2.y, T(1))) + 
-								   i.x + detail::tvec4<T>(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_ = T(0.142857142857); // 1.0/7.0
-		detail::tvec3<T> ns(n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x));
-		
-		detail::tvec4<T> j(p - T(49) * floor(p * ns.z * ns.z));  //  mod(p,7*7)
-		
-		detail::tvec4<T> x_(floor(j * ns.z));
-		detail::tvec4<T> y_(floor(j - T(7) * x_));    // mod(j,N)
-		
-		detail::tvec4<T> x(x_ * ns.x + ns.y);
-		detail::tvec4<T> y(y_ * ns.x + ns.y);
-		detail::tvec4<T> h(T(1) - abs(x) - abs(y));
-		
-		detail::tvec4<T> b0(x.x, x.y, y.x, y.y);
-		detail::tvec4<T> 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;
-		detail::tvec4<T> s0(floor(b0) * T(2) + T(1));
-		detail::tvec4<T> s1(floor(b1) * T(2) + T(1));
-		detail::tvec4<T> sh(-step(h, detail::tvec4<T>(0.0)));
-		
-		detail::tvec4<T> a0 = detail::tvec4<T>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
-		detail::tvec4<T> a1 = detail::tvec4<T>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
-		
-		detail::tvec3<T> p0(a0.x, a0.y, h.x);
-		detail::tvec3<T> p1(a0.z, a0.w, h.y);
-		detail::tvec3<T> p2(a1.x, a1.y, h.z);
-		detail::tvec3<T> p3(a1.z, a1.w, h.w);
-		
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(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
-		detail::tvec4<T> m = max(T(0.6) - detail::tvec4<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
-		m = m * m;
-		return T(42) * dot(m * m, detail::tvec4<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T> const & v)
-	{
-		detail::tvec4<T> 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 = T(0.309016994374947451);
-		
-		// First corner
-		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
-		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
-		
-		// Other corners
-		
-		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		detail::tvec4<T> i0;
-		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
-		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
-		//  i0.x = dot(isX, vec3(1.0));
-		//i0.x = isX.x + isX.y + isX.z;
-		//i0.yzw = T(1) - isX;
-		i0 = detail::tvec4<T>(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 - detail::tvec2<T>(isYZ.x, isYZ.y);
-		i0.z += T(1) - isYZ.x;
-		i0.w += T(1) - isYZ.y;
-		i0.z += isYZ.z;
-		i0.w += T(1) - isYZ.z;
-		
-		// i0 now contains the unique values 0,1,2,3 in each channel
-		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
-		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
-		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
-		
-		//  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
-		detail::tvec4<T> x1 = x0 - i1 + C.x;
-		detail::tvec4<T> x2 = x0 - i2 + C.y;
-		detail::tvec4<T> x3 = x0 - i3 + C.z;
-		detail::tvec4<T> x4 = x0 + C.w;
-		
-		// Permutations
-		i = mod(i, T(289)); 
-		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
-		detail::tvec4<T> j1 = permute(permute(permute(permute(
-															  i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
-													  + i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
-											  + i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
-									  + i.x + detail::tvec4<T>(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.
-		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
-		
-		detail::tvec4<T> p0 = grad4(j0,   ip);
-		detail::tvec4<T> p1 = grad4(j1.x, ip);
-		detail::tvec4<T> p2 = grad4(j1.y, ip);
-		detail::tvec4<T> p3 = grad4(j1.z, ip);
-		detail::tvec4<T> p4 = grad4(j1.w, ip);
-		
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(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
-		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
-		m0 = m0 * m0;
-		m1 = m1 * m1;
-		return T(49) * 
-		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-		 dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(glm::detail::tvec2<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(glm::detail::tvec3<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec2<T> noise2(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec2<T>(
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(glm::detail::tvec4<T>(0.0) - x));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(x + glm::detail::tvec2<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(x + glm::detail::tvec3<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec3<T> noise3(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec3<T>(
-			noise1(x - glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(x + glm::detail::tvec4<T>(1.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec2<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(0.0)),
-			noise1(x + glm::detail::tvec2<T>(1.0)),
-			noise1(x + glm::detail::tvec2<T>(2.0)));
-	}
-
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec3<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(0.0)),
-			noise1(x + glm::detail::tvec3<T>(1.0)),
-			noise1(x + glm::detail::tvec3<T>(2.0)));
-	}
-	
-	template <typename T>
-	GLM_FUNC_QUALIFIER glm::detail::tvec4<T> noise4(glm::detail::tvec4<T> const & x)
-	{
-		return glm::detail::tvec4<T>(
-			noise1(x - glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(0.0)),
-			noise1(x + glm::detail::tvec4<T>(1.0)),
-			noise1(x + glm::detail::tvec4<T>(2.0)));
-	}
-	
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_packing.hpp b/thirdparty/glm/glm/core/func_packing.hpp
deleted file mode 100644
index 91582b23..00000000
--- a/thirdparty/glm/glm/core/func_packing.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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>
-/// 
-/// @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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_packing
-#define GLM_CORE_func_packing GLM_VERSION
-
-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>
-	detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> 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>
-	detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> 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>
-	detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> 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>
-	detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> 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>
-	detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & 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>
-	detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & 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>
-    detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & 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>
-	detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & 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>
-	double packDouble2x32(detail::tvec2<detail::uint32> 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>
-	detail::tvec2<detail::uint32> unpackDouble2x32(double const & 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>
-	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>
-	vec2 unpackHalf2x16(uint const & v);
-	
-	/// @}
-}//namespace glm
-
-#include "func_packing.inl"
-
-#endif//GLM_CORE_func_packing
-
diff --git a/thirdparty/glm/glm/core/func_packing.inl b/thirdparty/glm/glm/core/func_packing.inl
deleted file mode 100644
index b025895a..00000000
--- a/thirdparty/glm/glm/core/func_packing.inl
+++ /dev/null
@@ -1,178 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_packing.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
-	{
-		detail::uint16 A(detail::uint16(round(clamp(v.x, 0.0f, 1.0f) * 65535.0f)));
-		detail::uint16 B(detail::uint16(round(clamp(v.y, 0.0f, 1.0f) * 65535.0f)));
-		return detail::uint32((B << 16) | A);
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
-	{
-		detail::uint32 Mask16((1 << 16) - 1);
-		detail::uint32 A((p >>  0) & Mask16);
-		detail::uint32 B((p >> 16) & Mask16);
-		return detail::tvec2<detail::float32>(
-			A * 1.0f / 65535.0f, 
-			B * 1.0f / 65535.0f);
-	}
-	
-	GLM_FUNC_QUALIFIER detail::uint32 packSnorm2x16(detail::tvec2<detail::float32> const & v)
-	{
-		union iu
-		{
-			detail::int16 i;
-			detail::uint16 u;
-		} A, B;
-		
-		detail::tvec2<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 32767.0f;
-		A.i = detail::int16(round(Unpack.x));
-		B.i = detail::int16(round(Unpack.y));
-		detail::uint32 Pack = (detail::uint32(B.u) << 16) | (detail::uint32(A.u) << 0);
-		return Pack;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackSnorm2x16(detail::uint32 const & p)
-	{
-		union iu
-		{
-			detail::int16 i;
-			detail::uint16 u;
-		} A, B;
-		
-		detail::uint32 Mask16((1 << 16) - 1);
-		A.u = detail::uint16((p >>  0) & Mask16);
-		B.u = detail::uint16((p >> 16) & Mask16);
-		detail::tvec2<detail::float32> Pack(A.i, B.i);
-		
-		return clamp(Pack * 1.0f / 32767.0f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
-	{
-		detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
-		detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
-		return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
-	{	
-		detail::uint32 Mask8((1 << 8) - 1);
-		detail::uint32 A((p >>  0) & Mask8);
-		detail::uint32 B((p >>  8) & Mask8);
-		detail::uint32 C((p >> 16) & Mask8);
-		detail::uint32 D((p >> 24) & Mask8);
-		return detail::tvec4<detail::float32>(
-			A * 1.0f / 255.0f, 
-			B * 1.0f / 255.0f, 
-			C * 1.0f / 255.0f, 
-			D * 1.0f / 255.0f);
-	}
-	
-	GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
-	{
-		union iu
-		{
-			detail::int8 i;
-			detail::uint8 u;
-		} A, B, C, D;
-	
-		detail::tvec4<detail::float32> Unpack = clamp(v ,-1.0f, 1.0f) * 127.0f;
-		A.i = detail::int8(round(Unpack.x));
-		B.i = detail::int8(round(Unpack.y));
-		C.i = detail::int8(round(Unpack.z));
-		D.i = detail::int8(round(Unpack.w));
-		detail::uint32 Pack = (detail::uint32(D.u) << 24) | (detail::uint32(C.u) << 16) | (detail::uint32(B.u) << 8) | (detail::uint32(A.u) << 0);
-		return Pack;
-	}
-	
-	GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
-	{	
-		union iu
-		{
-			detail::int8 i;
-			detail::uint8 u;
-		} A, B, C, D;
-	
-		detail::uint32 Mask8((1 << 8) - 1);
-		A.u = detail::uint8((p >>  0) & Mask8);
-		B.u = detail::uint8((p >>  8) & Mask8);
-		C.u = detail::uint8((p >> 16) & Mask8);
-		D.u = detail::uint8((p >> 24) & Mask8);
-		detail::tvec4<detail::float32> Pack(A.i, B.i, C.i, D.i);
-	
-		return clamp(Pack * 1.0f / 127.0f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
-	{
-		return *(double*)&v;
-	}
-
-	GLM_FUNC_QUALIFIER detail::tvec2<uint> unpackDouble2x32(double const & v)
-	{
-		return *(detail::tvec2<uint>*)&v;
-	}
-
-	GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2<float> const & v)
-	{
-        union helper
-        { 
-            uint other; 
-            struct 
-            { 
-                detail::hdata a, b; 
-            } orig; 
-        } Pack; 
-
-        Pack.orig.a = detail::toFloat16(v.x); 
-        Pack.orig.b = detail::toFloat16(v.y); 
-		return *(uint*)&Pack;
-	}
-
-	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
-	{
-        union helper
-        { 
-            uint other; 
-            struct 
-            { 
-                detail::hdata a, b; 
-            } orig; 
-        } Unpack; 
-        Unpack.other = v;
-        
-		return vec2(detail::toFloat32(Unpack.orig.a), detail::toFloat32(Unpack.orig.b));
-	}
-}//namespace glm
-
diff --git a/thirdparty/glm/glm/core/func_trigonometric.hpp b/thirdparty/glm/glm/core/func_trigonometric.hpp
deleted file mode 100644
index ba57cb67..00000000
--- a/thirdparty/glm/glm/core/func_trigonometric.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_trigonometric
-#define GLM_CORE_func_trigonometric GLM_VERSION
-
-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 genType> 
-	genType radians(genType 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 genType> 
-	genType degrees(genType 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 genType> 
-	genType sin(genType 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 genType> 
-	genType cos(genType 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 genType> 
-	genType tan(genType 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 genType> 
-	genType asin(genType 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 genType> 
-	genType acos(genType 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 genType> 
-	genType atan(genType const & y, genType 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 genType> 
-	genType atan(genType 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 genType> 
-	genType sinh(genType 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 genType> 
-	genType cosh(genType 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 genType> 
-	genType tanh(genType 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 genType> 
-	genType asinh(genType 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 genType> 
-	genType acosh(genType 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 genType> 
-	genType atanh(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_trigonometric.inl"
-
-#endif//GLM_CORE_func_trigonometric
-
-
diff --git a/thirdparty/glm/glm/core/func_trigonometric.inl b/thirdparty/glm/glm/core/func_trigonometric.inl
deleted file mode 100644
index 6d87bf3e..00000000
--- a/thirdparty/glm/glm/core/func_trigonometric.inl
+++ /dev/null
@@ -1,246 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_trigonometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_vectorize.hpp"
-
-namespace glm
-{
-	// radians
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType radians
-	(
-		genType const & degrees
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
-
-		genType const pi = genType(3.1415926535897932384626433832795);
-		return degrees * (pi / genType(180));
-	}
-
-	VECTORIZE_VEC(radians)
-	
-	// degrees
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType degrees
-	(
-		genType const & radians
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
-
-		const genType pi = genType(3.1415926535897932384626433832795);
-		return radians * (genType(180) / pi);
-	}
-
-	VECTORIZE_VEC(degrees)
-
-	// sin
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType sin
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
-
-		return ::std::sin(angle);
-	}
-
-	VECTORIZE_VEC(sin)
-
-	// cos
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType cos(genType const & angle)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
-
-		return ::std::cos(angle);
-	}
-
-	VECTORIZE_VEC(cos)
-
-	// tan
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType tan
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
-
-		return ::std::tan(angle);
-	}
-
-	VECTORIZE_VEC(tan)
-
-	// asin
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType asin
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
-
-		return ::std::asin(x);
-	}
-
-	VECTORIZE_VEC(asin)
-
-	// acos
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType acos
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
-
-		return ::std::acos(x);
-	}
-
-	VECTORIZE_VEC(acos)
-
-	// atan
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & y, 
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-		return ::std::atan2(y, x);
-	}
-
-	VECTORIZE_VEC_VEC(atan)
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-		return ::std::atan(x);
-	}
-
-	VECTORIZE_VEC(atan)
-
-	// sinh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType sinh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
-
-		return std::sinh(angle);
-	}
-
-	VECTORIZE_VEC(sinh)
-
-	// cosh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType cosh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
-
-		return std::cosh(angle);
-	}
-
-	VECTORIZE_VEC(cosh)
-
-	// tanh
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType tanh
-	(
-		genType const & angle
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
-
-		return std::tanh(angle);
-	}
-
-	VECTORIZE_VEC(tanh)
-
-	// asinh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType asinh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
-		
-		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
-	}
-
-	VECTORIZE_VEC(asinh)
-
-	// acosh
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType acosh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
-
-		if(x < genType(1))
-			return genType(0);
-		return log(x + sqrt(x * x - genType(1)));
-	}
-
-	VECTORIZE_VEC(acosh)
-
-	// atanh
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atanh
-	(
-		genType const & x
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
-		
-		if(abs(x) >= genType(1))
-			return 0;
-		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
-	}
-
-	VECTORIZE_VEC(atanh)
-
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/func_vector_relational.hpp b/thirdparty/glm/glm/core/func_vector_relational.hpp
deleted file mode 100644
index 8afba380..00000000
--- a/thirdparty/glm/glm/core/func_vector_relational.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_CORE_func_vector_relational
-#define GLM_CORE_func_vector_relational GLM_VERSION
-
-#include "_detail.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 vecType> 
-	typename vecType::bool_type lessThan(vecType const & x, vecType 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 vecType> 
-	typename vecType::bool_type lessThanEqual(vecType const & x, vecType 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 vecType> 
-	typename vecType::bool_type greaterThan(vecType const & x, vecType 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 vecType> 
-	typename vecType::bool_type greaterThanEqual(vecType const & x, vecType 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 vecType> 
-	typename vecType::bool_type equal(vecType const & x, vecType 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 vecType> 
-	typename vecType::bool_type notEqual(vecType const & x, vecType 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 <template <typename> class vecType> 
-	bool any(vecType<bool> 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 <template <typename> class vecType> 
-	bool all(vecType<bool> 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 <template <typename> class vecType> 
-	vecType<bool> not_(vecType<bool> const & v);
-
-	/// @}
-}//namespace glm
-
-#include "func_vector_relational.inl"
-
-#endif//GLM_CORE_func_vector_relational
diff --git a/thirdparty/glm/glm/core/func_vector_relational.inl b/thirdparty/glm/glm/core/func_vector_relational.inl
deleted file mode 100644
index 0ef817af..00000000
--- a/thirdparty/glm/glm/core/func_vector_relational.inl
+++ /dev/null
@@ -1,178 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/func_vector_relational.inl
-/// @date 2008-08-03 / 2011-09-09
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-    template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'lessThan', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
-			"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] < y[i];
-
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'lessThanEqual', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] <= y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'greaterThan', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] > y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required");
-		GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
-			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] >= y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'equal', GLM vector types required");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] == y[i];
-		return Result;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
-	(
-		vecType<T> const & x, 
-		vecType<T> const & y
-	)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
-			"Invalid template instantiation of 'notEqual', GLM vector types required");
-		assert(x.length() == y.length());
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < x.length(); ++i)
-			Result[i] = x[i] != y[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'any', GLM boolean vector types required");
-
-		bool Result = false;
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result = Result || v[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'all', GLM boolean vector types required");
-
-		bool Result = true;
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result = Result && v[i];
-		return Result;
-	}
-
-	template <template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v)
-	{
-		GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
-			"Invalid template instantiation of 'not_', GLM vector types required");
-
-		typename vecType<bool>::bool_type Result(vecType<bool>::null);
-		for(typename vecType<bool>::size_type i = 0; i < v.length(); ++i)
-			Result[i] = !v[i];
-		return Result;
-	}
-}//namespace glm
-
diff --git a/thirdparty/glm/glm/core/hint.hpp b/thirdparty/glm/glm/core/hint.hpp
deleted file mode 100644
index 8776c776..00000000
--- a/thirdparty/glm/glm/core/hint.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/hint.hpp
-/// @date 2008-08-14 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type
-#define glm_core_type
-
-namespace glm
-{
-	// Use dont_care, nicest and fastest to optimize implementations.
-	class dont_care {};
-	class nicest {};
-	class fastest {};
-}//namespace glm
-
-#endif//glm_core_type
diff --git a/thirdparty/glm/glm/core/intrinsic_common.hpp b/thirdparty/glm/glm/core/intrinsic_common.hpp
deleted file mode 100644
index c0e94015..00000000
--- a/thirdparty/glm/glm/core/intrinsic_common.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_common.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_common
-#define glm_detail_intrinsic_common
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_detail_intrinsic_common
diff --git a/thirdparty/glm/glm/core/intrinsic_common.inl b/thirdparty/glm/glm/core/intrinsic_common.inl
deleted file mode 100644
index 5890fc64..00000000
--- a/thirdparty/glm/glm/core/intrinsic_common.inl
+++ /dev/null
@@ -1,313 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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(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 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);
-}
-
-}//namespace detail
-}//namespace glms
diff --git a/thirdparty/glm/glm/core/intrinsic_exponential.hpp b/thirdparty/glm/glm/core/intrinsic_exponential.hpp
deleted file mode 100644
index 35341b96..00000000
--- a/thirdparty/glm/glm/core/intrinsic_exponential.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_exponential.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_exponential
-#define glm_detail_intrinsic_exponential
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_detail_intrinsic_exponential
diff --git a/thirdparty/glm/glm/core/intrinsic_exponential.inl b/thirdparty/glm/glm/core/intrinsic_exponential.inl
deleted file mode 100644
index 7f5623b4..00000000
--- a/thirdparty/glm/glm/core/intrinsic_exponential.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_exponential.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/thirdparty/glm/glm/core/intrinsic_geometric.hpp b/thirdparty/glm/glm/core/intrinsic_geometric.hpp
deleted file mode 100644
index 8dfda238..00000000
--- a/thirdparty/glm/glm/core/intrinsic_geometric.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_geometric.hpp
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_intrinsic_geometric
-#define glm_core_intrinsic_geometric
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_core_intrinsic_geometric
diff --git a/thirdparty/glm/glm/core/intrinsic_geometric.inl b/thirdparty/glm/glm/core/intrinsic_geometric.inl
deleted file mode 100644
index f28d584e..00000000
--- a/thirdparty/glm/glm/core/intrinsic_geometric.inl
+++ /dev/null
@@ -1,146 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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_SSE4) == GLM_ARCH_SSE4)
-        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
diff --git a/thirdparty/glm/glm/core/intrinsic_matrix.hpp b/thirdparty/glm/glm/core/intrinsic_matrix.hpp
deleted file mode 100644
index 49674179..00000000
--- a/thirdparty/glm/glm/core/intrinsic_matrix.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_common.hpp
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_matrix
-#define glm_detail_intrinsic_matrix
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_detail_intrinsic_matrix
diff --git a/thirdparty/glm/glm/core/intrinsic_matrix.inl b/thirdparty/glm/glm/core/intrinsic_matrix.inl
deleted file mode 100644
index 6f0fdb7f..00000000
--- a/thirdparty/glm/glm/core/intrinsic_matrix.inl
+++ /dev/null
@@ -1,1070 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_common.inl
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-static const __m128 GLM_VAR_USED _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
-static const __m128 GLM_VAR_USED _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
-
-template <typename matType>
-GLM_FUNC_QUALIFIER matType sse_comp_mul_ps
-(
-	__m128 const in1[4],
-	__m128 const in2[4],
-	__m128 out[4]
-)
-{
-	out[0] = _mm_mul_ps(in1[0], in2[0]);
-	out[1] = _mm_mul_ps(in1[1], in2[1]);
-	out[2] = _mm_mul_ps(in1[2], in2[2]);
-	out[3] = _mm_mul_ps(in1[3], in2[3]);
-}
-
-GLM_FUNC_QUALIFIER void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_add_ps(in1[0], in2[0]);
-		out[1] = _mm_add_ps(in1[1], in2[1]);
-		out[2] = _mm_add_ps(in1[2], in2[2]);
-		out[3] = _mm_add_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
-{
-	{
-		out[0] = _mm_sub_ps(in1[0], in2[0]);
-		out[1] = _mm_sub_ps(in1[1], in2[1]);
-		out[2] = _mm_sub_ps(in1[2], in2[2]);
-		out[3] = _mm_sub_ps(in1[3], in2[3]);
-	}
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 m[4], __m128 v)
-{
-	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
-
-	__m128 m0 = _mm_mul_ps(m[0], v0);
-	__m128 m1 = _mm_mul_ps(m[1], v1);
-	__m128 m2 = _mm_mul_ps(m[2], v2);
-	__m128 m3 = _mm_mul_ps(m[3], v3);
-
-	__m128 a0 = _mm_add_ps(m0, m1);
-	__m128 a1 = _mm_add_ps(m2, m3);
-	__m128 a2 = _mm_add_ps(a0, a1);
-
-	return a2;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 v, __m128 m[4])
-{
-	__m128 i0 = m[0];
-	__m128 i1 = m[1];
-	__m128 i2 = m[2];
-	__m128 i3 = m[3];
-
-	__m128 m0 = _mm_mul_ps(v, i0);
-	__m128 m1 = _mm_mul_ps(v, i1);
-	__m128 m2 = _mm_mul_ps(v, i2);
-	__m128 m3 = _mm_mul_ps(v, i3);
-
-	__m128 u0 = _mm_unpacklo_ps(m0, m1);
-	__m128 u1 = _mm_unpackhi_ps(m0, m1);
-	__m128 a0 = _mm_add_ps(u0, u1);
-
-	__m128 u2 = _mm_unpacklo_ps(m2, m3);
-	__m128 u3 = _mm_unpackhi_ps(m2, m3);
-	__m128 a1 = _mm_add_ps(u2, u3);
-
-	__m128 f0 = _mm_movelh_ps(a0, a1);
-	__m128 f1 = _mm_movehl_ps(a1, a0);
-	__m128 f2 = _mm_add_ps(f0, f1);
-
-	return f2;
-}
-
-GLM_FUNC_QUALIFIER void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
-{
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[0] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[1] = a2;
-	}
-
-	{
-		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[2] = a2;
-	}
-
-	{
-		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
-		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 m0 = _mm_mul_ps(in1[0], e0);
-		__m128 m1 = _mm_mul_ps(in1[1], e1);
-		__m128 m2 = _mm_mul_ps(in1[2], e2);
-		__m128 m3 = _mm_mul_ps(in1[3], e3);
-
-		__m128 a0 = _mm_add_ps(m0, m1);
-		__m128 a1 = _mm_add_ps(m2, m3);
-		__m128 a2 = _mm_add_ps(a0, a1);
-
-		out[3] = a2;
-	}
-}
-
-GLM_FUNC_QUALIFIER void sse_transpose_ps(__m128 const in[4], __m128 out[4])
-{
-    __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
-    __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
-    __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
-    __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
-
-    out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
-    out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
-    out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
-    out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_slow_det_ps(__m128 const in[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0]
-	//						+ m[0][1] * Inverse[1][0]
-	//						+ m[0][2] * Inverse[2][0]
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	return Det0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_detd_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
-
-	//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];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
- 	__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
-	__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
-	__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//detail::tvec4<T> 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));
-
-	__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
-	__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
-	__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_det_ps
-(
-	__m128 const m[4]
-)
-{
-	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
-
-	//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];
-
-	// First 2 columns
- 	__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
- 	__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
-
-	// Second 2 columns
-	__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
-	__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
-	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
-
-	// Columns subtraction
-	__m128 SubE = _mm_sub_ps(MulA, MulB);
-
-	// Last 2 rows
-	__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
-	__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
-	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
-	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
-
-	//detail::tvec4<T> 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));
-
-	__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
-	__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
-	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
-
-	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
-	__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
-	__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
-	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
-
-	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
-
-	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
-	__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
-	__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
-	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
-
-	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
-	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
-
-	//return m[0][0] * DetCof[0]
-	//	 + m[0][1] * DetCof[1]
-	//	 + m[0][2] * DetCof[2]
-	//	 + m[0][3] * DetCof[3];
-
-	return sse_dot_ps(m[0], DetCof);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-    }
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//__m128 Rcp0 = _mm_rcp_ps(Det0);
-
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-
-GLM_FUNC_QUALIFIER void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
-{
-	__m128 Fac0;
-	{
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac0 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac1;
-	{
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac1 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-
-	__m128 Fac2;
-	{
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac2 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac3;
-	{
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac3 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac4;
-	{
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac4 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 Fac5;
-	{
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
-		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
-
-		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
-		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
-		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
-
-		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
-		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
-		Fac5 = _mm_sub_ps(Mul00, Mul01);
-	}
-
-	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
-	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
-
-	// m[1][0]
-	// m[0][0]
-	// m[0][0]
-	// m[0][0]
-	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][1]
-	// m[0][1]
-	// m[0][1]
-	// m[0][1]
-	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][2]
-	// m[0][2]
-	// m[0][2]
-	// m[0][2]
-	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// m[1][3]
-	// m[0][3]
-	// m[0][3]
-	// m[0][3]
-	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
-	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
-
-	// col0
-	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
-	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
-	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
-	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
-	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
-	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
-	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
-	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
-	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
-	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
-
-	// col1
-	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
-	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
-	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
-	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
-	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
-	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
-	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
-	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
-	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
-	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
-
-	// col2
-	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
-	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
-	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
-	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
-	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
-	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
-	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
-	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
-	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
-	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
-
-	// col3
-	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
-	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
-	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
-	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
-	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
-	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
-	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
-	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
-	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
-	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
-
-	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
-
-	//	valType Determinant = m[0][0] * Inverse[0][0] 
-	//						+ m[0][1] * Inverse[1][0] 
-	//						+ m[0][2] * Inverse[2][0] 
-	//						+ m[0][3] * Inverse[3][0];
-	__m128 Det0 = sse_dot_ps(in[0], Row2);
-	__m128 Rcp0 = _mm_rcp_ps(Det0);
-	//__m128 Rcp0 = _mm_div_ps(one, Det0);
-	//	Inverse /= Determinant;
-	out[0] = _mm_mul_ps(Inv0, Rcp0);
-	out[1] = _mm_mul_ps(Inv1, Rcp0);
-	out[2] = _mm_mul_ps(Inv2, Rcp0);
-	out[3] = _mm_mul_ps(Inv3, Rcp0);
-}
-/*
-GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
-{
-	float a = glm::radians(Angle);
-    float c = cos(a);
-    float s = sin(a);
-
-	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
-	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
-    __m128 AxisC = detail::sse_nrm_ps(AxisB);
-
-	__m128 Cos0 = _mm_set_ss(c);
-	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 Sin0 = _mm_set_ss(s);
-	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
-
-	// detail::tvec3<valType> temp = (valType(1) - c) * axis;
-	__m128 Temp0 = _mm_sub_ps(one, CosA);
-	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
-	
-	//Rotate[0][0] = c + temp[0] * axis[0];
-	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
-	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
-	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
-	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
-	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
-	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
-	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
-	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
-
-	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
-	//Rotate[1][1] = c + temp[1] * axis[1];
-	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
-	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
-	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
-	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
-	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
-	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
-	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
-	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
-	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
-
-    //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-    //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-    //Rotate[2][2] = c + temp[2] * axis[2];
-	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
-	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
-	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
-	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
-	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
-	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
-	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
-	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
-
-	__m128 Result[4];
-	Result[0] = TmpA4;
-	Result[1] = TmpB4;
-	Result[2] = TmpC4;
-	Result[3] = _mm_set_ps(1, 0, 0, 0);
-
-	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::null);
-	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-	//Result[3] = m[3];
-	//return Result;
-	sse_mul_ps(in, Result, out);
-}
-*/
-GLM_FUNC_QUALIFIER void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
-{
-	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
-	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
-	out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
-	out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
-}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/intrinsic_trigonometric.hpp b/thirdparty/glm/glm/core/intrinsic_trigonometric.hpp
deleted file mode 100644
index 6594b90f..00000000
--- a/thirdparty/glm/glm/core/intrinsic_trigonometric.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_trigonometric.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_trigonometric
-#define glm_detail_intrinsic_trigonometric
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_detail_intrinsic_trigonometric
diff --git a/thirdparty/glm/glm/core/intrinsic_trigonometric.inl b/thirdparty/glm/glm/core/intrinsic_trigonometric.inl
deleted file mode 100644
index 39d10e67..00000000
--- a/thirdparty/glm/glm/core/intrinsic_trigonometric.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_trigonometric.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/thirdparty/glm/glm/core/intrinsic_vector_relational.hpp b/thirdparty/glm/glm/core/intrinsic_vector_relational.hpp
deleted file mode 100644
index 8ca06a8f..00000000
--- a/thirdparty/glm/glm/core/intrinsic_vector_relational.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_vector_relational.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_detail_intrinsic_vector_relational
-#define glm_detail_intrinsic_vector_relational
-
-#include "setup.hpp"
-
-#if((GLM_ARCH & GLM_ARCH_SSE2) != 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
-#endif//glm_detail_intrinsic_vector_relational
diff --git a/thirdparty/glm/glm/core/intrinsic_vector_relational.inl b/thirdparty/glm/glm/core/intrinsic_vector_relational.inl
deleted file mode 100644
index 0e8f97cd..00000000
--- a/thirdparty/glm/glm/core/intrinsic_vector_relational.inl
+++ /dev/null
@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/intrinsic_vector_relational.inl
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-//
-//// lessThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThan
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThan
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThan
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::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 detail::tvec2<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThanEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::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 detail::tvec2<valType>::bool_type greaterThan
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThan
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThan
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename detail::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 detail::tvec2<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThanEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename detail::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 detail::tvec2<valType>::bool_type equal
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> 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 detail::tvec2<valType>::bool_type(x.x == y.x, x.y == y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type equal
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> 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 detail::tvec3<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type equal
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> 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 detail::tvec4<valType>::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 detail::tvec2<valType>::bool_type notEqual
-//(
-//	detail::tvec2<valType> const & x, 
-//	detail::tvec2<valType> 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 detail::tvec2<valType>::bool_type(x.x != y.x, x.y != y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type notEqual
-//(
-//	detail::tvec3<valType> const & x, 
-//	detail::tvec3<valType> 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 detail::tvec3<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type notEqual
-//(
-//	detail::tvec4<valType> const & x, 
-//	detail::tvec4<valType> 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 detail::tvec4<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
-//}
-//
-//// any
-//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
-//{
-//	return x.x || x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
-//{
-//    return x.x || x.y || x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
-//{
-//    return x.x || x.y || x.z || x.w;
-//}
-//
-//// all
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
-//{
-//    return x.x && x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
-//{
-//    return x.x && x.y && x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
-//{
-//    return x.x && x.y && x.z && x.w;
-//}
-//
-//// not
-//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
-//(
-//	detail::tvec2<bool> const & v
-//)
-//{
-//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
-//}
-//
-//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
-//(
-//	detail::tvec3<bool> const & v
-//)
-//{
-//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
-//}
-//
-//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
-//(
-//	detail::tvec4<bool> const & v
-//)
-//{
-//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
-//}
\ No newline at end of file
diff --git a/thirdparty/glm/glm/core/setup.hpp b/thirdparty/glm/glm/core/setup.hpp
deleted file mode 100644
index 94c82c6a..00000000
--- a/thirdparty/glm/glm/core/setup.hpp
+++ /dev/null
@@ -1,677 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/setup.hpp
-/// @date 2006-11-13 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_setup
-#define glm_setup
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Version
-
-#define GLM_VERSION					93
-#define GLM_VERSION_MAJOR			0
-#define GLM_VERSION_MINOR			9
-#define GLM_VERSION_PATCH			3
-#define GLM_VERSION_REVISION		4
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// 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
-
-#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(_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_WINDOWS)
-#		pragma message("GLM: Windows 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_LINUX)
-#		pragma message("GLM: Linux platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_UNIX)
-#		pragma message("GLM: UNIX platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
-#		pragma message("GLM: Android platform detected")
-#	elif(GLM_PLATFORM & GLM_PLATFORM_CHROME_NACL)
-#		pragma message("GLM: Chrone Native Client 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
-
-// Visual C++ defines
-#define GLM_COMPILER_VC				0x01000000
-#define GLM_COMPILER_VC2			0x01000010
-#define GLM_COMPILER_VC4			0x01000020
-#define GLM_COMPILER_VC5			0x01000030
-#define GLM_COMPILER_VC6			0x01000040
-#define GLM_COMPILER_VC2002			0x01000050
-#define GLM_COMPILER_VC2003			0x01000060
-#define GLM_COMPILER_VC2005			0x01000070
-#define GLM_COMPILER_VC2008			0x01000080
-#define GLM_COMPILER_VC2010			0x01000090
-#define GLM_COMPILER_VC2011			0x010000A0
-
-// GCC defines
-#define GLM_COMPILER_GCC            0x02000000
-#define GLM_COMPILER_GCC_LLVM       0x02000001
-#define GLM_COMPILER_GCC_CLANG      0x02000002
-#define GLM_COMPILER_GCC30			0x02000010
-#define GLM_COMPILER_GCC31			0x02000020
-#define GLM_COMPILER_GCC32			0x02000030
-#define GLM_COMPILER_GCC33			0x02000040
-#define GLM_COMPILER_GCC34			0x02000050
-#define GLM_COMPILER_GCC35			0x02000060
-#define GLM_COMPILER_GCC40			0x02000070
-#define GLM_COMPILER_GCC41			0x02000080
-#define GLM_COMPILER_GCC42			0x02000090
-#define GLM_COMPILER_GCC43			0x020000A0
-#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
-
-// G++ command line to display defined
-// echo "" | g++ -E -dM -x c++ - | sort
-
-// Borland C++ defines. How to identify BC?
-#define GLM_COMPILER_BC				0x04000000
-#define GLM_COMPILER_BCB4			0x04000100
-#define GLM_COMPILER_BCB5			0x04000200
-#define GLM_COMPILER_BCB6			0x04000300
-//#define GLM_COMPILER_BCBX			0x04000400 // What's the version value?
-#define GLM_COMPILER_BCB2009		0x04000500
-
-// CodeWarrior
-#define GLM_COMPILER_CODEWARRIOR	0x08000000
-
-// CUDA
-#define GLM_COMPILER_CUDA           0x10000000
-#define GLM_COMPILER_CUDA30			0x10000010
-#define GLM_COMPILER_CUDA31			0x10000020
-#define GLM_COMPILER_CUDA32			0x10000030
-#define GLM_COMPILER_CUDA40			0x10000040
-#define GLM_COMPILER_CUDA41			0x10000050
-#define GLM_COMPILER_CUDA42			0x10000060
-
-// Clang
-#define GLM_COMPILER_CLANG          0x20000000
-#define GLM_COMPILER_CLANG26		0x20000010
-#define GLM_COMPILER_CLANG27		0x20000020
-#define GLM_COMPILER_CLANG28		0x20000030
-#define GLM_COMPILER_CLANG29		0x20000040
-#define GLM_COMPILER_CLANG30		0x20000050
-#define GLM_COMPILER_CLANG31		0x20000060
-#define GLM_COMPILER_CLANG32		0x20000070
-#define GLM_COMPILER_CLANG33		0x20000080
-
-// LLVM GCC
-#define GLM_COMPILER_LLVM_GCC		0x40000000
-
-// Intel
-#define GLM_COMPILER_INTEL          0x80000000
-#define GLM_COMPILER_INTEL9			0x80000010
-#define GLM_COMPILER_INTEL10_0		0x80000020
-#define GLM_COMPILER_INTEL10_1		0x80000030
-#define GLM_COMPILER_INTEL11_0		0x80000040
-#define GLM_COMPILER_INTEL11_1		0x80000050
-#define GLM_COMPILER_INTEL12_0		0x80000060
-#define GLM_COMPILER_INTEL12_1		0x80000070
-#define GLM_COMPILER_INTEL13_0		0x80000080
-
-// 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 == 900
-#		define GLM_COMPILER GLM_COMPILER_INTEL9
-#	elif __INTEL_COMPILER == 1000
-#		define GLM_COMPILER GLM_COMPILER_INTEL10_0
-#	elif __INTEL_COMPILER == 1010
-#		define GLM_COMPILER GLM_COMPILER_INTEL10_1
-#	elif __INTEL_COMPILER == 1100
-#		define GLM_COMPILER GLM_COMPILER_INTEL11_0
-#	elif __INTEL_COMPILER == 1110
-#		define GLM_COMPILER GLM_COMPILER_INTEL11_1
-#	elif __INTEL_COMPILER == 1200
-#		define GLM_COMPILER GLM_COMPILER_INTEL12_0
-#	elif __INTEL_COMPILER == 1210
-#		define GLM_COMPILER GLM_COMPILER_INTEL12_1
-#	elif __INTEL_COMPILER == 1300
-#		define GLM_COMPILER GLM_COMPILER_INTEL13_0
-#	else
-#		define GLM_COMPILER GLM_COMPILER_INTEL
-#	endif
-
-// CUDA
-#elif defined(__CUDACC__)
-#	define GLM_COMPILER GLM_COMPILER_CUDA
-/*
-#	if CUDA_VERSION < 3000
-#		error "GLM requires CUDA 3.0 or higher"
-#	elif CUDA_VERSION == 3000
-#		define GLM_COMPILER GLM_COMPILER_CUDA30	
-#	elif CUDA_VERSION == 3010
-#		define GLM_COMPILER GLM_COMPILER_CUDA31	
-#	elif CUDA_VERSION == 3020
-#		define GLM_COMPILER GLM_COMPILER_CUDA32	
-#	elif CUDA_VERSION == 4000
-#		define GLM_COMPILER GLM_COMPILER_CUDA40	
-#	elif CUDA_VERSION == 4010
-#		define GLM_COMPILER GLM_COMPILER_CUDA41	
-#	elif CUDA_VERSION == 4020
-#		define GLM_COMPILER GLM_COMPILER_CUDA42
-#	else
-#		define GLM_COMPILER GLM_COMPILER_CUDA
-#	endif
-*/
-
-// Visual C++
-#elif defined(_MSC_VER)
-#	if _MSC_VER == 900
-#		define GLM_COMPILER GLM_COMPILER_VC2
-#	elif _MSC_VER == 1000
-#		define GLM_COMPILER GLM_COMPILER_VC4
-#	elif _MSC_VER == 1100
-#		define GLM_COMPILER GLM_COMPILER_VC5
-#	elif _MSC_VER == 1200
-#		define GLM_COMPILER GLM_COMPILER_VC6
-#	elif _MSC_VER == 1300
-#		define GLM_COMPILER GLM_COMPILER_VC2002
-#	elif _MSC_VER == 1310
-#		define GLM_COMPILER GLM_COMPILER_VC2003
-#	elif _MSC_VER == 1400
-#		define GLM_COMPILER GLM_COMPILER_VC2005
-#	elif _MSC_VER == 1500
-#		define GLM_COMPILER GLM_COMPILER_VC2008
-#	elif _MSC_VER == 1600
-#		define GLM_COMPILER GLM_COMPILER_VC2010
-#	elif _MSC_VER == 1700
-#		define GLM_COMPILER GLM_COMPILER_VC2011
-#	else//_MSC_VER
-#		define GLM_COMPILER GLM_COMPILER_VC
-#	endif//_MSC_VER
-
-// Clang
-#elif defined(__clang__)
-#	if(__clang_major__ == 2) && (__clang_minor__ == 6)
-#		define GLM_COMPILER GLM_COMPILER_CLANG26
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 7)
-#		define GLM_COMPILER GLM_COMPILER_CLANG27
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 8)
-#		define GLM_COMPILER GLM_COMPILER_CLANG28
-#	elif(__clang_major__ == 2) && (__clang_minor__ == 9)
-#		define GLM_COMPILER GLM_COMPILER_CLANG29
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 0)
-#		define GLM_COMPILER GLM_COMPILER_CLANG30
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 1)
-#		define GLM_COMPILER GLM_COMPILER_CLANG31
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 2)
-#		define GLM_COMPILER GLM_COMPILER_CLANG32
-#	elif(__clang_major__ == 3) && (__clang_minor__ == 3)
-#		define GLM_COMPILER GLM_COMPILER_CLANG33
-#	else
-#		define GLM_COMPILER GLM_COMPILER_CLANG
-#   endif
-
-// G++ 
-#elif(defined(__GNUC__) || defined(__MINGW32__))// || defined(__llvm__) || defined(__clang__)
-#   if defined (__llvm__)
-#       define GLM_COMPILER_GCC_EXTRA GLM_COMPILER_GCC_LLVM
-#   elif defined (__clang__)
-#       define GLM_COMPILER_GCC_EXTRA GLM_COMPILER_GCC_CLANG
-#   else
-#       define GLM_COMPILER_GCC_EXTRA 0
-#   endif
-#
-#	if   (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
-#		define GLM_COMPILER GLM_COMPILER_GCC32
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 3)
-#		define GLM_COMPILER GLM_COMPILER_GCC33
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
-#		define GLM_COMPILER GLM_COMPILER_GCC34
-#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 5)
-#		define GLM_COMPILER GLM_COMPILER_GCC35
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 0)
-#		define GLM_COMPILER (GLM_COMPILER_GCC40 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 1)
-#		define GLM_COMPILER (GLM_COMPILER_GCC41 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
-#		define GLM_COMPILER (GLM_COMPILER_GCC42 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
-#		define GLM_COMPILER (GLM_COMPILER_GCC43 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
-#		define GLM_COMPILER (GLM_COMPILER_GCC44 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
-#		define GLM_COMPILER (GLM_COMPILER_GCC45 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
-#		define GLM_COMPILER (GLM_COMPILER_GCC46 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
-#		define GLM_COMPILER (GLM_COMPILER_GCC47 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
-#		define GLM_COMPILER (GLM_COMPILER_GCC48 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 9)
-#		define GLM_COMPILER (GLM_COMPILER_GCC49 | GLM_COMPILER_GCC_EXTRA)
-#	elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 0)
-#		define GLM_COMPILER (GLM_COMPILER_GCC50 | GLM_COMPILER_GCC_EXTRA)
-#	else
-#		define GLM_COMPILER (GLM_COMPILER_GCC | GLM_COMPILER_GCC_EXTRA)
-#	endif
-
-// Borland C++
-#elif defined(_BORLANDC_)
-#	if defined(VER125)
-#		define GLM_COMPILER GLM_COMPILER_BCB4
-#	elif defined(VER130)
-#		define GLM_COMPILER GLM_COMPILER_BCB5
-#	elif defined(VER140)
-#		define GLM_COMPILER GLM_COMPILER_BCB6
-#	elif defined(VER200)
-#		define GLM_COMPILER GLM_COMPILER_BCB2009
-#	else
-#		define GLM_COMPILER GLM_COMPILER_BC
-#	endif
-
-// Codewarrior
-#elif defined(__MWERKS__)
-#	define GLM_COMPILER GLM_COMPILER_CODEWARRIOR
-
-#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_CLANG)
-#		pragma message("GLM: Clang compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
-#		pragma message("GLM: LLVM GCC compiler detected")
-#	elif(GLM_COMPILER & GLM_COMPILER_GCC)
-#       if(GLM_COMPILER == GLM_COMPILER_GCC_LLVM)
-#           pragma message("GLM: LLVM GCC compiler detected")
-#       elif(GLM_COMPILER == GLM_COMPILER_GCC_CLANG)
-#           pragma message("GLM: CLANG compiler detected")
-#       else
-#           pragma message("GLM: GCC compiler detected")
-#       endif
-#	elif(GLM_COMPILER & GLM_COMPILER_BC)
-#		pragma message("GLM: Borland compiler detected but not supported")
-#	elif(GLM_COMPILER & GLM_COMPILER_CODEWARRIOR)
-#		pragma message("GLM: Codewarrior compiler detected but not supported")
-#	else
-#		pragma message("GLM: Compiler not detected")
-#	endif
-#endif//GLM_MESSAGE
-
-/////////////////
-// Build model //
-
-#if((defined(__WORDSIZE) && (__WORDSIZE == 64)) || 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
-
-#define GLM_LANG_CXX			(0 << 0)
-#define GLM_LANG_CXX98			((1 << 1) | GLM_LANG_CXX)
-#define GLM_LANG_CXX03			((1 << 2) | GLM_LANG_CXX98)
-#define GLM_LANG_CXX0X			((1 << 3) | GLM_LANG_CXX03)
-#define GLM_LANG_CXX11			((1 << 4) | GLM_LANG_CXX0X)
-#define GLM_LANG_CXXMS			(1 << 5)
-#define GLM_LANG_CXXGNU			(1 << 6)
-
-#if(defined(GLM_FORCE_CXX11))
-#	define GLM_LANG GLM_LANG_CXX11
-#elif(defined(GLM_FORCE_CXX03))
-#	define GLM_LANG GLM_LANG_CXX03
-#elif(defined(GLM_FORCE_CXX98))
-#	define GLM_LANG GLM_LANG_CXX98
-#else
-//  -std=c++0x or -std=gnu++0x
-#	if(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__GXX_EXPERIMENTAL_CXX0X__)) 
-#		define GLM_LANG GLM_LANG_CXX0X
-#	elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS))
-#		define GLM_LANG GLM_LANG_CXXMS
-#	elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS))
-#		if(GLM_COMPILER >= GLM_COMPILER_VC2010)
-#			define GLM_LANG GLM_LANG_CXX0X
-#		else
-#			define GLM_LANG GLM_LANG_CXX98
-#		endif//(GLM_COMPILER == GLM_COMPILER_VC2010)
-#	elif((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) //&& defined(__STRICT_ANSI__))
-#		define GLM_LANG GLM_LANG_CXX98
-#	elif((GLM_COMPILER & GLM_COMPILER_CLANG) == GLM_COMPILER_CLANG) 
-#		define GLM_LANG GLM_LANG_CXX98
-#	else
-#		define GLM_LANG GLM_LANG_CXX
-#	endif
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED))
-#	define GLM_MESSAGE_LANG_DISPLAYED
-#	if(GLM_LANG == GLM_LANG_CXX98)
-#		pragma message("GLM: C++98")
-#	elif(GLM_LANG == GLM_LANG_CXX03)
-#		pragma message("GLM: C++03")
-#	elif(GLM_LANG == GLM_LANG_CXX0X)
-#		pragma message("GLM: C++0x")
-#	elif(GLM_LANG == GLM_LANG_CXX11)
-#		pragma message("GLM: C++11")
-#	elif(GLM_LANG == GLM_LANG_CXXGNU)
-#		pragma message("GLM: C++ with GNU language extensions")
-#	elif(GLM_LANG == GLM_LANG_CXXMS)
-#		pragma message("GLM: C++ with VC language extensions")
-#   else
-#       pragma message("GLM: C++ language undetected")
-#	endif//GLM_MODEL
-#endif//GLM_MESSAGE
-
-/////////////////
-// Platform 
-
-// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_AVX
-
-#define GLM_ARCH_PURE		0x0000
-#define GLM_ARCH_SSE2		0x0001
-#define GLM_ARCH_SSE3		0x0002// | GLM_ARCH_SSE2
-#define GLM_ARCH_SSE4		0x0004// | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-#define GLM_ARCH_AVX		0x0008// | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-#define GLM_ARCH_AVX2		0x0010// | GLM_ARCH_AVX | GLM_ARCH_SSE4 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2
-
-#if(defined(GLM_FORCE_PURE))
-#	define GLM_ARCH GLM_ARCH_PURE
-#elif(defined(GLM_FORCE_AVX2))
-#	define GLM_ARCH GLM_ARCH_AVX2
-#elif(defined(GLM_FORCE_AVX))
-#	define GLM_ARCH GLM_ARCH_AVX
-#elif(defined(GLM_FORCE_SSE4))
-#	define GLM_ARCH GLM_ARCH_SSE4
-#elif(defined(GLM_FORCE_SSE3))
-#	define GLM_ARCH GLM_ARCH_SSE3
-#elif(defined(GLM_FORCE_SSE2))
-#	define GLM_ARCH GLM_ARCH_SSE2
-#elif((GLM_COMPILER & GLM_COMPILER_VC) && (defined(_M_IX86) || defined(_M_X64)))
-#	if(defined(_M_CEE_PURE))
-#		define GLM_ARCH GLM_ARCH_PURE
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2010)
-#		if(_MSC_FULL_VER >= 160031118) //160031118: VC2010 SP1 beta full version
-#			define GLM_ARCH GLM_ARCH_AVX //GLM_ARCH_AVX (Require SP1)
-#		else
-#			define GLM_ARCH GLM_ARCH_SSE3
-#		endif
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2008) 
-#		define GLM_ARCH GLM_ARCH_SSE3
-#	elif(GLM_COMPILER >= GLM_COMPILER_VC2005)
-#		define GLM_ARCH GLM_ARCH_SSE2
-#	else
-#		define GLM_ARCH GLM_ARCH_PURE
-#	endif
-#elif((GLM_PLATFORM & GLM_PLATFORM_APPLE) && (GLM_COMPILER & GLM_COMPILER_GCC))
-#	define GLM_ARCH GLM_ARCH_PURE
-#elif(((GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__))) || (GLM_COMPILER & GLM_COMPILER_LLVM_GCC))
-#	if(defined(__AVX2__))
-#		define GLM_ARCH GLM_ARCH_AVX2
-#	elif(defined(__AVX__))
-#		define GLM_ARCH GLM_ARCH_AVX
-#	elif(defined(__SSE4__))
-#		define GLM_ARCH GLM_ARCH_SSE4
-#	elif(defined(__SSE3__))
-#		define GLM_ARCH GLM_ARCH_SSE3
-#	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
-
-//#if(GLM_ARCH != GLM_ARCH_PURE)
-#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>
-#endif//GLM_ARCH
-//#endif//(GLM_ARCH != GLM_ARCH_PURE)
-
-#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")
-#	elif(GLM_ARCH == GLM_ARCH_SSE2)
-#		pragma message("GLM: SSE2 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE3)
-#		pragma message("GLM: SSE3 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE4)
-#		pragma message("GLM: SSE4 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_AVX)
-#		pragma message("GLM: AVX instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_AVX2)
-#		pragma message("GLM: AVX2 instruction set")
-#	endif//GLM_ARCH
-#endif//GLM_MESSAGE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Support check macros
-
-#define GLM_SUPPORT_ANONYMOUS_UNION() \
-	((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98)
-
-/*
-#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
-	(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))
-*/
-
-#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
-	(((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_COMPILER & GLM_COMPILER_VC) && ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS)) || ((GLM_LANG == GLM_LANG_CXX0X) == GLM_LANG_CXX0X))
-
-#define GLM_SUPPORT_SWIZZLE_OPERATOR() \
-	(/*defined(GLM_SWIZZLE) && */GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE())
-
-#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE)
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Components
-
-//#define GLM_FORCE_ONLY_XYZW
-#define GLM_COMPONENT_ONLY_XYZW				0 // To disable multiple vector component names access.
-#define GLM_COMPONENT_CXX98					1 //  
-#define GLM_COMPONENT_CXX11					2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
-
-#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXX11
-#elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
-#	define GLM_COMPONENT GLM_COMPONENT_CXX98
-#else
-#	define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
-#endif
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
-#	define GLM_MESSAGE_COMPONENT_DISPLAYED
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-#		pragma message("GLM: x,y,z,w component names for all vector types")
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-#		pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
-#	else
-#		error "GLM: GLM_COMPONENT value unknown"
-#	endif//GLM_MESSAGE_COMPONENT_DISPLAYED
-#endif//GLM_MESSAGE
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Static assert
-
-#if(GLM_LANG == GLM_LANG_CXX0X)
-#	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 
-
-// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
-
-#if(defined(GLM_FORCE_CUDA) || (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) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
-#       define GLM_INLINE __forceinline
-#   elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
-#       define GLM_INLINE __attribute__((always_inline))
-#   else
-#       define GLM_INLINE inline
-#   endif//GLM_COMPILER
-#else
-#   define GLM_INLINE 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(GLM_SUPPORT_SWIZZLE_OPERATOR())
-#		pragma message("GLM: Swizzling operators enabled")
-#	elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
-#		pragma message("GLM: Swizzling operators supported through swizzling functions")
-#	else
-#		pragma message("GLM: Swizzling operators disabled")
-#	endif
-#endif//GLM_MESSAGE
-
-#endif//glm_setup
diff --git a/thirdparty/glm/glm/core/type.hpp b/thirdparty/glm/glm/core/type.hpp
deleted file mode 100644
index 3bfe6cf5..00000000
--- a/thirdparty/glm/glm/core/type.hpp
+++ /dev/null
@@ -1,341 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type.hpp
-/// @date 2008-01-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type
-#define glm_core_type
-
-#include "type_half.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-
-#include "type_gentype.hpp"
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-
-#include "type_mat2x2.hpp"
-#include "type_mat2x3.hpp"
-#include "type_mat2x4.hpp"
-#include "type_mat3x2.hpp"
-#include "type_mat3x3.hpp"
-#include "type_mat3x4.hpp"
-#include "type_mat4x2.hpp"
-#include "type_mat4x3.hpp"
-#include "type_mat4x4.hpp"
-
-namespace glm
-{
-	/// @addtogroup core_types
-	/// @{
-
-	//////////////////////////
-	// Float definition
-
-#if(defined(GLM_PRECISION_HIGHP_FLOAT))
-	typedef highp_vec2          vec2;
-	typedef highp_vec3          vec3;
-	typedef highp_vec4          vec4;
-	typedef highp_mat2x2		mat2x2;
-	typedef highp_mat2x3		mat2x3;
-	typedef highp_mat2x4		mat2x4;
-	typedef highp_mat3x2		mat3x2;
-	typedef highp_mat3x3		mat3x3;
-	typedef highp_mat3x4		mat3x4;
-	typedef highp_mat4x2		mat4x2;
-	typedef highp_mat4x3		mat4x3;
-	typedef highp_mat4x4		mat4x4;
-#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
-	typedef mediump_vec2		vec2;
-	typedef mediump_vec3		vec3;
-	typedef mediump_vec4		vec4;
-	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;
-#elif(defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef lowp_vec2			vec2;
-	typedef lowp_vec3			vec3;
-	typedef lowp_vec4			vec4;
-	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;
-#else
-	/// 2 components vector 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.5 Vectors</a>
-	typedef mediump_vec2		vec2;
-
-	//! 3 components vector 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.5 Vectors</a>
-	typedef mediump_vec3		vec3;
-
-	//! 4 components vector 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.5 Vectors</a>
-	typedef mediump_vec4		vec4;
-
-	//! 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 mediump_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 mediump_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 mediump_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 mediump_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 mediump_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 mediump_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 mediump_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 mediump_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 mediump_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;
-
-	//////////////////////////
-	// Signed integer definition
-
-#if(defined(GLM_PRECISION_HIGHP_INT))
-	typedef highp_ivec2			ivec2;
-	typedef highp_ivec3			ivec3;
-	typedef highp_ivec4			ivec4;
-#elif(defined(GLM_PRECISION_MEDIUMP_INT))
-	typedef mediump_ivec2		ivec2;
-	typedef mediump_ivec3		ivec3;
-	typedef mediump_ivec4		ivec4;
-#elif(defined(GLM_PRECISION_LOWP_INT))
-	typedef lowp_ivec2			ivec2;
-	typedef lowp_ivec3			ivec3;
-	typedef lowp_ivec4			ivec4;
-#else
-	//! 2 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec2		ivec2;
-
-	//! 3 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec3		ivec3;
-
-	//! 4 components vector of signed integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_ivec4		ivec4;
-#endif//GLM_PRECISION
-
-	//////////////////////////
-	// Unsigned integer definition
-
-#if(defined(GLM_PRECISION_HIGHP_UINT))
-	typedef highp_uvec2			uvec2;
-	typedef highp_uvec3			uvec3;
-	typedef highp_uvec4			uvec4;
-#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
-	typedef mediump_uvec2		uvec2;
-	typedef mediump_uvec3		uvec3;
-	typedef mediump_uvec4		uvec4;
-#elif(defined(GLM_PRECISION_LOWP_UINT))
-	typedef lowp_uvec2			uvec2;
-	typedef lowp_uvec3			uvec3;
-	typedef lowp_uvec4			uvec4;
-#else
-	//! 2 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec2		uvec2;
-
-	//! 3 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec3		uvec3;
-
-	//! 4 components vector of unsigned integer numbers. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef mediump_uvec4		uvec4;
-#endif//GLM_PRECISION
-
-	//////////////////////////
-	// Boolean definition
-
-	//! 2 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec2<bool>		bvec2;
-
-	//! 3 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec3<bool>		bvec3;
-
-	//! 4 components vector of boolean. 
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.5 Vectors</a>
-	typedef detail::tvec4<bool>		bvec4;
-
-	//////////////////////////
-	// Double definition
-
-	//! Vector of 2 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.5 Vectors</a>
-	typedef detail::tvec2<double>	dvec2;
-
-	//! Vector of 3 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.5 Vectors</a>
-	typedef detail::tvec3<double>	dvec3;
-
-	//! Vector of 4 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.5 Vectors</a>
-	typedef detail::tvec4<double>	dvec4;
-
-	//! 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 detail::tmat2x2<double>	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 detail::tmat3x3<double>	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 detail::tmat4x4<double>	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 detail::tmat2x2<double>	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 detail::tmat2x3<double>	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 detail::tmat2x4<double>	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 detail::tmat3x2<double>	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 detail::tmat3x3<double>	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 detail::tmat3x4<double>	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 detail::tmat4x2<double>	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 detail::tmat4x3<double>	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 detail::tmat4x4<double>	dmat4x4;
-
-	/// @}
-}//namespace glm
-
-#endif//glm_core_type
diff --git a/thirdparty/glm/glm/core/type_float.hpp b/thirdparty/glm/glm/core/type_float.hpp
deleted file mode 100644
index b906dbb6..00000000
--- a/thirdparty/glm/glm/core/type_float.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_float.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_float
-#define glm_core_type_float
-
-#include "type_half.hpp"
-#include "setup.hpp"
-
-namespace glm
-{
-#ifdef GLM_USE_HALF_SCALAR
-    typedef detail::half		lowp_float_t;
-#else//GLM_USE_HALF_SCALAR
-    typedef float				lowp_float_t;
-#endif//GLM_USE_HALF_SCALAR
-    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
-
-	/// @}
-}//namespace glm
-
-#endif//glm_core_type_float
diff --git a/thirdparty/glm/glm/core/type_gentype.hpp b/thirdparty/glm/glm/core/type_gentype.hpp
deleted file mode 100644
index 50e0ca01..00000000
--- a/thirdparty/glm/glm/core/type_gentype.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_gentype.hpp
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype
-#define glm_core_type_gentype
-
-#include "type_size.hpp"
-
-namespace glm
-{
-	enum profile
-	{
-		nice,
-		fast,
-		simd
-	};
-
-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(value_type 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+= (value_type const & x);
-		class_type& operator+= (class_type const & x);
-		class_type& operator-= (value_type const & x);
-		class_type& operator-= (class_type const & x);
-		class_type& operator*= (value_type const & x);
-		class_type& operator*= (class_type const & x);
-		class_type& operator/= (value_type const & x);
-		class_type& operator/= (class_type const & x);
-		class_type& operator++ ();
-		class_type& operator-- ();
-	};
-*/
-	}//namespace detail
-}//namespace glm
-
-//#include "type_gentype.inl"
-
-#endif//glm_core_type_gentype
diff --git a/thirdparty/glm/glm/core/type_gentype.inl b/thirdparty/glm/glm/core/type_gentype.inl
deleted file mode 100644
index cbad2732..00000000
--- a/thirdparty/glm/glm/core/type_gentype.inl
+++ /dev/null
@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/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>::value_type 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>::value_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;
-
-	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>::value_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;
-
-	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>::value_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;
-
-	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>::value_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;
-
-	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
diff --git a/thirdparty/glm/glm/core/type_half.hpp b/thirdparty/glm/glm/core/type_half.hpp
deleted file mode 100644
index 1d933511..00000000
--- a/thirdparty/glm/glm/core/type_half.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_half.hpp
-/// @date 2008-08-17 / 2011-09-20
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_half
-#define glm_core_type_half
-
-#include <cstdlib>
-
-namespace glm{
-namespace detail
-{
-	typedef short hdata;
-
-	float toFloat32(hdata value);
-	hdata toFloat16(float const & value);
-
-	/// 16-bit floating point type.
-	/// @ingroup gtc_half_float
-	class half
-	{
-	public: 
-		// Constructors
-		GLM_FUNC_DECL half();
-		GLM_FUNC_DECL half(half const & s);
-			
-		template <typename U>
-		GLM_FUNC_DECL explicit half(U const & s);
-
-		// Cast
-		template <typename U>
-		GLM_FUNC_DECL operator U() const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL half& operator= (half const & s);
-		GLM_FUNC_DECL half& operator+=(half const & s);
-		GLM_FUNC_DECL half& operator-=(half const & s);
-		GLM_FUNC_DECL half& operator*=(half const & s);
-		GLM_FUNC_DECL half& operator/=(half const & s);
-		GLM_FUNC_DECL half& operator++();
-		GLM_FUNC_DECL half& operator--();
-	
-		GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
-
-		GLM_FUNC_DECL hdata _data() const{return data;}
-
-	private:
-		hdata data;
-	};
-
-	half operator+ (half const & s1, half const & s2);
-
-	half operator- (half const & s1, half const & s2);
-
-	half operator* (half const & s1, half const & s2);
-
-	half operator/ (half const & s1, half const & s2);
-
-	// Unary constant operators
-	half operator- (half const & s);
-
-	half operator-- (half const & s, int);
-
-	half operator++ (half const & s, int);
-
-	bool operator==(
-		detail::half const & x, 
-		detail::half const & y);
-
-	bool operator!=(
-		detail::half const & x, 
-		detail::half const & y);
-
-	bool operator<(
-		detail::half const & x, 
-		detail::half const & y);
-
-	bool operator<=(
-		detail::half const & x, 
-		detail::half const & y);
-
-	bool operator>(
-		detail::half const & x, 
-		detail::half const & y);
-
-	bool operator>=(
-		detail::half const & x, 
-		detail::half const & y);
-
-}//namespace detail
-}//namespace glm
-
-#include "type_half.inl"
-
-#endif//glm_core_type_half
diff --git a/thirdparty/glm/glm/core/type_half.inl b/thirdparty/glm/glm/core/type_half.inl
deleted file mode 100644
index 845369d2..00000000
--- a/thirdparty/glm/glm/core/type_half.inl
+++ /dev/null
@@ -1,415 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_half.inl
-/// @date 2008-08-17 / 2011-06-15
-/// @author Christophe Riccio
-///
-/// Copyright:
-/// This half implementation is based on OpenEXR which is Copyright (c) 2002, 
-/// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "_detail.hpp"
-
-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;
-	}
-
-	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::uif 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
-				//
-
-				uif result;
-				result.i = (unsigned int)((s << 31) | 0x7f800000);
-				return result.f;
-			}
-			else
-			{
-				//
-				// Nan -- preserve sign and significand bits
-				//
-
-				uif 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.
-		//
-
-		uif Result;
-		Result.i = (unsigned int)((s << 31) | (e << 23) | m);
-		return Result.f;
-	}
-
-	GLM_FUNC_QUALIFIER hdata toFloat16(float const & f)
-	{
-		uif 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).
-		//
-
-		register int s =  (i >> 16) & 0x00008000;
-		register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
-		register 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 _halfGTX zero.
-				//
-
-				return 0;
-			}
-
-			//
-			// 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 _halfGTX.
-			// 
-
-			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 _halfGTX 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));
-		}
-	}
-
-	GLM_FUNC_QUALIFIER half::half() :
-		data(0)
-	{}
-
-	GLM_FUNC_QUALIFIER half::half(half const & s) :
-		data(s.data)
-	{}
-
-	template <typename U>
-	GLM_FUNC_QUALIFIER half::half(U const & s) :
-		data(toFloat16(float(s)))
-	{}
-
-	template <typename U>
-	GLM_FUNC_QUALIFIER half::operator U() const
-	{
-		return static_cast<U>(toFloat32(this->data));
-	}
-
-	// Unary updatable operators
-	GLM_FUNC_QUALIFIER half& half::operator= (half const & s)
-	{
-		data = s.data;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator+=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) + toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator-=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) - toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator*=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) * toFloat32(s.data));		
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator/=(half const & s)
-	{
-		data = toFloat16(toFloat32(data) / toFloat32(s.data));
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator++()
-	{
-		float Casted = toFloat32(data);
-		this->data = toFloat16(++Casted);
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER half& half::operator--()
-	{
-		float Casted = toFloat32(data);
-		this->data = toFloat16(--Casted);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	GLM_FUNC_QUALIFIER detail::half operator+ (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) + float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) - float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator* (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) * float(s2));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator/ (detail::half const & s1, detail::half const & s2)
-	{
-		return detail::half(float(s1) / float(s2));
-	}
-
-	// Unary constant operators
-	GLM_FUNC_QUALIFIER detail::half operator- (detail::half const & s)
-	{
-		return detail::half(-float(s));
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator-- (detail::half const & s, int)
-	{
-		return detail::half(float(s) - 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER detail::half operator++ (detail::half const & s, int)
-	{
-		return detail::half(float(s) + 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return x._data() == y._data();
-	}
-
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return x._data() != y._data();
-	}
-
-	GLM_FUNC_QUALIFIER bool operator<
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) < float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator<=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) <= float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator>
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) > float(y);
-	}
-
-	GLM_FUNC_QUALIFIER bool operator>=
-	(
-		detail::half const & x, 
-		detail::half const & y
-	)
-	{
-		return float(x) >= float(y);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/type_int.hpp b/thirdparty/glm/glm/core/type_int.hpp
deleted file mode 100644
index 6a97ea69..00000000
--- a/thirdparty/glm/glm/core/type_int.hpp
+++ /dev/null
@@ -1,137 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_int.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_int
-#define glm_core_type_int
-
-#include "setup.hpp"
-#include "_detail.hpp"
-
-namespace glm{
-namespace detail
-{
-	typedef signed short			lowp_int_t;
-	typedef signed int				mediump_int_t;
-	typedef sint64					highp_int_t;
-
-	typedef unsigned short			lowp_uint_t;
-	typedef unsigned int			mediump_uint_t;
-	typedef uint64					highp_uint_t;
-
-	GLM_DETAIL_IS_INT(signed char);
-	GLM_DETAIL_IS_INT(signed short);
-	GLM_DETAIL_IS_INT(signed int);
-	GLM_DETAIL_IS_INT(signed long);
-	GLM_DETAIL_IS_INT(highp_int_t);
-
-	GLM_DETAIL_IS_UINT(unsigned char);
-	GLM_DETAIL_IS_UINT(unsigned short);
-	GLM_DETAIL_IS_UINT(unsigned int);
-	GLM_DETAIL_IS_UINT(unsigned long);
-	GLM_DETAIL_IS_UINT(highp_uint_t);
-}//namespace detail
-
-	/// @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 uint_t								uint;
-
-	/// @}
-
-}//namespace glm
-
-#endif//glm_core_type_int
diff --git a/thirdparty/glm/glm/core/type_mat.hpp b/thirdparty/glm/glm/core/type_mat.hpp
deleted file mode 100644
index cbf0c205..00000000
--- a/thirdparty/glm/glm/core/type_mat.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat.hpp
-/// @date 2010-01-26 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat
-#define glm_core_type_mat
-
-#include "type_gentype.hpp"
-
-namespace glm{
-namespace detail
-{
-	//template 
-	//<
-	//	typename T, 
-	//	template <typename> class C, 
-	//	template <typename> class R
-	//>
-	//struct matType
-	//{
-	//	enum ctor{null};
-	//	typedef T value_type;
-	//	typedef std::size_t size_type;
-	//	typedef C<T> col_type;
-	//	typedef R<T> row_type;
-	//	static size_type const col_size;
-	//	static size_type const row_size;
-	//};
-
-	//template 
-	//<
-	//	typename T, 
-	//	template <typename> class C, 
-	//	template <typename> class R
-	//>
-	//typename matType<T, C, R>::size_type const 
-	//matType<T, C, R>::col_size = matType<T, C, R>::col_type::value_size;
-
-	//template 
-	//<
-	//	typename T, 
-	//	template <typename> class C, 
-	//	template <typename> class R
-	//>
-	//typename matType<T, C, R>::size_type const 
-	//matType<T, C, R>::row_size = matType<T, C, R>::row_type::value_size;
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_mat
diff --git a/thirdparty/glm/glm/core/type_mat.inl b/thirdparty/glm/glm/core/type_mat.inl
deleted file mode 100644
index 06ce8f66..00000000
--- a/thirdparty/glm/glm/core/type_mat.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/thirdparty/glm/glm/core/type_mat2x2.hpp b/thirdparty/glm/glm/core/type_mat2x2.hpp
deleted file mode 100644
index 0f0c9669..00000000
--- a/thirdparty/glm/glm/core/type_mat2x2.hpp
+++ /dev/null
@@ -1,316 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x2.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x2
-#define glm_core_type_mat2x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// @brief Template for 2 * 2 matrix of floating-point numbers.
-	// @ingroup core_template
-	template <typename T> 
-	struct tmat2x2
-	{
-                // Implementation detail
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec2<T> row_type;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat2x2<T> type;
-		typedef tmat2x2<T> transpose_type;
-        
-		GLM_FUNC_DECL size_type length() const;
-        
-	public:
-                // Implementation detail
-		GLM_FUNC_DECL tmat2x2<T> _inverse() const;
-
-	private:
-		//////////////////////////////////////
-                // Implementation detail
-		col_type value[2];
-        
-	public:
-		//////////////////////////////////////
-		// Constructors
-		GLM_FUNC_DECL tmat2x2();
-		GLM_FUNC_DECL tmat2x2(
-			tmat2x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x2(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat2x2(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat2x2(
-			value_type const & x1, value_type const & y1, 
-			value_type const & x2, value_type const & y2);
-		GLM_FUNC_DECL explicit tmat2x2(
-			col_type const & v1, 
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			U const & x);
-
-		template <typename U, typename V, typename M, typename N> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			U const & x1, V const & y1, 
-			M const & x2, N const & y2);
-			
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tmat2x2(
-			tvec2<U> const & v1, 
-			tvec2<V> const & v2);
-
-		//////////////////////////////////////
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
-		GLM_FUNC_DECL tmat2x2<T> & operator++();
-		GLM_FUNC_DECL tmat2x2<T> & operator--();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat2x2<T> operator+ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x2<T> operator+ (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	tmat2x2<T> operator+ (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-	    
-	template <typename T> 
-	tmat2x2<T> operator- (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x2<T> operator- (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	tmat2x2<T> operator- (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	template <typename T> 
-	tmat2x2<T> operator* (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x2<T> operator* (
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	typename tmat2x2<T>::col_type operator* (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat2x2<T>::row_type operator* (
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	tmat2x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-		
-	template <typename T>
-	tmat3x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-		
-	template <typename T>
-	tmat4x2<T> operator* (
-		tmat2x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	tmat2x2<T> operator/ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x2<T> operator/ (
-		typename tmat2x2<T>::value_type const & s,
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	typename tmat2x2<T>::col_type operator/ (
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat2x2<T>::row_type operator/ (
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	tmat2x2<T> operator/ (
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat2x2<T> const operator-  (
-		tmat2x2<T> const & m);
-
-	template <typename T> 
-	tmat2x2<T> const operator-- (
-		tmat2x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat2x2<T> const operator++ (
-		tmat2x2<T> const & m, 
-		int);
-} //namespace detail
-
-	/// @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 detail::tmat2x2<lowp_float>		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 detail::tmat2x2<mediump_float>	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 detail::tmat2x2<highp_float>	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 detail::tmat2x2<lowp_float>		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 detail::tmat2x2<mediump_float>	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 detail::tmat2x2<highp_float>	highp_mat2x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x2.inl"
-#endif
-
-#endif //glm_core_type_mat2x2
diff --git a/thirdparty/glm/glm/core/type_mat2x2.inl b/thirdparty/glm/glm/core/type_mat2x2.inl
deleted file mode 100644
index a6227297..00000000
--- a/thirdparty/glm/glm/core/type_mat2x2.inl
+++ /dev/null
@@ -1,707 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x2.inl
-/// @date 2005-01-16 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::length() const
-    {
-        return 2;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type &
-	tmat2x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type const &
-	tmat2x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2()
-    {
-		this->value[0] = col_type(1, 0);
-        this->value[1] = col_type(0, 1);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero);
-        this->value[1] = col_type(Zero, s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		value_type const & x0, value_type const & y0, 
-		value_type const & x1, value_type const & y1
-	)
-    {
-        this->value[0] = col_type(x0, y0);
-        this->value[1] = col_type(x1, y1);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		col_type const & v0, 
-		col_type const & v1
-	)
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec2<T>(value_type(s), Zero);
-        this->value[1] = tvec2<T>(Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <typename X1, typename Y1, typename X2, typename Y2> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1));
-        this->value[1] = col_type(value_type(x2), value_type(y2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x2<T>::tmat2x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-	}
-
-    //////////////////////////////////////////////////////////////
-    // mat2x2 matrix conversions
-
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x2<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-	template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> tmat2x2<T>::_inverse() const
-    {
-        typename tmat2x2<T>::value_type Determinant = this->value[0][0] * this->value[1][1] - this->value[1][0] * this->value[0][1];
-
-        tmat2x2<T> Inverse(
-            + this->value[1][1] / Determinant,
-            - this->value[1][0] / Determinant,
-            - this->value[0][1] / Determinant, 
-            + this->value[0][0] / Determinant);
-        return Inverse;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // mat2x2 operators
-
-    // This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
-	(
-		tmat2x2<T> const & m
-	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-	    return *this;
-    }
-
-	template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
-	(
-		tmat2x2<U> const & m
-	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
-	(
-		U const & s
-	)
-    {
-	    this->value[0] += s;
-	    this->value[1] += s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
-	(
-		tmat2x2<U> const & m
-	)
-    {
-	    this->value[0] += m[0];
-	    this->value[1] += m[1];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
-	(
-		U const & s
-	)
-    {
-	    this->value[0] -= s;
-	    this->value[1] -= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
-	(
-		tmat2x2<U> const & m
-	)
-    {
-	    this->value[0] -= m[0];
-	    this->value[1] -= m[1];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] *= s;
-	    this->value[1] *= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
-	(
-		tmat2x2<U> const & m
-	)
-    {
-        return (*this = *this * m);
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] /= s;
-	    this->value[1] /= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
-	(
-		tmat2x2<U> const & m
-	)
-    {
-        return (*this = *this / m);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator++ ()
-    {
-	    ++this->value[0];
-	    ++this->value[1];
-	    return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-- ()
-    {
-	    --this->value[0];
-	    --this->value[1];
-	    return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-	// Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-    {
-        return tmat2x2<T>(
-            m[0] + s,
-            m[1] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-    {
-        return tmat2x2<T>(
-            m[0] + s,
-            m[1] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-    {
-        return tmat2x2<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-    {
-        return tmat2x2<T>(
-            m[0] - s,
-            m[1] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-    {
-        return tmat2x2<T>(
-            s - m[0],
-            s - m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-    {
-        return tmat2x2<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-    {
-        return tmat2x2<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-
-	//     X
-	//     X
-	// X X
-	// X X
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(	
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-    {
-        return tmat2x2<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator* 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type const & v
-	)
-    {
-        return detail::tvec2<T>(
-            m[0][0] * v.x + m[1][0] * v.y,
-            m[0][1] * v.x + m[1][1] * v.y);
-    }
-
-	//		X X
-	//		X X
-	// X X 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator* 
-	(
-		typename tmat2x2<T>::col_type const & v, 
-		tmat2x2<T> const & m
-	)
-    {
-        return detail::tvec2<T>(
-            v.x * m[0][0] + v.y * m[0][1],
-            v.x * m[1][0] + v.y * m[1][1]);
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x2<T>(
-			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>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat2x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			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>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat2x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			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> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::value_type const & s
-	)
-    {
-        return tmat2x2<T>(
-            m[0] / s,
-            m[1] / s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		typename tmat2x2<T>::value_type const & s, 
-		tmat2x2<T> const & m
-	)
-    {
-        return tmat2x2<T>(
-            s / m[0],
-            s / m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator/ 
-	(
-		tmat2x2<T> const & m, 
-		typename tmat2x2<T>::row_type & v
-	)
-    {
-        return m._inverse() * v;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator/ 
-	(
-		typename tmat2x2<T>::col_type const & v,
-		tmat2x2<T> const & m
-	)
-    {
-        return v * m._inverse();
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-    {
-        return m1 * m2._inverse();
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> const operator- 
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        return tmat2x2<T>(
-            -m[0], 
-            -m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> const operator++ 
-	(
-		tmat2x2<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x2<T>(
-            m[0] + T(1),
-            m[1] + T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> const operator-- 
-	(
-		tmat2x2<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x2<T>(
-            m[0] - T(1),
-            m[1] - T(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x2<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat2x3.hpp b/thirdparty/glm/glm/core/type_mat2x3.hpp
deleted file mode 100644
index e69828b6..00000000
--- a/thirdparty/glm/glm/core/type_mat2x3.hpp
+++ /dev/null
@@ -1,259 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x3.hpp
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x3
-#define glm_core_type_mat2x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat2x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec2<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat2x3<T> type;
-		typedef tmat3x2<T> transpose_type;
-
-	private:
-		// Data 
-		col_type value[2];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat2x3();
-		GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x3(
-			ctor);
-		GLM_FUNC_DECL explicit tmat2x3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat2x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1);
-		GLM_FUNC_DECL explicit tmat2x3(
-			col_type const & v0, 
-			col_type const & v1);
-            
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x3(
-            U const & x);
-			
-		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> 
-		GLM_FUNC_DECL explicit 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 explicit tmat2x3(
-            tvec3<U> const & v1, 
-            tvec3<V> const & v2);
-            
-		//////////////////////////////////////
-        // Matrix conversion
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
-
-		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat2x3<T> & operator++ ();
-		GLM_FUNC_DECL tmat2x3<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat2x3<T> operator+ (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat2x3<T> operator+ (
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-	    
-	template <typename T> 
-	tmat2x3<T> operator- (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x3<T> operator- (
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-
-	template <typename T> 
-	tmat2x3<T> operator* (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x3<T> operator* (
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m);
-
-	template <typename T>
-	typename tmat2x3<T>::col_type operator* (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat2x3<T>::row_type operator* (
-		typename tmat2x3<T>::col_type const & v, 
-		tmat2x3<T> const & m);
-
-	template <typename T>
-	tmat2x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat2x2<T> const & m2);
-
-	template <typename T>
-	tmat3x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat3x2<T> const & m2);
-		
-	template <typename T>
-	tmat4x3<T> operator* (
-		tmat2x3<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	tmat2x3<T> operator/ (
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x3<T> operator/ (
-		typename tmat2x3<T>::value_type const & s,
-		tmat2x3<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat2x3<T> const operator-  (
-		tmat2x3<T> const & m);
-
-	template <typename T> 
-	tmat2x3<T> const operator-- (
-		tmat2x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat2x3<T> const operator++ (
-		tmat2x3<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @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 detail::tmat2x3<lowp_float>		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 detail::tmat2x3<mediump_float>	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 detail::tmat2x3<highp_float>	highp_mat2x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x3.inl"
-#endif
-
-#endif //glm_core_type_mat2x3
diff --git a/thirdparty/glm/glm/core/type_mat2x3.inl b/thirdparty/glm/glm/core/type_mat2x3.inl
deleted file mode 100644
index 49246087..00000000
--- a/thirdparty/glm/glm/core/type_mat2x3.inl
+++ /dev/null
@@ -1,646 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x3.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::length() const
-    {
-        return 2;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type &
-	tmat2x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type const &
-	tmat2x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3()
-    {
-        this->value[0] = col_type(T(1), T(0), T(0));
-        this->value[1] = col_type(T(0), T(1), T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		value_type const & s
-	)
-    {
-        this->value[0] = col_type(s, T(0), T(0));
-        this->value[1] = col_type(T(0), s, T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0,
-        value_type const & x1, value_type const & y1, value_type const & z1
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0);
-        this->value[1] = col_type(x1, y1, z1);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-    (
-        col_type const & v0, 
-        col_type const & v1
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-        this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x3<T>::tmat2x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-	}
-
-	//////////////////////////////////////
-    // Matrix conversions
-    
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x3<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
-	(
-		tmat2x3<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator+=
-	(
-		tmat2x3<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
-	(
-		tmat2x3<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator*= 
-	(
-		tmat2x3<U> const & m
-	)
-    {
-        return (*this = tmat2x3<U>(*this * m));
-    }
-
-    template <typename T>
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        return *this;
-    }
-    
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-    {
-        return tmat2x3<T>(
-            m[0] + s,
-            m[1] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-    {
-        return tmat2x3<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-    {
-        return tmat2x3<T>(
-            m[0] - s,
-            m[1] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-    {
-        return tmat2x3<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-    {
-        return tmat2x3<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m
-	)
-    {
-        return tmat2x3<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type operator* 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::row_type const & v)
-    {
-        return typename tmat2x3<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y,
-            m[0][1] * v.x + m[1][1] * v.y,
-            m[0][2] * v.x + m[1][2] * v.y);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x3<T>::row_type operator* 
-	(
-		typename tmat2x3<T>::col_type const & v, 
-		tmat2x3<T> const & m) 
-    {
-        return typename tmat2x3<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
-            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			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][2] * m2[0][0] + m1[1][2] * 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][2] * m2[1][0] + m1[1][2] * m2[1][1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-    {
-		typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
-		typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
-		typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
-		typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
-		typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
-		typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
-
-		typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
-		typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
-		typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
-		typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
-		typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
-		typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
-
-		tmat3x3<T> Result(tmat3x3<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat2x3<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			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][2] * m2[0][0] + m1[1][2] * 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][2] * m2[1][0] + m1[1][2] * 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][2] * m2[2][0] + m1[1][2] * 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],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
-	(
-		tmat2x3<T> const & m, 
-		typename tmat2x3<T>::value_type const & s
-	)
-    {
-        return tmat2x3<T>(
-            m[0] / s,
-            m[1] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
-	(
-		typename tmat2x3<T>::value_type const & s, 
-		tmat2x3<T> const & m
-	)
-    {
-        return tmat2x3<T>(
-            s / m[0],
-            s / m[1]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> const operator- 
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        return tmat2x3<T>(
-            -m[0], 
-            -m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> const operator++ 
-	(
-		tmat2x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x3<T>(
-            m[0] + typename tmat2x3<T>::value_type(1),
-            m[1] + typename tmat2x3<T>::value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x3<T> const operator-- 
-	(
-		tmat2x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x3<T>(
-            m[0] - typename tmat2x3<T>::value_type(1),
-            m[1] - typename tmat2x3<T>::value_type(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat2x4.hpp b/thirdparty/glm/glm/core/type_mat2x4.hpp
deleted file mode 100644
index 7740a3d3..00000000
--- a/thirdparty/glm/glm/core/type_mat2x4.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x4.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat2x4
-#define glm_core_type_mat2x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// Template for 2 columns and 4 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat2x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec2<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat2x4<T> type;
-		typedef tmat4x2<T> transpose_type;
-
-	private:
-		// Data 
-		col_type value[2];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat2x4();
-		GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat2x4(
-			ctor);
-		GLM_FUNC_DECL explicit tmat2x4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat2x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
-		GLM_FUNC_DECL explicit tmat2x4(
-			col_type const & v0, 
-			col_type const & v1);
-            
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x4(
-            U const & x);
-			
-		template <
-            typename X1, typename Y1, typename Z1, typename W1, 
-            typename X2, typename Y2, typename Z2, typename W2> 
-		GLM_FUNC_DECL explicit tmat2x4(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
-			
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tmat2x4(
-            tvec4<U> const & v1, 
-            tvec4<V> const & v2);
-            
-        //////////////////////////////////////
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat2x4<T>& operator++ ();
-		GLM_FUNC_DECL tmat2x4<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat2x4<T> operator+ (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat2x4<T> operator+ (
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-	    
-	template <typename T> 
-	tmat2x4<T> operator- (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x4<T> operator- (
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	tmat2x4<T> operator* (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x4<T> operator* (
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m);
-
-	template <typename T>
-	typename tmat2x4<T>::col_type operator* (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat2x4<T>::row_type operator* (
-		typename tmat2x4<T>::col_type const & v, 
-		tmat2x4<T> const & m);
-
-	template <typename T>
-	tmat4x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat4x2<T> const & m2);
-		
-	template <typename T>
-	tmat2x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat2x2<T> const & m2);
-		
-	template <typename T>
-	tmat3x4<T> operator* (
-		tmat2x4<T> const & m1, 
-		tmat3x2<T> const & m2);
-
-	template <typename T> 
-	tmat2x4<T> operator/ (
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat2x4<T> operator/ (
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat2x4<T> const operator-  (
-		tmat2x4<T> const & m);
-
-	template <typename T> 
-	tmat2x4<T> const operator-- (
-		tmat2x4<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat2x4<T> const operator++ (
-		tmat2x4<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @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 detail::tmat2x4<lowp_float>		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 detail::tmat2x4<mediump_float>	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 detail::tmat2x4<highp_float>	highp_mat2x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x4.inl"
-#endif
-
-#endif //glm_core_type_mat2x4
diff --git a/thirdparty/glm/glm/core/type_mat2x4.inl b/thirdparty/glm/glm/core/type_mat2x4.inl
deleted file mode 100644
index 39c82251..00000000
--- a/thirdparty/glm/glm/core/type_mat2x4.inl
+++ /dev/null
@@ -1,676 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat2x4.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::length() const
-    {
-        return 2;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type &
-	tmat2x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type const &
-	tmat2x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4()
-    {
-		value_type const Zero(0);
-		value_type const One(1);
-        this->value[0] = col_type(One, Zero, Zero, Zero);
-        this->value[1] = col_type(Zero, One, Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero, Zero);
-        this->value[1] = col_type(Zero, Zero, Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0, w0);
-        this->value[1] = col_type(x1, y1, z1, w1);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-    (
-        col_type const & v0, 
-        col_type const & v1
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-        this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2 
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2> 
-	GLM_FUNC_DECL tmat2x4<T>::tmat2x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-	}
-
-	//////////////////////////////////////
-    // Matrix conversions
-    
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x4<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
-	(
-		tmat2x4<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
-	(
-		tmat2x4<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
-	(
-		tmat2x4<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*=
-	(
-		tmat2x4<U> const & m
-	)
-    {
-        return (*this = tmat2x4<T>(*this * m));
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator+
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-    {
-        return tmat2x4<T>(
-            m[0] + s,
-            m[1] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator+ 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-    {
-        return tmat2x4<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-    {
-        return tmat2x4<T>(
-            m[0] - s,
-            m[1] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-    {
-        return tmat2x4<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-    {
-        return tmat2x4<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator*
-	(
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m
-	)
-    {
-        return tmat2x4<T>(
-            m[0] * s,
-            m[1] * s);
-    }
-   
-	//     X
-	//     X
-	// X X
-	// X X
-	// X X
-	// X X
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type operator* 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::row_type const & v
-	)
-    {
-        return typename tmat2x4<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y,
-            m[0][1] * v.x + m[1][1] * v.y,
-            m[0][2] * v.x + m[1][2] * v.y,
-            m[0][3] * v.x + m[1][3] * v.y);
-    }
-
-	//			X X
-	//			X X
-	//			X X
-	//			X X
-	// X X X X
-	template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat2x4<T>::row_type operator* 
-	(
-		typename tmat2x4<T>::col_type const & v, 
-		tmat2x4<T> const & m
-	) 
-    {
-        return typename tmat2x4<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
-            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-    {
-		typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
-		typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
-		typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
-		typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
-		typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
-		typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
-		typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
-		typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
-
-		typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
-		typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
-		typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
-		typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
-		typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
-		typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
-		typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
-		typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
-
-		tmat4x4<T> Result(tmat4x4<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
-		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
-		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
-		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
-		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
-		return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x2<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * 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][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat2x4<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * 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][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * 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][2] * m2[2][0] + m1[1][2] * m2[2][1],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
-	(
-		tmat2x4<T> const & m, 
-		typename tmat2x4<T>::value_type const & s
-	)
-    {
-        return tmat2x4<T>(
-            m[0] / s,
-            m[1] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
-	(
-		typename tmat2x4<T>::value_type const & s, 
-		tmat2x4<T> const & m
-	)
-    {
-        return tmat2x4<T>(
-            s / m[0],
-            s / m[1]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> const operator- 
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        return tmat2x4<T>(
-            -m[0], 
-            -m[1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> const operator++ 
-	(
-		tmat2x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x4<T>(
-            m[0] + typename tmat2x4<T>::value_type(1),
-            m[1] + typename tmat2x4<T>::value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x4<T> const operator-- 
-	(
-		tmat2x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat2x4<T>(
-            m[0] - typename tmat2x4<T>::value_type(1),
-            m[1] - typename tmat2x4<T>::value_type(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat2x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat3x2.hpp b/thirdparty/glm/glm/core/type_mat3x2.hpp
deleted file mode 100644
index 2e9a0823..00000000
--- a/thirdparty/glm/glm/core/type_mat3x2.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x2.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x2
-#define glm_core_type_mat3x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat3x2
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec3<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat3x2<T> type;
-		typedef tmat2x3<T> transpose_type;
-
-	private:
-		// Data
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x2();
-		GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x2(
-			ctor);
-		GLM_FUNC_DECL explicit tmat3x2(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x2(
-			value_type const & x0, value_type const & y0,
-			value_type const & x1, value_type const & y1,
-			value_type const & x2, value_type const & y2);
-		GLM_FUNC_DECL explicit tmat3x2(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x2(
-            U const & x);
-			
-		template 
-        <
-            typename X1, typename Y1, 
-            typename X2, typename Y2, 
-            typename X3, typename Y3
-        > 
-		GLM_FUNC_DECL explicit tmat3x2(
-            X1 const & x1, Y1 const & y1, 
-            X2 const & x2, Y2 const & y2,
-            X3 const & x3, Y3 const & y3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x2(
-            tvec2<V1> const & v1, 
-            tvec2<V2> const & v2,
-            tvec2<V3> const & v3);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat3x2<T> & operator++ ();
-		GLM_FUNC_DECL tmat3x2<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat3x2<T> operator+ (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat3x2<T> operator+ (
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-	    
-	template <typename T> 
-	tmat3x2<T> operator- (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x2<T> operator- (
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2);
-
-	template <typename T> 
-	tmat3x2<T> operator* (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x2<T> operator* (
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m);
-
-	template <typename T>
-	typename tmat3x2<T>::col_type operator* (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat3x2<T>::row_type operator* (
-		typename tmat3x2<T>::col_type const & v,
-		tmat3x2<T> const & m);
-
-	template <typename T>
-	tmat2x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	tmat3x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat3x3<T> const & m2);
-		
-	template <typename T>
-	tmat4x2<T> operator* (
-		tmat3x2<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	tmat3x2<T> operator/ (
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x2<T> operator/ (
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat3x2<T> const operator-  (
-		tmat3x2<T> const & m);
-
-	template <typename T> 
-	tmat3x2<T> const operator-- (
-		tmat3x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat3x2<T> const operator++ (
-		tmat3x2<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @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 detail::tmat3x2<lowp_float>		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 detail::tmat3x2<mediump_float>	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 detail::tmat3x2<highp_float>	highp_mat3x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x2.inl"
-#endif
-
-#endif //glm_core_type_mat3x2
diff --git a/thirdparty/glm/glm/core/type_mat3x2.inl b/thirdparty/glm/glm/core/type_mat3x2.inl
deleted file mode 100644
index 05c7ed61..00000000
--- a/thirdparty/glm/glm/core/type_mat3x2.inl
+++ /dev/null
@@ -1,682 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x2.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::length() const
-    {
-        return 3;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type &
-	tmat3x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type const & 
-	tmat3x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2()
-    {
-        this->value[0] = col_type(1, 0);
-        this->value[1] = col_type(0, 1);
-        this->value[2] = col_type(0, 0);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-		this->value[2] = m.value[2];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		value_type const & s
-	)
-    {
-        this->value[0] = col_type(s, 0);
-        this->value[1] = col_type(0, s);
-        this->value[2] = col_type(0, 0);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-    (
-        value_type const & x0, value_type const & y0,
-        value_type const & x1, value_type const & y1,
-        value_type const & x2, value_type const & y2
-    )
-    {
-        this->value[0] = col_type(x0, y0);
-        this->value[1] = col_type(x1, y1);
-        this->value[2] = col_type(x2, y2);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec2<T>(value_type(s), Zero);
-        this->value[1] = tvec2<T>(Zero, value_type(s));
-        this->value[2] = tvec2<T>(Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, 
-		typename X2, typename Y2, 
-		typename X3, typename Y3> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2, 
-		X3 const & x3, Y3 const & y3
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1));
-        this->value[1] = col_type(value_type(x2), value_type(y2));
-        this->value[2] = col_type(value_type(x3), value_type(y3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x2<T>::tmat3x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2, 
-		tvec2<V3> const & v3
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-	}
-
-    //////////////////////////////////////////////////////////////
-    // mat3x2 matrix conversions
-
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x2<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = col_type(T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
-	(
-		tmat3x2<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        this->value[2] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
-	(
-		tmat3x2<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        this->value[2] += m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        this->value[2] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
-	(
-		tmat3x2<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        this->value[2] -= m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        this->value[2] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
-	(
-		tmat3x2<U> const & m
-	)
-    {
-        return (*this = tmat3x2<T>(*this * m));
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        this->value[2] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        ++this->value[2];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        --this->value[2];
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-    {
-        return tmat3x2<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-    {
-        return tmat3x2<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-    {
-        return tmat3x2<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
-	(	
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-    {
-        return tmat3x2<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-    {
-        return tmat3x2<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m
-	)
-    {
-        return tmat3x2<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-   
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type operator* 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::row_type const & v)
-    {
-        return typename tmat3x2<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x2<T>::row_type operator* 
-	(
-		typename tmat3x2<T>::col_type const & v, 
-		tmat3x2<T> const & m) 
-    {
-        return typename tmat3x2<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1],
-            v.x * m[1][0] + v.y * m[1][1],
-            v.x * m[2][0] + v.y * m[2][1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-    {
-        const T SrcA00 = m1[0][0];
-        const T SrcA01 = m1[0][1];
-        const T SrcA10 = m1[1][0];
-        const T SrcA11 = m1[1][1];
-        const T SrcA20 = m1[2][0];
-        const T SrcA21 = m1[2][1];
-
-        const T SrcB00 = m2[0][0];
-        const T SrcB01 = m2[0][1];
-        const T SrcB02 = m2[0][2];
-        const T SrcB10 = m2[1][0];
-        const T SrcB11 = m2[1][1];
-        const T SrcB12 = m2[1][2];
-
-        tmat2x2<T> Result(tmat2x2<T>::null);
-        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-        return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat3x2<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
-	(
-		tmat3x2<T> const & m, 
-		typename tmat3x2<T>::value_type const & s
-	)
-    {
-        return tmat3x2<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
-	(
-		typename tmat3x2<T>::value_type const & s, 
-		tmat3x2<T> const & m
-	)
-    {
-        return tmat3x2<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> const operator- 
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        return tmat3x2<T>(
-            -m[0], 
-            -m[1],
-            -m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> const operator++ 
-	(
-		tmat3x2<T> const & m, 
-		int
-	) 
-    {
-		typename tmat3x2<T>::value_type One(1);
-        return tmat3x2<T>(
-            m[0] + One,
-            m[1] + One,
-            m[2] + One);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x2<T> const operator-- 
-	(
-		tmat3x2<T> const & m, 
-		int
-	) 
-    {
-		typename tmat3x2<T>::value_type One(1);
-        return tmat3x2<T>(
-            m[0] - One,
-            m[1] - One,
-            m[2] - One);
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x2<T> const & m1, 
-		tmat3x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat3x3.hpp b/thirdparty/glm/glm/core/type_mat3x3.hpp
deleted file mode 100644
index a4cbd95e..00000000
--- a/thirdparty/glm/glm/core/type_mat3x3.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x3.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x3
-#define glm_core_type_mat3x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// @brief Template for 3 * 3 matrix of floating-point numbers.
-	// @ingroup core_template
-	template <typename T> 
-	struct tmat3x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec3<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat3x3<T> type;
-		typedef tmat3x3<T> transpose_type;
-
-	public:
-		/// Implementation detail
-        /// @cond DETAIL
-		GLM_FUNC_DECL tmat3x3<T> _inverse() const;
-        /// @endcond
-        
-	private:
-		// Data
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x3();
-		GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x3(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat3x3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1,
-			value_type const & x2, value_type const & y2, value_type const & z2);
-		GLM_FUNC_DECL explicit tmat3x3(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x3(
-            U const & x);
-			
-		template 
-        <
-            typename X1, typename Y1, typename Z1, 
-            typename X2, typename Y2, typename Z2, 
-            typename X3, typename Y3, typename Z3
-        > 
-		GLM_FUNC_DECL explicit tmat3x3(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, 
-            X3 const & x3, Y3 const & y3, Z3 const & z3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x3(
-            tvec3<V1> const & v1, 
-            tvec3<V2> const & v2,
-            tvec3<V3> const & v3);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
-		GLM_FUNC_DECL tmat3x3<T>& operator++ ();
-		GLM_FUNC_DECL tmat3x3<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat3x3<T> operator+ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x3<T> operator+ (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	tmat3x3<T> operator+ (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-	    
-	template <typename T> 
-	tmat3x3<T> operator- (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x3<T> operator- (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	tmat3x3<T> operator- (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	template <typename T> 
-	tmat3x3<T> operator* (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x3<T> operator* (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	typename tmat3x3<T>::col_type operator* (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat3x3<T>::row_type operator* (
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	tmat3x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-		
-	template <typename T>
-	tmat2x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	tmat4x3<T> operator* (
-		tmat3x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	tmat3x3<T> operator/ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x3<T> operator/ (
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	typename tmat3x3<T>::col_type operator/ (
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat3x3<T>::row_type operator/ (
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	tmat3x3<T> operator/ (
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat3x3<T> const operator-  (
-		tmat3x3<T> const & m);
-
-	template <typename T> 
-	tmat3x3<T> const operator-- (
-		tmat3x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat3x3<T> const operator++ (
-		tmat3x3<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @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 detail::tmat3x3<lowp_float>		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 detail::tmat3x3<mediump_float>	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 detail::tmat3x3<highp_float>	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 detail::tmat3x3<lowp_float>		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 detail::tmat3x3<mediump_float>	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 detail::tmat3x3<highp_float>	highp_mat3x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x3.inl"
-#endif
-
-#endif //glm_core_type_mat3x3
diff --git a/thirdparty/glm/glm/core/type_mat3x3.inl b/thirdparty/glm/glm/core/type_mat3x3.inl
deleted file mode 100644
index d94ad05c..00000000
--- a/thirdparty/glm/glm/core/type_mat3x3.inl
+++ /dev/null
@@ -1,812 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x3.inl
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::length() const
-    {
-        return 3;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type &
-	tmat3x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type const &
-	tmat3x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
-    {
-		value_type const Zero(0);
-		value_type const One(1);
-        this->value[0] = col_type(One, Zero, Zero);
-        this->value[1] = col_type(Zero, One, Zero);
-        this->value[2] = col_type(Zero, Zero, One);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero);
-        this->value[1] = col_type(Zero, s, Zero);
-        this->value[2] = col_type(Zero, Zero, s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0, 
-        value_type const & x1, value_type const & y1, value_type const & z1,
-        value_type const & x2, value_type const & y2, value_type const & z2
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0);
-        this->value[1] = col_type(x1, y1, z1);
-        this->value[2] = col_type(x2, y2, z2);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-        this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-        this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2, 
-		typename X3, typename Y3, typename Z3>  
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3 
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-        this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x3<T>::tmat3x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2, 
-		tvec3<V3> const & v3
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Conversions
-
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x3<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-	template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
-	(
-		tmat3x3<T> const & m
-	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-        this->value[2] = m[2];
-	    return *this;
-    }
-
-    template <typename T> 
-    template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
-	(
-		tmat3x3<U> const & m
-	)
-    {
-	    this->value[0] = m[0];
-	    this->value[1] = m[1];
-        this->value[2] = m[2];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] += s;
-	    this->value[1] += s;
-        this->value[2] += s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
-	(
-		tmat3x3<U> const & m
-	)
-    {
-	    this->value[0] += m[0];
-	    this->value[1] += m[1];
-        this->value[2] += m[2];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] -= s;
-	    this->value[1] -= s;
-        this->value[2] -= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
-	(
-		tmat3x3<U> const & m
-	)
-    {
-	    this->value[0] -= m[0];
-	    this->value[1] -= m[1];
-        this->value[2] -= m[2];
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] *= s;
-	    this->value[1] *= s;
-        this->value[2] *= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
-	(
-		tmat3x3<U> const & m
-	)
-    {
-        return (*this = *this * m);
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-	    this->value[0] /= s;
-	    this->value[1] /= s;
-        this->value[2] /= s;
-	    return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
-	(
-		tmat3x3<U> const & m
-	)
-    {
-        return (*this = *this / m);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
-    {
-	    ++this->value[0];
-	    ++this->value[1];
-        ++this->value[2];
-	    return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
-    {
-	    --this->value[0];
-	    --this->value[1];
-        --this->value[2];
-	    return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
-    {
-        T S00 = value[0][0];
-        T S01 = value[0][1];
-        T S02 = value[0][2];
-
-        T S10 = value[1][0];
-        T S11 = value[1][1];
-        T S12 = value[1][2];
-
-        T S20 = value[2][0];
-        T S21 = value[2][1];
-        T S22 = value[2][2];
-/*
-        tmat3x3<T> Inverse(
-            + (S11 * S22 - S21 * S12),
-            - (S10 * S22 - S20 * S12),
-            + (S10 * S21 - S20 * S11),
-            - (S01 * S22 - S21 * S02),
-            + (S00 * S22 - S20 * S02),
-            - (S00 * S21 - S20 * S01),
-            + (S01 * S12 - S11 * S02),
-            - (S00 * S12 - S10 * S02),
-            + (S00 * S11 - S10 * S01));
-*/
-        tmat3x3<T> Inverse(
-            S11 * S22 - S21 * S12,
-            S12 * S20 - S22 * S10,
-            S10 * S21 - S20 * S11,
-            S02 * S21 - S01 * S22,
-            S00 * S22 - S02 * S20,
-            S01 * S20 - S00 * S21,
-            S12 * S01 - S11 * S02,
-            S10 * S02 - S12 * S00,
-            S11 * S00 - S10 * S01);
-
-        T Determinant = S00 * (S11 * S22 - S21 * S12)
-                      - S10 * (S01 * S22 - S21 * S02)
-                      + S20 * (S01 * S12 - S11 * S02);
-
-        Inverse /= Determinant;
-        return Inverse;
-    }
-
-    //////////////////////////////////////////////////////////////
-	// Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-    {
-        return tmat3x3<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-    {
-        return tmat3x3<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-    {
-        return tmat3x3<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-    {
-        return tmat3x3<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-    {
-        return tmat3x3<T>(
-            s - m[0],
-            s - m[1],
-            s - m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-    {
-        return tmat3x3<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-    {
-        return tmat3x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-    {
-        return tmat3x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator* 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v
-	)
-    {
-        return typename tmat3x3<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator* 
-	(
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m
-	)
-    {
-        return typename tmat3x3<T>::row_type(
-            m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
-            m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
-            m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-    {
-		typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
-		typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
-		typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
-		typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
-		typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
-		typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
-		typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
-		typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
-		typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
-
-		typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
-		typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
-		typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
-		typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
-		typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
-		typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
-		typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
-		typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
-		typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
-
-		tmat3x3<T> Result(tmat3x3<T>::null);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
-		return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat3x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::value_type const & s
-	)
-    {
-        return tmat3x3<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		typename tmat3x3<T>::value_type const & s, 
-		tmat3x3<T> const & m
-	)
-    {
-        return tmat3x3<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2]);
-    }
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator/ 
-	(
-		tmat3x3<T> const & m, 
-		typename tmat3x3<T>::row_type const & v
-	)
-	{
-		return m._inverse() * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator/ 
-	(
-		typename tmat3x3<T>::col_type const & v, 
-		tmat3x3<T> const & m
-	)
-	{
-		return v * m._inverse();
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return m1 * m2._inverse();
-	}
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator- 
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        return tmat3x3<T>(
-            -m[0], 
-            -m[1],
-            -m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator++ 
-	(
-		tmat3x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat3x3<T>(
-            m[0] + T(1),
-            m[1] + T(1),
-            m[2] + T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> const operator-- 
-	(
-		tmat3x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat3x3<T>(
-            m[0] - T(1),
-            m[1] - T(1),
-            m[2] - T(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x3<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat3x4.hpp b/thirdparty/glm/glm/core/type_mat3x4.hpp
deleted file mode 100644
index 34cf48a6..00000000
--- a/thirdparty/glm/glm/core/type_mat3x4.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x4.hpp
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat3x4
-#define glm_core_type_mat3x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat3x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec3<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat3x4<T> type;
-		typedef tmat4x3<T> transpose_type;
-
-	private:
-		// Data 
-		col_type value[3];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat3x4();
-		GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat3x4(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat3x4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tmat3x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
-		GLM_FUNC_DECL explicit tmat3x4(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x4(
-            U const & x);
-			
-		template 
-        <
-            typename X1, typename Y1, typename Z1, typename W1, 
-            typename X2, typename Y2, typename Z2, typename W2, 
-            typename X3, typename Y3, typename Z3, typename W3 
-        > 
-		GLM_FUNC_DECL explicit tmat3x4(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-            X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
-			
-		template <typename V1, typename V2, typename V3> 
-		GLM_FUNC_DECL explicit tmat3x4(
-            tvec4<V1> const & v1, 
-            tvec4<V2> const & v2,
-            tvec4<V3> const & v3);
-            
-		// Matrix conversion
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
-
-		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat3x4<T> & operator++ ();
-		GLM_FUNC_DECL tmat3x4<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat3x4<T> operator+ (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat3x4<T> operator+ (
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-	    
-	template <typename T> 
-	tmat3x4<T> operator- (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x4<T> operator- (
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-
-	template <typename T> 
-	tmat3x4<T> operator* (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x4<T> operator* (
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m);
-
-	template <typename T>
-	typename tmat3x4<T>::col_type operator* (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat3x4<T>::row_type operator* (
-		typename tmat3x4<T>::col_type const & v, 
-		tmat3x4<T> const & m);
-
-	template <typename T>
-	tmat4x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat4x3<T> const & m2);
-		
-	template <typename T>
-	tmat2x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat2x3<T> const & m2);
-		
-	template <typename T>
-	tmat3x4<T> operator* (
-		tmat3x4<T> const & m1, 
-		tmat3x3<T> const & m2);
-
-	template <typename T> 
-	tmat3x4<T> operator/ (
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat3x4<T> operator/ (
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat3x4<T> const operator-  (
-		tmat3x4<T> const & m);
-
-	template <typename T> 
-	tmat3x4<T> const operator-- (
-		tmat3x4<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat3x4<T> const operator++ (
-		tmat3x4<T> const & m, 
-		int);
-
-}//namespace detail
-
-	/// @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 detail::tmat3x4<lowp_float>		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 detail::tmat3x4<mediump_float>	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 detail::tmat3x4<highp_float>	highp_mat3x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat3x4.inl"
-#endif
-
-#endif //glm_core_type_mat3x4
diff --git a/thirdparty/glm/glm/core/type_mat3x4.inl b/thirdparty/glm/glm/core/type_mat3x4.inl
deleted file mode 100644
index caf5a8b9..00000000
--- a/thirdparty/glm/glm/core/type_mat3x4.inl
+++ /dev/null
@@ -1,718 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat3x4.inl
-/// @date 2006-08-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::length() const
-    {
-        return 3;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type & 
-	tmat3x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type const & 
-	tmat3x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4()
-    {
-        this->value[0] = col_type(1, 0, 0, 0);
-        this->value[1] = col_type(0, 1, 0, 0);
-        this->value[2] = col_type(0, 0, 1, 0);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero, Zero);
-        this->value[1] = col_type(Zero, s, Zero, Zero);
-        this->value[2] = col_type(Zero, Zero, s, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-    (
-		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-        value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0, w0);
-        this->value[1] = col_type(x1, y1, z1, w1);
-        this->value[2] = col_type(x2, y2, z2, w2);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-        this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-        this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2, 
-		typename X3, typename Y3, typename Z3, typename W3>  
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3  
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-        this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3> 
-	GLM_FUNC_DECL tmat3x4<T>::tmat3x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2, 
-		tvec4<V3> const & v3
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-	}
-
-    // Conversion
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x4<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = col_type(T(0), T(0), T(1), T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = col_type(m[2], T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = col_type(T(0), T(0), T(1), T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = col_type(m[2], T(0), T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(T(0), T(0), T(1), T(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
-        this->value[2] = col_type(m[2], detail::tvec2<T>(T(1), T(0)));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = col_type(m[2], T(0));
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
-	(
-		tmat3x4<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        this->value[2] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
-	(
-		tmat3x4<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        this->value[2] += m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        this->value[2] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
-	(
-		tmat3x4<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        this->value[2] -= m[2];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        this->value[2] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
-	(
-		tmat3x4<U> const & m
-	)
-    {
-        return (*this = tmat3x4<T>(*this * m));
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        this->value[2] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        ++this->value[2];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        --this->value[2];
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-    {
-        return tmat3x4<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-    {
-        return tmat3x4<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2]);
-    }
-
-    template <typename T> 
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-    {
-        return tmat3x4<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-    {
-        return tmat3x4<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-    {
-        return tmat3x4<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m
-	)
-    {
-        return tmat3x4<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s);
-    }
-   
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type operator* 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::row_type const & v
-	)
-    {
-        return typename tmat3x4<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
-            m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
-    }
-
-	//			X X X
-	//			X X X
-	//			X X X
-	//			X X X
-	// X X X X
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat3x4<T>::row_type operator* 
-	(
-		typename tmat3x4<T>::col_type const & v, 
-		tmat3x4<T> const & m
-	)
-    {
-		return typename tmat3x4<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
-            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
-            v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-    {
-        const T SrcA00 = m1[0][0];
-        const T SrcA01 = m1[0][1];
-        const T SrcA02 = m1[0][2];
-        const T SrcA03 = m1[0][3];
-        const T SrcA10 = m1[1][0];
-        const T SrcA11 = m1[1][1];
-        const T SrcA12 = m1[1][2];
-        const T SrcA13 = m1[1][3];
-        const T SrcA20 = m1[2][0];
-        const T SrcA21 = m1[2][1];
-        const T SrcA22 = m1[2][2];
-        const T SrcA23 = m1[2][3];
-
-        const T SrcB00 = m2[0][0];
-        const T SrcB01 = m2[0][1];
-        const T SrcB02 = m2[0][2];
-        const T SrcB10 = m2[1][0];
-        const T SrcB11 = m2[1][1];
-        const T SrcB12 = m2[1][2];
-        const T SrcB20 = m2[2][0];
-        const T SrcB21 = m2[2][1];
-        const T SrcB22 = m2[2][2];
-        const T SrcB30 = m2[3][0];
-        const T SrcB31 = m2[3][1];
-        const T SrcB32 = m2[3][2];
-
-        tmat4x4<T> Result(tmat4x4<T>::null);
-        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
-        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
-        Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
-        Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
-        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
-        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
-        Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
-        Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
-        Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
-        Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
-        Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
-        Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
-        Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
-        Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
-        Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
-        Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
-        return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat2x3<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x3<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator/ 
-	(
-		tmat3x4<T> const & m, 
-		typename tmat3x4<T>::value_type const & s
-	)
-    {
-        return tmat3x4<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> operator/
-	(
-		typename tmat3x4<T>::value_type const & s, 
-		tmat3x4<T> const & m
-	)
-    {
-        return tmat3x4<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> const operator- 
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        return tmat3x4<T>(
-            -m[0], 
-            -m[1],
-            -m[2]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> const operator++ 
-	(
-		tmat3x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat3x4<T>(
-            m[0] + T(1),
-            m[1] + T(1),
-            m[2] + T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x4<T> const operator-- 
-	(
-		tmat3x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat3x4<T>(
-            m[0] - T(1),
-            m[1] - T(1),
-            m[2] - T(1));
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat3x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat4x2.hpp b/thirdparty/glm/glm/core/type_mat4x2.hpp
deleted file mode 100644
index d6a264d3..00000000
--- a/thirdparty/glm/glm/core/type_mat4x2.hpp
+++ /dev/null
@@ -1,272 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x2.hpp
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x2
-#define glm_core_type_mat4x2
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat4x2
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec2<T> col_type;
-		typedef tvec4<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat4x2<T> type;
-		typedef tmat2x4<T> transpose_type;
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x2();
-		GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x2(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x2(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x2(
-			value_type const & x0, value_type const & y0,
-			value_type const & x1, value_type const & y1,
-			value_type const & x2, value_type const & y2,
-			value_type const & x3, value_type const & y3);
-		GLM_FUNC_DECL explicit tmat4x2(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-            
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x2(
-            U const & x);
-			
-		template 
-        <
-            typename X1, typename Y1, 
-            typename X2, typename Y2, 
-            typename X3, typename Y3,
-            typename X4, typename Y4
-        > 
-		GLM_FUNC_DECL explicit tmat4x2(
-            X1 const & x1, Y1 const & y1, 
-            X2 const & x2, Y2 const & y2,
-            X3 const & x3, Y3 const & y3,
-            X4 const & x4, Y4 const & y4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x2(
-            tvec2<V1> const & v1, 
-            tvec2<V2> const & v2,
-            tvec2<V3> const & v3,
-            tvec2<V4> const & v4);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
-			
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat4x2<T>& operator++ ();
-		GLM_FUNC_DECL tmat4x2<T>& operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat4x2<T> operator+ (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat4x2<T> operator+ (
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-	    
-	template <typename T> 
-	tmat4x2<T> operator- (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x2<T> operator- (
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2);
-
-	template <typename T> 
-	tmat4x2<T> operator* (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x2<T> operator* (
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m);
-
-	template <typename T>
-	typename tmat4x2<T>::col_type operator* (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat4x2<T>::row_type operator* (
-		typename tmat4x2<T>::col_type const & v, 
-		tmat4x2<T> const & m);
-
-	template <typename T>
-	tmat3x2<T> operator* (
-		tmat4x2<T> const & m1, 
-		tmat3x4<T> const & m2);
-		
-	template <typename T>
-	tmat4x2<T> operator* (
-		tmat4x2<T> const & m1, 
-		tmat4x4<T> const & m2);
-		
-	template <typename T>
-	tmat2x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	tmat4x2<T> operator/ (
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x2<T> operator/ (
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat4x2<T> const operator-  (
-		tmat4x2<T> const & m);
-
-	template <typename T> 
-	tmat4x2<T> const operator-- (
-		tmat4x2<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat4x2<T> const operator++ (
-		tmat4x2<T> const & m, 
-		int);
-
-} //namespace detail
-
-	/// @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 detail::tmat4x2<lowp_float>		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 detail::tmat4x2<mediump_float>	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 detail::tmat4x2<highp_float>	highp_mat4x2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x2.inl"
-#endif
-
-#endif //glm_core_type_mat4x2
diff --git a/thirdparty/glm/glm/core/type_mat4x2.inl b/thirdparty/glm/glm/core/type_mat4x2.inl
deleted file mode 100644
index 582bb3c8..00000000
--- a/thirdparty/glm/glm/core/type_mat4x2.inl
+++ /dev/null
@@ -1,729 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x2.inl
-/// @date 2006-10-01 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::length() const
-    {
-        return 4;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
-	{
-		return 2;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type & 
-	tmat4x2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type const & 
-	tmat4x2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2()
-    {
-		value_type const Zero(0);
-		value_type const One(1);
-        this->value[0] = col_type(One, Zero);
-        this->value[1] = col_type(Zero, One);
-        this->value[2] = col_type(Zero, Zero);
-        this->value[3] = col_type(Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-        this->value[3] = m.value[3];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero);
-        this->value[1] = col_type(Zero, s);
-        this->value[2] = col_type(Zero, Zero);
-        this->value[3] = col_type(Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-    (
-        value_type const & x0, value_type const & y0,
-        value_type const & x1, value_type const & y1,
-        value_type const & x2, value_type const & y2,
-        value_type const & x3, value_type const & y3
-    )
-    {
-        this->value[0] = col_type(x0, y0);
-        this->value[1] = col_type(x1, y1);
-        this->value[2] = col_type(x2, y2);
-        this->value[3] = col_type(x3, y3);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2,
-        col_type const & v3
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-        this->value[3] = v3;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec2<T>(value_type(s), Zero);
-        this->value[1] = tvec2<T>(Zero, value_type(s));
-        this->value[2] = tvec2<T>(Zero, Zero);
-        this->value[3] = tvec2<T>(Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, 
-		typename X2, typename Y2, 
-		typename X3, typename Y3, 
-		typename X4, typename Y4>  
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		X1 const & x1, Y1 const & y1, 
-		X2 const & x2, Y2 const & y2,
-		X3 const & x3, Y3 const & y3,
-		X4 const & x4, Y4 const & y4
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1));
-        this->value[1] = col_type(value_type(x2), value_type(y2));
-        this->value[2] = col_type(value_type(x3), value_type(y3));
-		this->value[3] = col_type(value_type(x4), value_type(y4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x2<T>::tmat4x2
-	(
-		tvec2<V1> const & v1, 
-		tvec2<V2> const & v2, 
-		tvec2<V3> const & v3,
-		tvec2<V4> const & v4
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-    // Conversion
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x2<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(value_type(0));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(value_type(0));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(value_type(0));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(value_type(0));
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
-	(
-		tmat4x2<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        this->value[2] += s;
-        this->value[3] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
-	(
-		tmat4x2<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        this->value[2] += m[2];
-        this->value[3] += m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        this->value[2] -= s;
-        this->value[3] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
-	(
-		tmat4x2<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        this->value[2] -= m[2];
-        this->value[3] -= m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        this->value[2] *= s;
-        this->value[3] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
-	(
-		tmat4x2<U> const & m
-	)
-    {
-        return (*this = tmat4x2<T>(*this * m));
-    }
-
-    template <typename T>
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        this->value[2] /= s;
-        this->value[3] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        ++this->value[2];
-        ++this->value[3];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        --this->value[2];
-        --this->value[3];
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-    {
-        return tmat4x2<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s,
-            m[3] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
-	(	
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-    {
-        return tmat4x2<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2],
-            m1[3] + m2[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-    {
-        return tmat4x2<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s,
-            m[3] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
-	(	
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-    {
-        return tmat4x2<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2],
-            m1[3] - m2[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-    {
-        return tmat4x2<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m
-	)
-    {
-        return tmat4x2<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type operator* 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::row_type const & v)
-    {
-        return typename tmat4x2<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x2<T>::row_type operator* 
-	(
-		typename tmat4x2<T>::col_type const & v, 
-		tmat4x2<T> const & m) 
-    {
-        return typename tmat4x2<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1],
-            v.x * m[1][0] + v.y * m[1][1],
-            v.x * m[2][0] + v.y * m[2][1],
-            v.x * m[3][0] + v.y * m[3][1]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-    {
-        T const SrcA00 = m1[0][0];
-        T const SrcA01 = m1[0][1];
-        T const SrcA10 = m1[1][0];
-        T const SrcA11 = m1[1][1];
-        T const SrcA20 = m1[2][0];
-        T const SrcA21 = m1[2][1];
-        T const SrcA30 = m1[3][0];
-        T const SrcA31 = m1[3][1];
-
-        T const SrcB00 = m2[0][0];
-        T const SrcB01 = m2[0][1];
-        T const SrcB02 = m2[0][2];
-        T const SrcB03 = m2[0][3];
-        T const SrcB10 = m2[1][0];
-        T const SrcB11 = m2[1][1];
-        T const SrcB12 = m2[1][2];
-        T const SrcB13 = m2[1][3];
-
-        tmat2x2<T> Result(tmat2x2<T>::null);
-        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
-        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
-        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
-        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
-        return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x2<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
-	(
-		tmat4x2<T> const & m, 
-		typename tmat4x2<T>::value_type const & s
-	)
-    {
-        return tmat4x2<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s,
-            m[3] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
-	(
-		typename tmat4x2<T>::value_type const & s, 
-		tmat4x2<T> const & m
-	)
-    {
-        return tmat4x2<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2],
-            s / m[3]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> const operator- 
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        return tmat4x2<T>(
-            -m[0], 
-            -m[1], 
-            -m[2], 
-            -m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> const operator++ 
-	(
-		tmat4x2<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x2<T>(
-			m[0] + typename tmat4x2<T>::value_type(1),
-            m[1] + typename tmat4x2<T>::value_type(1),
-            m[2] + typename tmat4x2<T>::value_type(1),
-            m[3] + typename tmat4x2<T>::value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x2<T> const operator-- 
-	(
-		tmat4x2<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x2<T>(
-            m[0] - typename tmat4x2<T>::value_type(1),
-            m[1] - typename tmat4x2<T>::value_type(1),
-            m[2] - typename tmat4x2<T>::value_type(1),
-            m[3] - typename tmat4x2<T>::value_type(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x2<T> const & m1, 
-		tmat4x2<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_mat4x3.hpp b/thirdparty/glm/glm/core/type_mat4x3.hpp
deleted file mode 100644
index aaf8f1cd..00000000
--- a/thirdparty/glm/glm/core/type_mat4x3.hpp
+++ /dev/null
@@ -1,270 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x3.hpp
-/// @date 2006-08-04 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x3
-#define glm_core_type_mat4x3
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat4x3
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec3<T> col_type;
-		typedef tvec4<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat4x3<T> type;
-		typedef tmat3x4<T> transpose_type;
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x3();
-		GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x3(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x3(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x3(
-			value_type const & x0, value_type const & y0, value_type const & z0,
-			value_type const & x1, value_type const & y1, value_type const & z1,
-			value_type const & x2, value_type const & y2, value_type const & z2,
-			value_type const & x3, value_type const & y3, value_type const & z3);
-		GLM_FUNC_DECL explicit tmat4x3(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-            col_type const & v3);
-            
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x3(
-            U const & x);
-			
-		template <
-            typename X1, typename Y1, typename Z1, 
-            typename X2, typename Y2, typename Z2, 
-            typename X3, typename Y3, typename Z3, 
-            typename X4, typename Y4, typename Z4> 
-		GLM_FUNC_DECL explicit tmat4x3(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, 
-            X3 const & x3, Y3 const & y3, Z3 const & z3, 
-            X4 const & x4, Y4 const & y4, Z4 const & z4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x3(
-            tvec3<V1> const & v1, 
-            tvec3<V2> const & v2,
-            tvec3<V3> const & v3,
-            tvec3<V4> const & v4);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
-			
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
-
-		// Accesses
-		col_type & operator[](size_type i);
-		col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
-		template <typename U> 
-		GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
-
-		GLM_FUNC_DECL tmat4x3<T> & operator++ ();
-		GLM_FUNC_DECL tmat4x3<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat4x3<T> operator+ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-	    
-	template <typename T> 
-	tmat4x3<T> operator+ (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-	    
-	template <typename T> 
-	tmat4x3<T> operator- (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x3<T> operator- (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2);
-
-	template <typename T> 
-	tmat4x3<T> operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x3<T> operator* (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m);
-
-	template <typename T>
-	typename tmat4x3<T>::col_type operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat4x3<T>::row_type operator* (
-		typename tmat4x3<T>::col_type const & v, 
-		tmat4x3<T> const & m);
-
-	template <typename T> 
-	tmat2x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T> 
-	tmat3x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat3x4<T> const & m2);
-		
-	template <typename T>
-	tmat4x3<T> operator* (
-		tmat4x3<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	tmat4x3<T> operator/ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x3<T> operator/ (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat4x3<T> const operator- (
-		tmat4x3<T> const & m);
-
-	template <typename T> 
-	tmat4x3<T> const operator-- (
-		tmat4x3<T> const & m, 
-		int);
-
-	template <typename T> 
-	tmat4x3<T> const operator++ (
-		tmat4x3<T> const & m, 
-		int);
-
-}//namespace detail
-
-	/// @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 detail::tmat4x3<lowp_float>		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 detail::tmat4x3<mediump_float>	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 detail::tmat4x3<highp_float>	highp_mat4x3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x3.inl"
-#endif //GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x3
diff --git a/thirdparty/glm/glm/core/type_mat4x3.inl b/thirdparty/glm/glm/core/type_mat4x3.inl
deleted file mode 100644
index badd92eb..00000000
--- a/thirdparty/glm/glm/core/type_mat4x3.inl
+++ /dev/null
@@ -1,738 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x3.inl
-/// @date 2006-04-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::length() const
-    {
-        return 4;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::col_size()
-	{
-		return 3;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type & 
-	tmat4x3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type const & 
-	tmat4x3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3()
-    {
-		value_type const Zero(0);
-		value_type const One(1);
-        this->value[0] = col_type(One, Zero, Zero);
-        this->value[1] = col_type(Zero, One, Zero);
-        this->value[2] = col_type(Zero, Zero, One);
-        this->value[3] = col_type(Zero, Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-        this->value[3] = m.value[3];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero);
-        this->value[1] = col_type(Zero, s, Zero);
-        this->value[2] = col_type(Zero, Zero, s);
-        this->value[3] = col_type(Zero, Zero, Zero);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0,
-        value_type const & x1, value_type const & y1, value_type const & z1,
-        value_type const & x2, value_type const & y2, value_type const & z2,
-        value_type const & x3, value_type const & y3, value_type const & z3
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0);
-        this->value[1] = col_type(x1, y1, z1);
-        this->value[2] = col_type(x2, y2, z2);
-        this->value[3] = col_type(x3, y3, z3);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2,
-        col_type const & v3
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-        this->value[3] = v3;
-    }
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		U const & s
-	)
-	{
-		value_type const Zero(0);
-        this->value[0] = tvec3<T>(value_type(s), Zero, Zero);
-        this->value[1] = tvec3<T>(Zero, value_type(s), Zero);
-        this->value[2] = tvec3<T>(Zero, Zero, value_type(s));
-        this->value[3] = tvec3<T>(Zero, Zero, Zero);
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, 
-		typename X2, typename Y2, typename Z2, 
-		typename X3, typename Y3, typename Z3, 
-		typename X4, typename Y4, typename Z4>  
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, 
-		X4 const & x4, Y4 const & y4, Z4 const & z4
-	)		
-	{
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2));
-        this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3));
-		this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x3<T>::tmat4x3
-	(
-		tvec3<V1> const & v1, 
-		tvec3<V2> const & v2, 
-		tvec3<V3> const & v3,
-		tvec3<V4> const & v4
-	)		
-	{
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Matrix conversions
-
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x3<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
-        this->value[3] = col_type(value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(1));
-        this->value[3] = col_type(m[3], value_type(0));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(value_type(0));
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Unary updatable operators
-
-	template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
-	(
-		tmat4x3<U> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        this->value[2] += s;
-        this->value[3] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
-	(
-		tmat4x3<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        this->value[2] += m[2];
-        this->value[3] += m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        this->value[2] -= s;
-        this->value[3] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
-	(
-		tmat4x3<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        this->value[2] -= m[2];
-        this->value[3] -= m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        this->value[2] *= s;
-        this->value[3] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
-	(
-		tmat4x3<U> const & m
-	)
-    {
-        return (*this = tmat4x3<T>(*this * m));
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        this->value[2] /= s;
-        this->value[3] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        ++this->value[2];
-        ++this->value[3];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        --this->value[2];
-        --this->value[3];
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Binary operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-    {
-        return tmat4x3<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s,
-            m[3] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2)
-    {
-        return tmat4x3<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2],
-            m1[3] + m2[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-    {
-        return tmat4x3<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s,
-            m[3] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2)
-    {
-        return tmat4x3<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2],
-            m1[3] - m2[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s)
-    {
-        return tmat4x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m)
-    {
-        return tmat4x3<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-   
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type operator* 
-	(
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::row_type const & v)
-    {
-        return typename tmat4x3<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x3<T>::row_type operator* 
-	(
-		typename tmat4x3<T>::col_type const & v, 
-		tmat4x3<T> const & m) 
-    {
-        return typename tmat4x3<T>::row_type(
-            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
-            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
-            v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
-            v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-    {
-        T const SrcA00 = m1[0][0];
-        T const SrcA01 = m1[0][1];
-        T const SrcA02 = m1[0][2];
-        T const SrcA10 = m1[1][0];
-		T const SrcA11 = m1[1][1];
-        T const SrcA12 = m1[1][2];
-        T const SrcA20 = m1[2][0];
-        T const SrcA21 = m1[2][1];
-        T const SrcA22 = m1[2][2];
-        T const SrcA30 = m1[3][0];
-        T const SrcA31 = m1[3][1];
-        T const SrcA32 = m1[3][2];
-
-        T const SrcB00 = m2[0][0];
-        T const SrcB01 = m2[0][1];
-        T const SrcB02 = m2[0][2];
-        T const SrcB03 = m2[0][3];
-        T const SrcB10 = m2[1][0];
-        T const SrcB11 = m2[1][1];
-        T const SrcB12 = m2[1][2];
-        T const SrcB13 = m2[1][3];
-        T const SrcB20 = m2[2][0];
-        T const SrcB21 = m2[2][1];
-        T const SrcB22 = m2[2][2];
-        T const SrcB23 = m2[2][3];
-
-        tmat3x3<T> Result(tmat3x3<T>::null);
-        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
-        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
-        Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
-        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
-        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
-        Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
-        Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
-        Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
-        Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
-        return Result;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x3<T> operator* 
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return tmat4x3<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1] + m1[2][0] * m2[3][2] + m1[3][0] * m2[3][3],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1] + m1[2][1] * m2[3][2] + m1[3][1] * m2[3][3],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1] + m1[2][2] * m2[3][2] + m1[3][2] * m2[3][3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
-	(
-		tmat4x3<T> const & m, 
-		typename tmat4x3<T>::value_type const & s
-	)
-    {
-        return tmat4x3<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s,
-            m[3] / s);        
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
-	(
-		typename tmat4x3<T>::value_type const & s, 
-		tmat4x3<T> const & m
-	)
-    {
-        return tmat4x3<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2],
-            s / m[3]);        
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> const operator- 
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        return tmat4x3<T>(
-            -m[0], 
-            -m[1],
-            -m[2],
-            -m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> const operator++ 
-	(
-		tmat4x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x3<T>(
-            m[0] + T(1),
-            m[1] + T(1),
-            m[2] + T(1),
-            m[3] + T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x3<T> const operator-- 
-	(
-		tmat4x3<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x3<T>(
-            m[0] - T(1),
-            m[1] - T(1),
-            m[2] - T(1),
-            m[3] - T(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x3<T> const & m1, 
-		tmat4x3<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-
-} //namespace detail
-} //namespace glm
-
diff --git a/thirdparty/glm/glm/core/type_mat4x4.hpp b/thirdparty/glm/glm/core/type_mat4x4.hpp
deleted file mode 100644
index 5599a206..00000000
--- a/thirdparty/glm/glm/core/type_mat4x4.hpp
+++ /dev/null
@@ -1,321 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x4.hpp
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_mat4x4
-#define glm_core_type_mat4x4
-
-#include "type_mat.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-	template <typename T> struct tmat2x2;
-	template <typename T> struct tmat2x3;
-	template <typename T> struct tmat2x4;
-	template <typename T> struct tmat3x2;
-	template <typename T> struct tmat3x3;
-	template <typename T> struct tmat3x4;
-	template <typename T> struct tmat4x2;
-	template <typename T> struct tmat4x3;
-	template <typename T> struct tmat4x4;
-
-	// \brief Template for 4 * 4 matrix of floating-point numbers.
-	// \ingroup core_template
-	template <typename T> 
-	struct tmat4x4
-	{
-		enum ctor{null};
-		typedef T value_type;
-		typedef std::size_t size_type;
-		typedef tvec4<T> col_type;
-		typedef tvec4<T> row_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type col_size();
-		static GLM_FUNC_DECL size_type row_size();
-
-		typedef tmat4x4<T> type;
-		typedef tmat4x4<T> transpose_type;
-
-	public:
-		/// Implementation detail
-        /// @cond DETAIL
-		GLM_FUNC_DECL tmat4x4<T> _inverse() const;
-        /// @endcond
-
-	private:
-		// Data 
-		col_type value[4];
-
-	public:
-		// Constructors
-		GLM_FUNC_DECL tmat4x4();
-		GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
-
-		GLM_FUNC_DECL explicit tmat4x4(
-			ctor Null);
-		GLM_FUNC_DECL explicit tmat4x4(
-			value_type const & x);
-		GLM_FUNC_DECL explicit tmat4x4(
-			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
-			value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
-		GLM_FUNC_DECL explicit tmat4x4(
-			col_type const & v0, 
-			col_type const & v1,
-			col_type const & v2,
-			col_type const & v3);
-
-		//////////////////////////////////////
-		// Conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x4(
-            U const & x);
-			
-		template <
-            typename X1, typename Y1, typename Z1, typename W1, 
-            typename X2, typename Y2, typename Z2, typename W2, 
-            typename X3, typename Y3, typename Z3, typename W3, 
-            typename X4, typename Y4, typename Z4, typename W4> 
-		GLM_FUNC_DECL explicit tmat4x4(
-            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-            X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
-            X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
-			
-		template <typename V1, typename V2, typename V3, typename V4> 
-		GLM_FUNC_DECL explicit tmat4x4(
-            tvec4<V1> const & v1, 
-            tvec4<V2> const & v2,
-            tvec4<V3> const & v3,
-            tvec4<V4> const & v4);
-            
-		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
-
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
-
-		// Accesses
-		GLM_FUNC_DECL col_type & operator[](size_type i);
-		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-		// Unary updatable operators
-		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
-		GLM_FUNC_DECL tmat4x4<T> & operator++ ();
-		GLM_FUNC_DECL tmat4x4<T> & operator-- ();
-	};
-
-	// Binary operators
-	template <typename T> 
-	tmat4x4<T> operator+ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x4<T> operator+ (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	tmat4x4<T> operator+ (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-	    
-	template <typename T> 
-	tmat4x4<T> operator- (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x4<T> operator- (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	tmat4x4<T> operator- (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	tmat4x4<T> operator* (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x4<T> operator* (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	typename tmat4x4<T>::col_type operator* (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat4x4<T>::row_type operator* (
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m);
-		
-	template <typename T>
-	tmat2x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat2x4<T> const & m2);
-
-	template <typename T>
-	tmat3x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat3x4<T> const & m2);
-
-	template <typename T> 
-	tmat4x4<T> operator* (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	template <typename T> 
-	tmat4x4<T> operator/ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s);
-
-	template <typename T> 
-	tmat4x4<T> operator/ (
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	typename tmat4x4<T>::col_type operator/ (
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v);
-
-	template <typename T> 
-	typename tmat4x4<T>::row_type operator/ (
-		typename tmat4x4<T>::col_type & v, 
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	tmat4x4<T> operator/ (
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2);
-
-	// Unary constant operators
-	template <typename T> 
-	tmat4x4<T> const operator-  (
-		tmat4x4<T> const & m);
-
-	template <typename T> 
-	tmat4x4<T> const operator-- (
-		tmat4x4<T> const & m, int);
-
-	template <typename T> 
-	tmat4x4<T> const operator++ (
-		tmat4x4<T> const & m, int);
-
-} //namespace detail
-
-	/// @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 detail::tmat4x4<lowp_float>		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 detail::tmat4x4<mediump_float>	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 detail::tmat4x4<highp_float>	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 detail::tmat4x4<lowp_float>		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 detail::tmat4x4<mediump_float>	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 detail::tmat4x4<highp_float>	highp_mat4x4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat4x4.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_mat4x4
diff --git a/thirdparty/glm/glm/core/type_mat4x4.inl b/thirdparty/glm/glm/core/type_mat4x4.inl
deleted file mode 100644
index 47cc30a6..00000000
--- a/thirdparty/glm/glm/core/type_mat4x4.inl
+++ /dev/null
@@ -1,905 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_mat4x4.inl
-/// @date 2005-01-27 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::length() const
-    {
-        return 4;
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::col_size()
-	{
-		return 4;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::row_size()
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type & 
-	tmat4x4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type const & 
-	tmat4x4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-    //////////////////////////////////////////////////////////////
-    // Constructors
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4()
-    {
-		value_type Zero(0);
-		value_type One(1);
-        this->value[0] = col_type(One, Zero, Zero, Zero);
-        this->value[1] = col_type(Zero, One, Zero, Zero);
-        this->value[2] = col_type(Zero, Zero, One, Zero);
-        this->value[3] = col_type(Zero, Zero, Zero, One);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        this->value[0] = m.value[0];
-        this->value[1] = m.value[1];
-        this->value[2] = m.value[2];
-        this->value[3] = m.value[3];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		ctor
-	)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		value_type const & s
-	)
-    {
-		value_type const Zero(0);
-        this->value[0] = col_type(s, Zero, Zero, Zero);
-        this->value[1] = col_type(Zero, s, Zero, Zero);
-        this->value[2] = col_type(Zero, Zero, s, Zero);
-        this->value[3] = col_type(Zero, Zero, Zero, s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-    (
-        value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-        value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
-        value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3
-    )
-    {
-        this->value[0] = col_type(x0, y0, z0, w0);
-        this->value[1] = col_type(x1, y1, z1, w1);
-        this->value[2] = col_type(x2, y2, z2, w2);
-        this->value[3] = col_type(x3, y3, z3, w3);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-    (
-        col_type const & v0, 
-        col_type const & v1, 
-        col_type const & v2,
-        col_type const & v3
-    )
-    {
-        this->value[0] = v0;
-        this->value[1] = v1;
-        this->value[2] = v2;
-        this->value[3] = v3;
-    }
-
-    template <typename T> 
-    template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        this->value[0] = col_type(m[0]);
-        this->value[1] = col_type(m[1]);
-        this->value[2] = col_type(m[2]);
-        this->value[3] = col_type(m[3]);
-	}
-
-	//////////////////////////////////////
-	// Convertion constructors
-	template <typename T> 
-	template <typename U> 
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		U const & s
-	)
-	{
-		GLM_STATIC_ASSERT(detail::type<U>::is_float || std::numeric_limits<U>::is_integer, "*mat4x4 constructor only takes float and integer types");
-
-		value_type const Zero(0);
-        this->value[0] = tvec4<T>(value_type(s), Zero, Zero, Zero);
-        this->value[1] = tvec4<T>(Zero, value_type(s), Zero, Zero);
-        this->value[2] = tvec4<T>(Zero, Zero, value_type(s), Zero);
-        this->value[3] = tvec4<T>(Zero, Zero, Zero, value_type(s));
-	}
-	
-	template <typename T> 
-	template <
-		typename X1, typename Y1, typename Z1, typename W1, 
-		typename X2, typename Y2, typename Z2, typename W2, 
-		typename X3, typename Y3, typename Z3, typename W3, 
-		typename X4, typename Y4, typename Z4, typename W4>  
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-		X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-		X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
-		X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4
-	)		
-	{
-		GLM_STATIC_ASSERT(detail::type<X1>::is_float || std::numeric_limits<X1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y1>::is_float || std::numeric_limits<Y1>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z1>::is_float || std::numeric_limits<Z1>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W1>::is_float || std::numeric_limits<W1>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X2>::is_float || std::numeric_limits<X2>::is_integer, "*mat4x4 constructor only takes float and integer types, 5th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y2>::is_float || std::numeric_limits<Y2>::is_integer, "*mat4x4 constructor only takes float and integer types, 6th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z2>::is_float || std::numeric_limits<Z2>::is_integer, "*mat4x4 constructor only takes float and integer types, 7th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W2>::is_float || std::numeric_limits<W2>::is_integer, "*mat4x4 constructor only takes float and integer types, 8th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X3>::is_float || std::numeric_limits<X3>::is_integer, "*mat4x4 constructor only takes float and integer types, 9th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y3>::is_float || std::numeric_limits<Y3>::is_integer, "*mat4x4 constructor only takes float and integer types, 10th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z3>::is_float || std::numeric_limits<Z3>::is_integer, "*mat4x4 constructor only takes float and integer types, 11th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W3>::is_float || std::numeric_limits<W3>::is_integer, "*mat4x4 constructor only takes float and integer types, 12th parameter type invalid.");
-
-		GLM_STATIC_ASSERT(detail::type<X4>::is_float || std::numeric_limits<X4>::is_integer, "*mat4x4 constructor only takes float and integer types, 13th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Y4>::is_float || std::numeric_limits<Y4>::is_integer, "*mat4x4 constructor only takes float and integer types, 14th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<Z4>::is_float || std::numeric_limits<Z4>::is_integer, "*mat4x4 constructor only takes float and integer types, 15th parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<W4>::is_float || std::numeric_limits<W4>::is_integer, "*mat4x4 constructor only takes float and integer types, 16th parameter type invalid.");
-
-        this->value[0] = col_type(value_type(x1), value_type(y1), value_type(z1), value_type(w1));
-        this->value[1] = col_type(value_type(x2), value_type(y2), value_type(z2), value_type(w2));
-        this->value[2] = col_type(value_type(x3), value_type(y3), value_type(z3), value_type(w3));
-		this->value[3] = col_type(value_type(x4), value_type(y4), value_type(z4), value_type(w4));
-	}
-	
-	template <typename T> 
-	template <typename V1, typename V2, typename V3, typename V4> 
-	GLM_FUNC_DECL tmat4x4<T>::tmat4x4
-	(
-		tvec4<V1> const & v1, 
-		tvec4<V2> const & v2, 
-		tvec4<V3> const & v3,
-		tvec4<V4> const & v4
-	)		
-	{
-		GLM_STATIC_ASSERT(detail::type<V1>::is_float || std::numeric_limits<V1>::is_integer, "*mat4x4 constructor only takes float and integer types, 1st parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V2>::is_float || std::numeric_limits<V2>::is_integer, "*mat4x4 constructor only takes float and integer types, 2nd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V3>::is_float || std::numeric_limits<V3>::is_integer, "*mat4x4 constructor only takes float and integer types, 3rd parameter type invalid.");
-		GLM_STATIC_ASSERT(detail::type<V4>::is_float || std::numeric_limits<V4>::is_integer, "*mat4x4 constructor only takes float and integer types, 4th parameter type invalid.");
-
-        this->value[0] = col_type(v1);
-        this->value[1] = col_type(v2);
-        this->value[2] = col_type(v3);
-		this->value[3] = col_type(v4);
-	}
-
-	//////////////////////////////////////
-	// Matrix convertion constructors
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = col_type(value_type(0));
-        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(m[2], value_type(0));
-        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-    }
-
-	template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], value_type(0));
-        this->value[1] = col_type(m[1], value_type(0));
-        this->value[2] = col_type(value_type(0));
-        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = col_type(m[2], detail::tvec2<T>(0));
-        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat2x4<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = col_type(T(0));
-        this->value[3] = col_type(T(0), T(0), T(0), T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x2<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
-        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
-        this->value[2] = col_type(T(0));
-        this->value[3] = col_type(T(0), T(0), T(0), T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat3x4<T> const & m
-	)
-    {
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = col_type(T(0), T(0), T(0), T(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
-	(
-		tmat4x3<T> const & m
-	)
-    {
-        this->value[0] = col_type(m[0], T(0));
-        this->value[1] = col_type(m[1], T(0));
-        this->value[2] = col_type(m[2], T(0));
-        this->value[3] = col_type(m[3], T(1));
-    }
-
-    //////////////////////////////////////////////////////////////
-    // Operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        //memcpy could be faster
-        //memcpy(&this->value, &m.value, 16 * sizeof(valType));
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        //memcpy could be faster
-        //memcpy(&this->value, &m.value, 16 * sizeof(valType));
-        this->value[0] = m[0];
-        this->value[1] = m[1];
-        this->value[2] = m[2];
-        this->value[3] = m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] += s;
-        this->value[1] += s;
-        this->value[2] += s;
-        this->value[3] += s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        this->value[0] += m[0];
-        this->value[1] += m[1];
-        this->value[2] += m[2];
-        this->value[3] += m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] -= s;
-        this->value[1] -= s;
-        this->value[2] -= s;
-        this->value[3] -= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U>
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        this->value[0] -= m[0];
-        this->value[1] -= m[1];
-        this->value[2] -= m[2];
-        this->value[3] -= m[3];
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U>
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] *= s;
-        this->value[1] *= s;
-        this->value[2] *= s;
-        this->value[3] *= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U>
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        return (*this = *this * m);
-    }
-
-    template <typename T> 
-	template <typename U>
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
-	(
-		U const & s
-	)
-    {
-        this->value[0] /= s;
-        this->value[1] /= s;
-        this->value[2] /= s;
-        this->value[3] /= s;
-        return *this;
-    }
-
-    template <typename T> 
-	template <typename U>
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
-	(
-		tmat4x4<U> const & m
-	)
-    {
-        return (*this = *this / m);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator++ ()
-    {
-        ++this->value[0];
-        ++this->value[1];
-        ++this->value[2];
-        ++this->value[3];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-- ()
-    {
-        --this->value[0];
-        --this->value[1];
-        --this->value[2];
-        --this->value[3];
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> tmat4x4<T>::_inverse() const
-    {
-        // Calculate all mat2 determinants
-        value_type SubFactor00 = this->value[2][2] * this->value[3][3] - this->value[3][2] * this->value[2][3];
-        value_type SubFactor01 = this->value[2][1] * this->value[3][3] - this->value[3][1] * this->value[2][3];
-        value_type SubFactor02 = this->value[2][1] * this->value[3][2] - this->value[3][1] * this->value[2][2];
-        value_type SubFactor03 = this->value[2][0] * this->value[3][3] - this->value[3][0] * this->value[2][3];
-        value_type SubFactor04 = this->value[2][0] * this->value[3][2] - this->value[3][0] * this->value[2][2];
-        value_type SubFactor05 = this->value[2][0] * this->value[3][1] - this->value[3][0] * this->value[2][1];
-        value_type SubFactor06 = this->value[1][2] * this->value[3][3] - this->value[3][2] * this->value[1][3];
-        value_type SubFactor07 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
-        value_type SubFactor08 = this->value[1][1] * this->value[3][2] - this->value[3][1] * this->value[1][2];
-        value_type SubFactor09 = this->value[1][0] * this->value[3][3] - this->value[3][0] * this->value[1][3];
-        value_type SubFactor10 = this->value[1][0] * this->value[3][2] - this->value[3][0] * this->value[1][2];
-        value_type SubFactor11 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
-        value_type SubFactor12 = this->value[1][0] * this->value[3][1] - this->value[3][0] * this->value[1][1];
-        value_type SubFactor13 = this->value[1][2] * this->value[2][3] - this->value[2][2] * this->value[1][3];
-        value_type SubFactor14 = this->value[1][1] * this->value[2][3] - this->value[2][1] * this->value[1][3];
-        value_type SubFactor15 = this->value[1][1] * this->value[2][2] - this->value[2][1] * this->value[1][2];
-        value_type SubFactor16 = this->value[1][0] * this->value[2][3] - this->value[2][0] * this->value[1][3];
-        value_type SubFactor17 = this->value[1][0] * this->value[2][2] - this->value[2][0] * this->value[1][2];
-        value_type SubFactor18 = this->value[1][0] * this->value[2][1] - this->value[2][0] * this->value[1][1];
-/*
-        tmat4x4<T> Inverse(
-            + (this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02),
-            - (this->value[1][0] * SubFactor00 - this->value[1][2] * SubFactor03 + this->value[1][3] * SubFactor04),
-            + (this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05),
-            - (this->value[1][0] * SubFactor02 - this->value[1][1] * SubFactor04 + this->value[1][2] * SubFactor05),
-
-            - (this->value[0][1] * SubFactor00 - this->value[0][2] * SubFactor01 + this->value[0][3] * SubFactor02),
-            + (this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04),
-            - (this->value[0][0] * SubFactor01 - this->value[0][1] * SubFactor03 + this->value[0][3] * SubFactor05),
-            + (this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05),
-
-            + (this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08),
-            - (this->value[0][0] * SubFactor06 - this->value[0][2] * SubFactor09 + this->value[0][3] * SubFactor10),
-            + (this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12),
-            - (this->value[0][0] * SubFactor08 - this->value[0][1] * SubFactor10 + this->value[0][2] * SubFactor12),
-
-            - (this->value[0][1] * SubFactor13 - this->value[0][2] * SubFactor14 + this->value[0][3] * SubFactor15),
-            + (this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17),
-            - (this->value[0][0] * SubFactor14 - this->value[0][1] * SubFactor16 + this->value[0][3] * SubFactor18),
-            + (this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18));
-*/
-        tmat4x4<T> Inverse(
-            + this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02,
-            - this->value[1][0] * SubFactor00 + this->value[1][2] * SubFactor03 - this->value[1][3] * SubFactor04,
-            + this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05,
-            - this->value[1][0] * SubFactor02 + this->value[1][1] * SubFactor04 - this->value[1][2] * SubFactor05,
-
-            - this->value[0][1] * SubFactor00 + this->value[0][2] * SubFactor01 - this->value[0][3] * SubFactor02,
-            + this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04,
-            - this->value[0][0] * SubFactor01 + this->value[0][1] * SubFactor03 - this->value[0][3] * SubFactor05,
-            + this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05,
-
-            + this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08,
-            - this->value[0][0] * SubFactor06 + this->value[0][2] * SubFactor09 - this->value[0][3] * SubFactor10,
-            + this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12,
-            - this->value[0][0] * SubFactor08 + this->value[0][1] * SubFactor10 - this->value[0][2] * SubFactor12,
-
-            - this->value[0][1] * SubFactor13 + this->value[0][2] * SubFactor14 - this->value[0][3] * SubFactor15,
-            + this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17,
-            - this->value[0][0] * SubFactor14 + this->value[0][1] * SubFactor16 - this->value[0][3] * SubFactor18,
-            + this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18);
-
-        value_type Determinant = 
-			+ this->value[0][0] * Inverse[0][0] 
-			+ this->value[0][1] * Inverse[1][0] 
-			+ this->value[0][2] * Inverse[2][0] 
-			+ this->value[0][3] * Inverse[3][0];
-
-        Inverse /= Determinant;
-        return Inverse;
-    }
-
-	// Binary operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-    {
-        return tmat4x4<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s,
-            m[3] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-    {
-        return tmat4x4<T>(
-            m[0] + s,
-            m[1] + s,
-            m[2] + s,
-            m[3] + s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-    {
-        return tmat4x4<T>(
-            m1[0] + m2[0],
-            m1[1] + m2[1],
-            m1[2] + m2[2],
-            m1[3] + m2[3]);
-    }
-    
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-    {
-        return tmat4x4<T>(
-            m[0] - s,
-            m[1] - s,
-            m[2] - s,
-            m[3] - s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-    {
-        return tmat4x4<T>(
-            s - m[0],
-            s - m[1],
-            s - m[2],
-            s - m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-    {
-        return tmat4x4<T>(
-            m1[0] - m2[0],
-            m1[1] - m2[1],
-            m1[2] - m2[2],
-            m1[3] - m2[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const  & s
-	)
-    {
-        return tmat4x4<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-    {
-        return tmat4x4<T>(
-            m[0] * s,
-            m[1] * s,
-            m[2] * s,
-            m[3] * s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator* 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v
-	)
-    {
-        return typename tmat4x4<T>::col_type(
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w,
-            m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z + m[3][3] * v.w);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator* 
-	(
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m
-	)
-    {
-        return typename tmat4x4<T>::row_type(
-            m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w,
-            m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
-            m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
-            m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w);
-    }
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat2x4<T> const & m2
-	)
-	{
-		return tmat2x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat3x4<T> const & m2
-	)
-	{
-		return tmat3x4<T>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2] + m1[3][0] * m2[0][3],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2] + m1[3][1] * m2[0][3],
-			m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2] + m1[3][2] * m2[0][3],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1] + m1[2][3] * m2[0][2] + m1[3][3] * m2[0][3],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2] + m1[3][0] * m2[1][3],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2] + m1[3][1] * m2[1][3],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2] + m1[3][2] * m2[1][3],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1] + m1[2][3] * m2[1][2] + m1[3][3] * m2[1][3],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2] + m1[3][0] * m2[2][3],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2] + m1[3][1] * m2[2][3],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2] + m1[3][2] * m2[2][3],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1] + m1[2][3] * m2[2][2] + m1[3][3] * m2[2][3]);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-    {
-		typename tmat4x4<T>::col_type const SrcA0 = m1[0];
-		typename tmat4x4<T>::col_type const SrcA1 = m1[1];
-		typename tmat4x4<T>::col_type const SrcA2 = m1[2];
-		typename tmat4x4<T>::col_type const SrcA3 = m1[3];
-
-		typename tmat4x4<T>::col_type const SrcB0 = m2[0];
-		typename tmat4x4<T>::col_type const SrcB1 = m2[1];
-		typename tmat4x4<T>::col_type const SrcB2 = m2[2];
-		typename tmat4x4<T>::col_type const SrcB3 = m2[3];
-
-        tmat4x4<T> Result(tmat4x4<T>::null);
-		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
-		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
-		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
-		Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
-        return Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::value_type const & s
-	)
-    {
-        return tmat4x4<T>(
-            m[0] / s,
-            m[1] / s,
-            m[2] / s,
-            m[3] / s);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		typename tmat4x4<T>::value_type const & s, 
-		tmat4x4<T> const & m
-	)
-    {
-        return tmat4x4<T>(
-            s / m[0],
-            s / m[1],
-            s / m[2],
-            s / m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator/ 
-	(
-		tmat4x4<T> const & m, 
-		typename tmat4x4<T>::row_type const & v
-	)
-    {
-        return m._inverse() * v;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator/ 
-	(
-		typename tmat4x4<T>::col_type const & v, 
-		tmat4x4<T> const & m
-	)
-    {
-        return v * m._inverse();
-    }
- 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-    {
-        return m1 * m2._inverse();
-    }
-
-	// Unary constant operators
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> const operator- 
-	(
-		tmat4x4<T> const & m
-	)
-    {
-        return tmat4x4<T>(
-            -m[0], 
-            -m[1],
-            -m[2],
-            -m[3]);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> const operator++ 
-	(
-		tmat4x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x4<T>(
-            m[0] + typename tmat4x4<T>::value_type(1),
-            m[1] + typename tmat4x4<T>::value_type(1),
-            m[2] + typename tmat4x4<T>::value_type(1),
-            m[3] + typename tmat4x4<T>::value_type(1));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tmat4x4<T> const operator-- 
-	(
-		tmat4x4<T> const & m, 
-		int
-	) 
-    {
-        return tmat4x4<T>(
-            m[0] - typename tmat4x4<T>::value_type(1),
-            m[1] - typename tmat4x4<T>::value_type(1),
-            m[2] - typename tmat4x4<T>::value_type(1),
-            m[3] - typename tmat4x4<T>::value_type(1));
-    }
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tmat4x4<T> const & m1, 
-		tmat4x4<T> const & m2
-	)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
-	}
-
-} //namespace detail
-} //namespace glm
diff --git a/thirdparty/glm/glm/core/type_size.hpp b/thirdparty/glm/glm/core/type_size.hpp
deleted file mode 100644
index c68a1f9b..00000000
--- a/thirdparty/glm/glm/core/type_size.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_size.hpp
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_size
-#define glm_core_type_size
-
-#include <cstdlib>
-
-namespace glm{
-namespace detail
-{
-	//typedef std::size_t size_t;
-	typedef int sizeType;
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_size
diff --git a/thirdparty/glm/glm/core/type_vec.hpp b/thirdparty/glm/glm/core/type_vec.hpp
deleted file mode 100644
index b3fdc9f3..00000000
--- a/thirdparty/glm/glm/core/type_vec.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec.hpp
-/// @date 2010-01-26 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_vec
-#define glm_core_type_vec
-
-#include "type_gentype.hpp"
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#endif//glm_core_type_vec
diff --git a/thirdparty/glm/glm/core/type_vec.inl b/thirdparty/glm/glm/core/type_vec.inl
deleted file mode 100644
index fbaf08e7..00000000
--- a/thirdparty/glm/glm/core/type_vec.inl
+++ /dev/null
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
diff --git a/thirdparty/glm/glm/core/type_vec1.hpp b/thirdparty/glm/glm/core/type_vec1.hpp
deleted file mode 100644
index 2011e3ff..00000000
--- a/thirdparty/glm/glm/core/type_vec1.hpp
+++ /dev/null
@@ -1,212 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec1.hpp
-/// @date 2008-08-25 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype1
-#define glm_core_type_gentype1
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref1;
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec1;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-
-	template <typename T>
-	struct tvec1
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-
-		typedef tvec1<T> type;
-		typedef tvec1<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-			value_type x;
-#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
-			union {value_type x, r, s;};
-#		endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec1();
-		GLM_FUNC_DECL tvec1(tvec1<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec1(
-			ctor);
-		GLM_FUNC_DECL explicit tvec1(
-			value_type const & s);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec1(tref1<T> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(U const & s);
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator+=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator-=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator*=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator/=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<U> const & v);
-		GLM_FUNC_DECL tvec1<T> & operator++();
-		GLM_FUNC_DECL tvec1<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator%=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator&=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator|=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator^=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator<<=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator>>=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref1<T> swizzle(comp X);
-	};
-
-	template <typename T>
-	struct tref1
-	{
-		GLM_FUNC_DECL tref1(T & x);
-		GLM_FUNC_DECL tref1(tref1<T> const & r);
-		GLM_FUNC_DECL tref1(tvec1<T> const & v);
-
-		GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
-		GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
-
-		T& x;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec1);
-
-	typedef detail::tvec1<highp_float>		highp_vec1_t;
-	typedef detail::tvec1<mediump_float>	mediump_vec1_t;
-	typedef detail::tvec1<lowp_float>		lowp_vec1_t;
-	typedef detail::tvec1<highp_int>		highp_ivec1_t;
-	typedef detail::tvec1<mediump_int>		mediump_ivec1_t;
-	typedef detail::tvec1<lowp_int>			lowp_ivec1_t;
-	typedef detail::tvec1<highp_uint>		highp_uvec1_t;
-	typedef detail::tvec1<mediump_uint>		mediump_uvec1_t;
-	typedef detail::tvec1<lowp_uint>		lowp_uvec1_t;
-
-}//namespace detail
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec1.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype1
diff --git a/thirdparty/glm/glm/core/type_vec1.inl b/thirdparty/glm/glm/core/type_vec1.inl
deleted file mode 100644
index 781f89da..00000000
--- a/thirdparty/glm/glm/core/type_vec1.inl
+++ /dev/null
@@ -1,928 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec1.inl
-/// @date 2008-08-25 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec1<T>::size_type tvec1<T>::length() const
-	{
-		return 1;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec1<T>::value_type & tvec1<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec1<T>::value_type const & tvec1<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1() :
-		x(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec1<T> const & v
-	) :
-		x(v.x)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		value_type const & s
-	) :
-		x(s)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tref1<T> const & r
-	) :
-		x(r.x)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		U const & s
-	) :
-		x(value_type(s))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec2<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T>::tvec1
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
-	(
-		tvec1<T> const & v
-	)
-	{
-		this->x = v.x;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
-	(
-		U const & s
-	)
-	{
-		this->x += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
-	(
-		U const & s
-	)
-	{
-		this->x -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
-	(
-		U const & s
-	)
-	{
-		this->x *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
-	(	
-		tvec1<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
-	(
-		U const & s
-	)
-	{
-		this->x /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator++()
-	{
-		++this->x;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator--()
-	{
-		--this->x;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return (v1.x == v2.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return (v1.x != v2.x);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
-	(
-		U const & s
-	)
-	{
-		this->x %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
-	(
-		U const & s
-	)
-	{
-		this->x &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
-	(
-		U const & s
-	)
-	{
-		this->x |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x |= U(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
-	(
-		U const & s
-	)
-	{
-		this->x ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
-	(
-		U const & s
-	)
-	{
-		this->x <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
-	(
-		U const & s
-	)
-	{
-		this->x >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
-	(
-		tvec1<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T 
-	tvec1<T>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> 
-	tvec1<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref1<T> 
-	tvec1<T>::swizzle
-	(
-		comp x
-	)
-	{
-		return tref1<T>(
-			(*this)[x]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s + v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator+ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x + v2.x);
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s - v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x - v2.x);
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator* 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator* 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s * v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator*
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x * v2.x);
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s / v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator/ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x / v2.x);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator- 
-	(
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			-v.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator++ 
-	(
-		tvec1<T> const & v, 
-		int
-	)
-	{
-		return tvec1<T>(
-			v.x + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator-- 
-	(
-		tvec1<T> const & v, 
-		int
-	)
-	{
-		return tvec1<T>(
-			v.x - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x % s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s % v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator% 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x % v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x & s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s & v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator& 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x & v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x | s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s | v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator| 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x | v2.x);
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x ^ s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s ^ v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator^ 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x ^ v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x << s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s << v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator<< 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x << v2.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		tvec1<T> const & v, 
-		typename tvec1<T>::value_type const & s
-	)
-	{
-		return tvec1<T>(
-			v.x >> s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		typename tvec1<T>::value_type const & s, 
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			s >> v.x);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec1<T> operator>> 
-	(
-		tvec1<T> const & v1, 
-		tvec1<T> const & v2
-	)
-	{
-		return tvec1<T>(
-			v1.x >> v2.x);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec1<T> operator~ 
-	(
-		tvec1<T> const & v
-	)
-	{
-		return tvec1<T>(
-			~v.x);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		T & x
-	) :
-		x(x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		tref1<T> const & r
-	) :
-		x(r.x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T>::tref1
-	(
-		tvec1<T> const & v
-	) :
-		x(v.x)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
-	(
-		tref1<T> const & r
-	)
-	{
-		x = r.x;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
-	(
-		tvec1<T> const & v
-	)
-	{
-		x = v.x;
-		return *this;
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/type_vec2.hpp b/thirdparty/glm/glm/core/type_vec2.hpp
deleted file mode 100644
index 00972536..00000000
--- a/thirdparty/glm/glm/core/type_vec2.hpp
+++ /dev/null
@@ -1,319 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec2.hpp
-/// @date 2008-08-18 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype2
-#define glm_core_type_gentype2
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec3;
-	template <typename T> struct tvec4;
-
-	// The basic 2D vector type.
-	// \ingroup core_template
-	template <typename T>
-	struct tvec2
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-
-		typedef tvec2<T> type;
-		typedef tvec2<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y)
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g)
-			_GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g)
-			_GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g)
-			_GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t)
-#		endif//(defined(GLM_SWIZZLE))
-
-			struct{value_type r, g;};
-			struct{value_type s, t;};
-			struct{value_type x, y;};
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, detail::tvec2, detail::tref2)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec2();
-		GLM_FUNC_DECL tvec2(tvec2<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec2(
-			ctor);
-		GLM_FUNC_DECL explicit tvec2(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec2(
-			value_type const & s1, 
-			value_type const & s2);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		tvec2(tref2<T> const & r);
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T>,E0,E1,-1,-2>& that)
-        {
-            *this = that();
-        }
-
-		//////////////////////////////////////
-		// Convertion constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V> 
-		GLM_FUNC_DECL explicit tvec2(
-			U const & x, 
-			V const & y);
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
-		GLM_FUNC_DECL tvec2<T> & operator++();
-		GLM_FUNC_DECL tvec2<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-	};
-
-	template <typename T>
-	struct tref2
-	{
-		GLM_FUNC_DECL tref2(T & x, T & y);
-		GLM_FUNC_DECL tref2(tref2<T> const & r);
-		GLM_FUNC_DECL explicit tref2(tvec2<T> const & v);
-
-		GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
-		GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
-
-		GLM_FUNC_DECL tvec2<T> operator() ();
-
-		T & x;
-		T & y;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec2);
-
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 2 components vector 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.5 Vectors</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::tvec2<highp_float>		highp_vec2;
-
-	/// 2 components vector 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.5 Vectors</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::tvec2<mediump_float>	mediump_vec2;
-
-	/// 2 components vector 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.5 Vectors</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::tvec2<lowp_float>		lowp_vec2;
-
-	/// 2 components vector of high precision signed integer 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.5 Vectors</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::tvec2<highp_int>		highp_ivec2;
-
-	/// 2 components vector of medium precision signed integer 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.5 Vectors</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::tvec2<mediump_int>		mediump_ivec2;
-
-	/// 2 components vector of low precision signed integer 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.5 Vectors</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::tvec2<lowp_int>			lowp_ivec2;
-	
-	/// 2 components vector of high precision unsigned integer 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.5 Vectors</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::tvec2<highp_uint>		highp_uvec2;
-
-	/// 2 components vector of medium precision unsigned integer 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.5 Vectors</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::tvec2<mediump_uint>		mediump_uvec2;
-
-	/// 2 components vector of low precision unsigned integer 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.5 Vectors</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::tvec2<lowp_uint>		lowp_uvec2;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec2.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype2
diff --git a/thirdparty/glm/glm/core/type_vec2.inl b/thirdparty/glm/glm/core/type_vec2.inl
deleted file mode 100644
index ac2b0b5e..00000000
--- a/thirdparty/glm/glm/core/type_vec2.inl
+++ /dev/null
@@ -1,1029 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_tvec2.inl
-/// @date 2008-08-18 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::size_type tvec2<T>::length() const
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type & 
-	tvec2<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type const & 
-	tvec2<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2() :
-		x(value_type(0)),
-		y(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec2<T> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		value_type const & s1, 
-		value_type const & s2
-	) :
-		x(s1),
-		y(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tref2<T> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		U const & x
-	) :
-		x(value_type(x)),
-		y(value_type(x))
-	{}
-
-	template <typename T>
-	template <typename U, typename V> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		U const & a, 
-		V const & b
-	) :
-		x(value_type(a)),
-		y(value_type(b))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec2<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T>::tvec2
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
-	(
-		tvec2<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
-	(
-		U const & s
-	)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
-	(
-		U const & s
-	)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
-	(
-		U const & s
-	)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
-	(
-		U const & s
-	)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
-	(
-		U const & s
-	)
-	{
-		this->x %= T(s);
-		this->y %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		this->y %= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
-	(
-		U const & s
-	)
-	{
-		this->x &= T(s);
-		this->y &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		this->y &= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
-	(
-		U const & s
-	)
-	{
-		this->x |= T(s);
-		this->y |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x |= T(v.x);
-		this->y |= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
-	(
-		U const & s
-	)
-	{
-		this->x ^= T(s);
-		this->y ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		this->y ^= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
-	(
-		U const & s
-	)
-	{
-		this->x <<= T(s);
-		this->y <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
-	(
-		U const & s
-	)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
-	(
-		tvec2<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec2<T>::value_type tvec2<T>::swizzle
-	(
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec2<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x + T(s),
-			v.y + T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) + v.x,
-			T(s) + v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator+ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x + T(v2.x),
-			v1.y + T(v2.y));
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator-
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x - T(s),
-			v.y - T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) - v.x,
-			T(s) - v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x - T(v2.x),
-			v1.y - T(v2.y));
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator* 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x * T(s),
-			v.y * T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator* 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) * v.x,
-			T(s) * v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator*
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x * T(v2.x),
-			v1.y * T(v2.y));
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x / T(s),
-			v.y / T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) / v.x,
-			T(s) / v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator/ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x / T(v2.x),
-			v1.y / T(v2.y));
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator- 
-	(
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			-v.x, 
-			-v.y);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator++ 
-	(
-		tvec2<T> const & v, 
-		int
-	)
-	{
-		return tvec2<T>(
-			v.x + T(1), 
-			v.y + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator-- 
-	(
-		tvec2<T> const & v, 
-		int
-	)
-	{
-		return tvec2<T>(
-			v.x - T(1), 
-			v.y - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator% 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x % T(s),
-			v.y % T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator%
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) % v.x,
-			T(s) % v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator% 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x % T(v2.x),
-			v1.y % T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x & T(s),
-			v.y & T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) & v.x,
-			T(s) & v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator& 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x & T(v2.x),
-			v1.y & T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x | T(s),
-			v.y | T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) | v.x,
-			T(s) | v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator| 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x | T(v2.x),
-			v1.y | T(v2.y));
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x ^ T(s),
-			v.y ^ T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) ^ v.x,
-			T(s) ^ v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator^ 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x ^ T(v2.x),
-			v1.y ^ T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x << T(s),
-			v.y << T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			s << T(v.x),
-			s << T(v.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator<< 
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x << T(v2.x),
-			v1.y << T(v2.y));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>> 
-	(
-		tvec2<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec2<T>(
-			v.x >> T(s),
-			v.y >> T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>> 
-	(
-		T const & s, 
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			T(s) >> v.x,
-			T(s) >> v.y);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> operator>>
-	(
-		tvec2<T> const & v1, 
-		tvec2<T> const & v2
-	)
-	{
-		return tvec2<T>(
-			v1.x >> T(v2.x),
-			v1.y >> T(v2.y));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> operator~ 
-	(
-		tvec2<T> const & v
-	)
-	{
-		return tvec2<T>(
-			~v.x,
-			~v.y);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		T & x, 
-		T & y
-	) :
-		x(x),
-		y(y)
-	{}
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		tref2<T> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	template <typename T> 
-	tref2<T>::tref2
-	(
-		tvec2<T> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	template <typename T> 
-	tref2<T>& tref2<T>::operator= 
-	(
-		tref2<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		return *this;
-	}
-
-	template <typename T> 
-	tref2<T>& tref2<T>::operator= 
-	(
-		tvec2<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec2<T> tref2<T>::operator() ()
-	{
-		return tvec2<T>(this->x, this->y);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/type_vec3.hpp b/thirdparty/glm/glm/core/type_vec3.hpp
deleted file mode 100644
index 3177b342..00000000
--- a/thirdparty/glm/glm/core/type_vec3.hpp
+++ /dev/null
@@ -1,344 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec3.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype3
-#define glm_core_type_gentype3
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec4;
-
-	// Basic 3D vector type.
-	// \ingroup core_template
-	template <typename T>
-	struct tvec3
-	{	
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-
-		typedef tvec3<T> type;
-		typedef tvec3<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z)
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b)
-			_GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b)
-			_GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b)
-			_GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p)
-#		endif//(defined(GLM_SWIZZLE))
-
-			struct{value_type r, g, b;};
-			struct{value_type s, t, p;};
-			struct{value_type x, y, z;};
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-		union {value_type z, b, p;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, detail::tvec3, detail::tref2, detail::tref3)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec3();
-		GLM_FUNC_DECL tvec3(tvec3<T> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec3(
-			ctor);
-		GLM_FUNC_DECL explicit tvec3(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec3(
-			value_type const & s1, 
-			value_type const & s2, 
-			value_type const & s3);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V, typename W> 
-		GLM_FUNC_DECL explicit tvec3(
-			U const & x, 
-			V const & y, 
-			W const & z);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec3(tref3<T> const & r);
-
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(tref2<A> const & v, B const & s);
-
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B> const & v);
-
-        template <int E0, int E1, int E2>
-        GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & that)
-        {
-            *this = that();
-        }
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
-        {
-            *this = tvec3<T>(v(), s);
-        }
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
-        {
-            *this = tvec3<T>(s, v());
-        }
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
-
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
-		template <typename U> 
-		GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
-		GLM_FUNC_DECL tvec3<T> & operator++();
-		GLM_FUNC_DECL tvec3<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
-	};
-
-	template <typename T>
-	struct tref3
-	{
-		GLM_FUNC_DECL tref3(T & x, T & y, T & z);
-		GLM_FUNC_DECL tref3(tref3<T> const & r);
-		GLM_FUNC_DECL explicit tref3(tvec3<T> const & v);
-
-		GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
-		GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
-
-		GLM_FUNC_DECL tvec3<T> operator() ();
-
-		T & x;
-		T & y;
-		T & z;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec3);
-} //namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 3 components vector 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.5 Vectors</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::tvec3<highp_float>		highp_vec3;
-
-	/// 3 components vector 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.5 Vectors</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::tvec3<mediump_float>	mediump_vec3;
-
-	/// 3 components vector 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.5 Vectors</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::tvec3<lowp_float>		lowp_vec3;
-
-	/// 3 components vector of high precision signed integer 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.5 Vectors</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::tvec3<highp_int>		highp_ivec3;
-
-	/// 3 components vector of medium precision signed integer 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.5 Vectors</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::tvec3<mediump_int>		mediump_ivec3;
-
-	/// 3 components vector of low precision signed integer 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.5 Vectors</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::tvec3<lowp_int>			lowp_ivec3;
-
-	/// 3 components vector of high precision unsigned integer 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.5 Vectors</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::tvec3<highp_uint>		highp_uvec3;
-
-	/// 3 components vector of medium precision unsigned integer 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.5 Vectors</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::tvec3<mediump_uint>		mediump_uvec3;
-
-	/// 3 components vector of low precision unsigned integer 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.5 Vectors</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::tvec3<lowp_uint>		lowp_uvec3;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec3.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype3
diff --git a/thirdparty/glm/glm/core/type_vec3.inl b/thirdparty/glm/glm/core/type_vec3.inl
deleted file mode 100644
index 3fe670b6..00000000
--- a/thirdparty/glm/glm/core/type_vec3.inl
+++ /dev/null
@@ -1,1152 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_tvec3.inl
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::size_type tvec3<T>::length() const
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type & 
-	tvec3<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type const & 
-	tvec3<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3() :
-		x(value_type(0)),
-		y(value_type(0)),
-		z(value_type(0))
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec3<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s),
-		z(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		value_type const & s0, 
-		value_type const & s1, 
-		value_type const & s2
-	) :
-		x(s0),
-		y(s1),
-		z(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tref3<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tref2<A> const & v, 
-		B const & s
-	) : 
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		A const & s, 
-		tref2<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		U const & s
-	) :
-		x(value_type(s)),
-		y(value_type(s)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		A const & x, 
-		B const & y, 
-		C const & z
-	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec2<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(	
-		A const & s, 
-		tvec2<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec3<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>::tvec3
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
-	(
-		tvec3<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		this->z = T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
-	(
-		U const & s
-	)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		this->z += T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
-	(
-		U const & s
-	)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		this->z -= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
-	(
-		U const & s
-	)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		this->z *= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
-	(
-		U const & s
-	)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		this->z /= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
-	(
-		U const & s
-	)
-	{
-		this->x %= s;
-		this->y %= s;
-		this->z %= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x %= v.x;
-		this->y %= v.y;
-		this->z %= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
-	(	
-		U const & s
-	)
-	{
-		this->x &= s;
-		this->y &= s;
-		this->z &= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x &= v.x;
-		this->y &= v.y;
-		this->z &= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
-	(
-		U const & s
-	)
-	{
-		this->x |= s;
-		this->y |= s;
-		this->z |= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x |= v.x;
-		this->y |= v.y;
-		this->z |= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
-	(
-		U const & s
-	)
-	{
-		this->x ^= s;
-		this->y ^= s;
-		this->z ^= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x ^= v.x;
-		this->y ^= v.y;
-		this->z ^= v.z;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
-	(
-		U const & s
-	)
-	{
-		this->x <<= s;
-		this->y <<= s;
-		this->z <<= s;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		this->z <<= T(v.z);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
-	(
-		U const & s
-	)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
-	(
-		tvec3<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		this->z >>= T(v.z);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec3<T>::value_type 
-	tvec3<T>::swizzle
-	(
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	)
-	{
-		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x + T(s),
-			v.y + T(s),
-			v.z + T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) + v.x,
-			T(s) + v.y,
-			T(s) + v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator+ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x + T(v2.x),
-			v1.y + T(v2.y),
-			v1.z + T(v2.z));
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x - T(s),
-			v.y - T(s),
-			v.z - T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) - v.x,
-			T(s) - v.y,
-			T(s) - v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x - T(v2.x),
-			v1.y - T(v2.y),
-			v1.z - T(v2.z));
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator*
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x * T(s),
-			v.y * T(s),
-			v.z * T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator* 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) * v.x,
-			T(s) * v.y,
-			T(s) * v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator* 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x * T(v2.x),
-			v1.y * T(v2.y),
-			v1.z * T(v2.z));
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x / T(s),
-			v.y / T(s),
-			v.z / T(s));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) / v.x,
-			T(s) / v.y,
-			T(s) / v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator/ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x / T(v2.x),
-			v1.y / T(v2.y),
-			v1.z / T(v2.z));
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator- 
-	(
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			-v.x, 
-			-v.y, 
-			-v.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator++ 
-	(
-		tvec3<T> const & v, 
-		int
-	)
-	{
-		return tvec3<T>(
-			v.x + T(1), 
-			v.y + T(1), 
-			v.z + T(1));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator-- 
-	(
-		tvec3<T> const & v, 
-		int
-	)
-	{
-		return tvec3<T>(
-			v.x - T(1), 
-			v.y - T(1), 
-			v.z - T(1));
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator% 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x % T(s),
-			v.y % T(s),
-			v.z % T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator%
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) % v.x,
-			T(s) % v.y,
-			T(s) % v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator% 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x % T(v2.x),
-			v1.y % T(v2.y),
-			v1.z % T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x & T(s),
-			v.y & T(s),
-			v.z & T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) & v.x,
-			T(s) & v.y,
-			T(s) & v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator& 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x & T(v2.x),
-			v1.y & T(v2.y),
-			v1.z & T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x | T(s),
-			v.y | T(s),
-			v.z | T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) | v.x,
-			T(s) | v.y,
-			T(s) | v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator| 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x | T(v2.x),
-			v1.y | T(v2.y),
-			v1.z | T(v2.z));
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x ^ T(s),
-			v.y ^ T(s),
-			v.z ^ T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) ^ v.x,
-			T(s) ^ v.y,
-			T(s) ^ v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator^ 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x ^ T(v2.x),
-			v1.y ^ T(v2.y),
-			v1.z ^ T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x << T(s),
-			v.y << T(s),
-			v.z << T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			T(s) << v.x,
-			T(s) << v.y,
-			T(s) << v.z);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator<< 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x << T(v2.x),
-			v1.y << T(v2.y),
-			v1.z << T(v2.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		tvec3<T> const & v, 
-		T const & s
-	)
-	{
-		return tvec3<T>(
-			v.x >> T(s),
-			v.y >> T(s),
-			v.z >> T(s));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		T const & s, 
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			s >> T(v.x),
-			s >> T(v.y),
-			s >> T(v.z));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> operator>> 
-	(
-		tvec3<T> const & v1, 
-		tvec3<T> const & v2
-	)
-	{
-		return tvec3<T>(
-			v1.x >> T(v2.x),
-			v1.y >> T(v2.y),
-			v1.z >> T(v2.z));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> operator~ 
-	(
-		tvec3<T> const & v
-	)
-	{
-		return tvec3<T>(
-			~v.x,
-			~v.y,
-			~v.z);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3(T & x, T & y, T & z) :
-		x(x),
-		y(y),
-		z(z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3
-	(
-		tref3<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T>::tref3
-	(
-		tvec3<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
-	(
-		tref3<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		z = r.z;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
-	(
-		tvec3<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		z = v.z;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec3<T> tref3<T>::operator() ()
-	{
-		return tvec3<T>(this->x, this->y, this->z);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/core/type_vec4.hpp b/thirdparty/glm/glm/core/type_vec4.hpp
deleted file mode 100644
index 31cd9940..00000000
--- a/thirdparty/glm/glm/core/type_vec4.hpp
+++ /dev/null
@@ -1,401 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_vec4.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef glm_core_type_gentype4
-#define glm_core_type_gentype4
-
-#include "type_vec.hpp"
-#include "type_float.hpp"
-#include "type_int.hpp"
-#include "type_size.hpp"
-#include "_swizzle.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T> struct tref2;
-	template <typename T> struct tref3;
-	template <typename T> struct tref4;
-	template <typename T> struct tvec2;
-	template <typename T> struct tvec3;
-
-	// Basic 4D vector type.
-	// @ingroup core_template
-	template <typename T>
-	struct tvec4
-	{
-		enum ctor{null};
-
-		typedef T value_type;
-		typedef std::size_t size_type;
-		GLM_FUNC_DECL size_type length() const;
-
-		typedef tvec4<T> type;
-		typedef tvec4<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-#	if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
-		union 
-		{
-#		if(defined(GLM_SWIZZLE))
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a)
-			_GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q)
-#		endif//(defined(GLM_SWIZZLE))
-
-			struct{value_type r, g, b, a;};
-			struct{value_type s, t, p, q;};
-			struct{value_type x, y, z, w;};
-		};
-#	elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-		union {value_type x, r, s;};
-		union {value_type y, g, t;};
-		union {value_type z, b, p;};
-		union {value_type w, a, q;};
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
-#		endif//(defined(GLM_SWIZZLE))
-#	else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-		value_type x, y, z, w;
-
-#		if(defined(GLM_SWIZZLE))
-			// Defines all he swizzle operator as functions
-			GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
-			GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
-#		endif//(defined(GLM_SWIZZLE))
-#	endif//GLM_COMPONENT
-
-		//////////////////////////////////////
-		// Accesses
-
-		GLM_FUNC_DECL value_type & operator[](size_type i);
-		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		GLM_FUNC_DECL tvec4();
-		GLM_FUNC_DECL tvec4(type const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		GLM_FUNC_DECL explicit tvec4(
-			ctor);
-		GLM_FUNC_DECL explicit tvec4(
-			value_type const & s);
-		GLM_FUNC_DECL explicit tvec4(
-			value_type const & s0, 
-			value_type const & s1, 
-			value_type const & s2, 
-			value_type const & s3);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(
-			U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, typename D> 
-		GLM_FUNC_DECL explicit tvec4(
-			A const & x, 
-			B const & y, 
-			C const & z, 
-			D const & w);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
-
-        template <int E0, int E1, int E2, int E3>
-        GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
-        {
-            *this = that();
-        }
-
-        template <int E0, int E1, int F0, int F1>
-        GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T>, F0, F1, -1, -2> const & u)
-        {
-            *this = tvec4<T>(v(), u());
-        }
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
-        {
-            *this = tvec4<T>(x, y, v());
-        }
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
-        {
-            *this = tvec4<T>(x, v(), w);
-        }
-
-        template <int E0, int E1>
-        GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
-        {
-            *this = tvec4<T>(v(), z, w);
-        }
-
-        template <int E0, int E1, int E2>
-        GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
-        {
-            *this = tvec4<T>(v(), w);
-        }
-
-        template <int E0, int E1, int E2>
-        GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
-        {
-            *this = tvec4<T>(x, v());
-        }
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		GLM_FUNC_DECL tvec4(tref4<T> const & r);
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
-
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
-		GLM_FUNC_DECL tvec4<T> & operator++();
-		GLM_FUNC_DECL tvec4<T> & operator--();
-
-		//////////////////////////////////////
-		// Unary bit operators
-
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
-		template <typename U>
-		GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		GLM_FUNC_DECL value_type swizzle(comp X) const;
-		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
-		GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
-	};
-
-	template <typename T>
-	struct tref4
-	{
-		GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
-		GLM_FUNC_DECL tref4(tref4<T> const & r);
-		GLM_FUNC_DECL explicit tref4(tvec4<T> const & v);
-
-		GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
-		GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
-
-		GLM_FUNC_DECL tvec4<T> operator() ();
-
-		T & x;
-		T & y;
-		T & z;
-		T & w;
-	};
-
-	GLM_DETAIL_IS_VECTOR(tvec4);
-}//namespace detail
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// 4 components vector 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.5 Vectors</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::tvec4<highp_float>		highp_vec4;
-
-	/// 4 components vector 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.5 Vectors</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::tvec4<mediump_float>	mediump_vec4;
-
-	/// 4 components vector 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.5 Vectors</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::tvec4<lowp_float>		lowp_vec4;
-
-	/// 4 components vector of high precision signed integer 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.5 Vectors</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::tvec4<highp_int>		highp_ivec4;
-
-	/// 4 components vector of medium precision signed integer 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.5 Vectors</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::tvec4<mediump_int>		mediump_ivec4;
-
-	/// 4 components vector of low precision signed integer 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.5 Vectors</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::tvec4<lowp_int>			lowp_ivec4;
-
-	/// 4 components vector of high precision unsigned integer 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.5 Vectors</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::tvec4<highp_uint>		highp_uvec4;
-
-	/// 4 components vector of medium precision unsigned integer 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.5 Vectors</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::tvec4<mediump_uint>		mediump_uvec4;
-
-	/// 4 components vector of low precision unsigned integer 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.5 Vectors</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::tvec4<lowp_uint>		lowp_uvec4;
-
-	/// @}
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_vec4.inl"
-#endif//GLM_EXTERNAL_TEMPLATE
-
-#endif//glm_core_type_gentype4
diff --git a/thirdparty/glm/glm/core/type_vec4.inl b/thirdparty/glm/glm/core/type_vec4.inl
deleted file mode 100644
index b8ca8427..00000000
--- a/thirdparty/glm/glm/core/type_vec4.inl
+++ /dev/null
@@ -1,1378 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/core/type_tvec4.inl
-/// @date 2008-08-23 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::size_type tvec4<T>::length() const
-	{
-		return 4;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type & 
-	tvec4<T>::operator[]
-	(
-		size_type i
-	)
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type const & 
-	tvec4<T>::operator[]
-	(
-		size_type i
-	) const
-	{
-		assert(i < this->length());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4() :
-		x(value_type(0)),
-		y(value_type(0)),
-		z(value_type(0)),
-		w(value_type(0))
-	{}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		ctor
-	)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		type const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		value_type const & s
-	) :
-		x(s),
-		y(s),
-		z(s),
-		w(s)
-	{}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		value_type const & s1, 
-		value_type const & s2, 
-		value_type const & s3, 
-		value_type const & s4
-	) :
-		x(s1),
-		y(s2),
-		z(s3),
-		w(s4)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref4<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s1)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		tref2<B> const & v, 
-		C const & s2
-	) :
-		x(value_type(s1)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tref2<C> const & v
-	) :
-		x(value_type(s1)),
-		y(value_type(s2)),
-		z(value_type(v.x)),
-		w(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref3<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s, 
-		tref3<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v1, 
-		tref2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tref2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tref2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-		
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		U const & x
-	) :
-		x(value_type(x)),
-		y(value_type(x)),
-		z(value_type(x)),
-		w(value_type(x))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C, typename D> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & x, 
-		B const & y, 
-		C const & z, 
-		D const & w
-	) :
-		x(value_type(x)),
-		y(value_type(y)),
-		z(value_type(z)),
-		w(value_type(w))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(s1)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		tvec2<B> const & v, 
-		C const & s2
-	) :
-		x(value_type(s1)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(s2))
-	{}
-
-	template <typename T>
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tvec2<C> const & v
-	) :
-		x(value_type(s1)),
-		y(value_type(s2)),
-		z(value_type(v.x)),
-		w(value_type(v.y))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec3<A> const & v, 
-		B const & s
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(s))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		A const & s, 
-		tvec3<B> const & v
-	) :
-		x(value_type(s)),
-		y(value_type(v.x)),
-		z(value_type(v.y)),
-		w(value_type(v.z))
-	{}
-
-	template <typename T>
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(value_type(v1.x)),
-		y(value_type(v1.y)),
-		z(value_type(v2.x)),
-		w(value_type(v2.y))
-	{}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T>::tvec4
-	(
-		tvec4<U> const & v
-	) :
-		x(value_type(v.x)),
-		y(value_type(v.y)),
-		z(value_type(v.z)),
-		w(value_type(v.w))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
-	(
-		tvec4<T> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		this->w = v.w;
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x = T(v.x);
-		this->y = T(v.y);
-		this->z = T(v.z);
-		this->w = T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
-	(
-		U const & s
-	)
-	{
-		this->x += T(s);
-		this->y += T(s);
-		this->z += T(s);
-		this->w += T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x += T(v.x);
-		this->y += T(v.y);
-		this->z += T(v.z);
-		this->w += T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
-	(
-		U const & s
-	)
-	{
-		this->x -= T(s);
-		this->y -= T(s);
-		this->z -= T(s);
-		this->w -= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x -= T(v.x);
-		this->y -= T(v.y);
-		this->z -= T(v.z);
-		this->w -= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
-	(
-		U const & s
-	)
-	{
-		this->x *= T(s);
-		this->y *= T(s);
-		this->z *= T(s);
-		this->w *= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x *= T(v.x);
-		this->y *= T(v.y);
-		this->z *= T(v.z);
-		this->w *= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
-	(
-		U const & s
-	)
-	{
-		this->x /= T(s);
-		this->y /= T(s);
-		this->z /= T(s);
-		this->w /= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x /= T(v.x);
-		this->y /= T(v.y);
-		this->z /= T(v.z);
-		this->w /= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		++this->w;
-		return *this;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		--this->w;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Unary bit operators
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
-	(
-		U const & s
-	)
-	{
-		this->x %= T(s);
-		this->y %= T(s);
-		this->z %= T(s);
-		this->w %= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x %= T(v.x);
-		this->y %= T(v.y);
-		this->z %= T(v.z);
-		this->w %= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
-	(
-		U const & s
-	)
-	{
-		this->x &= T(s);
-		this->y &= T(s);
-		this->z &= T(s);
-		this->w &= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x &= T(v.x);
-		this->y &= T(v.y);
-		this->z &= T(v.z);
-		this->w &= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
-	(
-		U const & s
-	)
-	{
-		this->x |= T(s);
-		this->y |= T(s);
-		this->z |= T(s);
-		this->w |= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x |= T(v.x);
-		this->y |= T(v.y);
-		this->z |= T(v.z);
-		this->w |= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
-	(
-		U const & s
-	)
-	{
-		this->x ^= T(s);
-		this->y ^= T(s);
-		this->z ^= T(s);
-		this->w ^= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x ^= T(v.x);
-		this->y ^= T(v.y);
-		this->z ^= T(v.z);
-		this->w ^= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
-	(
-		U const & s
-	)
-	{
-		this->x <<= T(s);
-		this->y <<= T(s);
-		this->z <<= T(s);
-		this->w <<= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x <<= T(v.x);
-		this->y <<= T(v.y);
-		this->z <<= T(v.z);
-		this->w <<= T(v.w);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
-	(
-		U const & s
-	)
-	{
-		this->x >>= T(s);
-		this->y >>= T(s);
-		this->z >>= T(s);
-		this->w >>= T(s);
-		return *this;
-	}
-
-	template <typename T>
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
-	(
-		tvec4<U> const & v
-	)
-	{
-		this->x >>= T(v.x);
-		this->y >>= T(v.y);
-		this->z >>= T(v.z);
-		this->w >>= T(v.w);
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER typename tvec4<T>::value_type 
-	tvec4<T>::swizzle
-	(	
-		comp x
-	) const
-	{
-		return (*this)[x];
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y
-	) const
-	{
-		return tvec2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	) const
-	{
-		return tvec3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	) const
-	{
-		return tvec4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref2<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y
-	)
-	{
-		return tref2<T>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref3<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z
-	)
-	{
-		return tref3<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
-	(
-		comp x, 
-		comp y, 
-		comp z, 
-		comp w
-	)
-	{
-		return tref4<T>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	//////////////////////////////////////
-	// Binary arithmetic operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x + s,
-			v.y + s,
-			v.z + s,
-			v.w + s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s + v.x,
-			s + v.y,
-			s + v.z,
-			s + v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator+ 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x + v2.x,
-			v1.y + v2.y,
-			v1.z + v2.z,
-			v1.w + v2.w);
-	}
-
-	//operator-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x - s,
-			v.y - s,
-			v.z - s,
-			v.w - s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s - v.x,
-			s - v.y,
-			s - v.z,
-			s - v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x - v2.x,
-			v1.y - v2.y,
-			v1.z - v2.z,
-			v1.w - v2.w);
-	}
-
-	//operator*
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator* 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x * s,
-			v.y * s,
-			v.z * s,
-			v.w * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator* 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s * v.x,
-			s * v.y,
-			s * v.z,
-			s * v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator*
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x * v2.x,
-			v1.y * v2.y,
-			v1.z * v2.z,
-			v1.w * v2.w);
-	}
-
-	//operator/
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x / s,
-			v.y / s,
-			v.z / s,
-			v.w / s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s / v.x,
-			s / v.y,
-			s / v.z,
-			s / v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator/ 
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x / v2.x,
-			v1.y / v2.y,
-			v1.z / v2.z,
-			v1.w / v2.w);
-	}
-
-	// Unary constant operators
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator- 
-	(
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			-v.x, 
-			-v.y, 
-			-v.z, 
-			-v.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator++ 
-	(
-		tvec4<T> const & v, 
-		int
-	)
-	{
-		typename tvec4<T>::value_type One(1);
-		return tvec4<T>(
-			v.x + One, 
-			v.y + One, 
-			v.z + One, 
-			v.w + One);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator-- 
-	(
-		tvec4<T> const & v, 
-		int
-	)
-	{
-		typename tvec4<T>::value_type One(1);
-		return tvec4<T>(
-			v.x - One, 
-			v.y - One, 
-			v.z - One, 
-			v.w - One);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
-	}
-
-	//////////////////////////////////////
-	// Binary bit operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator% 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x % s,
-			v.y % s,
-			v.z % s,
-			v.w % s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator% 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s % v.x,
-			s % v.y,
-			s % v.z,
-			s % v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator%
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x % v2.x,
-			v1.y % v2.y,
-			v1.z % v2.z,
-			v1.w % v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator& 
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x & s,
-			v.y & s,
-			v.z & s,
-			v.w & s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator& 
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s & v.x,
-			s & v.y,
-			s & v.z,
-			s & v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator&
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x & v2.x,
-			v1.y & v2.y,
-			v1.z & v2.z,
-			v1.w & v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x | s,
-			v.y | s,
-			v.z | s,
-			v.w | s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s | v.x,
-			s | v.y,
-			s | v.z,
-			s | v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator|
-	(
-		tvec4<T> const & v1, 
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x | v2.x,
-			v1.y | v2.y,
-			v1.z | v2.z,
-			v1.w | v2.w);
-	}
-		
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		tvec4<T> const & v, 
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x ^ s,
-			v.y ^ s,
-			v.z ^ s,
-			v.w ^ s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		typename tvec4<T>::value_type const & s, 
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s ^ v.x,
-			s ^ v.y,
-			s ^ v.z,
-			s ^ v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator^
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x ^ v2.x,
-			v1.y ^ v2.y,
-			v1.z ^ v2.z,
-			v1.w ^ v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x << s,
-			v.y << s,
-			v.z << s,
-			v.w << s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		typename tvec4<T>::value_type const & s,
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s << v.x,
-			s << v.y,
-			s << v.z,
-			s << v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator<<
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x << v2.x,
-			v1.y << v2.y,
-			v1.z << v2.z,
-			v1.w << v2.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		tvec4<T> const & v,
-		typename tvec4<T>::value_type const & s
-	)
-	{
-		return tvec4<T>(
-			v.x >> s,
-			v.y >> s,
-			v.z >> s,
-			v.w >> s);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		typename tvec4<T>::value_type const & s,
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			s >> v.x,
-			s >> v.y,
-			s >> v.z,
-			s >> v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T> operator>>
-	(
-		tvec4<T> const & v1,
-		tvec4<T> const & v2
-	)
-	{
-		return tvec4<T>(
-			v1.x >> v2.x,
-			v1.y >> v2.y,
-			v1.z >> v2.z,
-			v1.w >> v2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> operator~
-	(
-		tvec4<T> const & v
-	)
-	{
-		return tvec4<T>(
-			~v.x,
-			~v.y,
-			~v.z,
-			~v.w);
-	}
-
-	//////////////////////////////////////
-	// tref definition
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		T & x, 
-		T & y, 
-		T & z, 
-		T & w
-	) :
-		x(x),
-		y(y),
-		z(z),
-		w(w)
-	{}
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		tref4<T> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	template <typename T> 
-	tref4<T>::tref4
-	(
-		tvec4<T> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	template <typename T> 
-	tref4<T>& tref4<T>::operator= 
-	(
-		tref4<T> const & r
-	)
-	{
-		x = r.x;
-		y = r.y;
-		z = r.z;
-		w = r.w;
-		return *this;
-	}
-
-	template <typename T> 
-	tref4<T>& tref4<T>::operator= 
-	(
-		tvec4<T> const & v
-	)
-	{
-		x = v.x;
-		y = v.y;
-		z = v.z;
-		w = v.w;
-		return *this;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tvec4<T> tref4<T>::operator() ()
-	{
-		return tvec4<T>(this->x, this->y, this->z, this->w);
-	}
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/glm.hpp b/thirdparty/glm/glm/glm.hpp
deleted file mode 100644
index d38b1bb2..00000000
--- a/thirdparty/glm/glm/glm.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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/glm.hpp
-/// @date 2005-01-14 / 2011-10-24
-/// @author Christophe Riccio
-///
-///	@defgroup core GLM Core
-///	
-///	@brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
-///
-/// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and
-/// C++ functions that mirror the GLSL functions. It also includes 
-/// @ref core_precision "a set of precision-based types" that can be used in the appropriate
-/// functions. The C++ types are all based on a basic set of @ref core_template "template types".
-/// 
-/// The best documentation for GLM Core is the current GLSL specification,
-/// <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.clean.pdf">version 4.2
-/// (pdf file)</a>.
-/// There are a few @ref pg_differences "differences" between GLM core and GLSL.
-/// 
-/// GLM core functionnalities require <glm/glm.hpp> to be included to be used.
-/// 
-/// @defgroup core_types Types
-/// 
-/// @brief The standard types defined by the specification.
-/// 
-/// These types are all typedefs of more generalized, template types. To see the definiton
-/// of these template types, go to @ref core_template.
-/// 
-/// @ingroup core
-/// 
-/// @defgroup core_precision Precision types
-/// 
-/// @brief Non-GLSL types that are used to define precision-based types.
-/// 
-/// The GLSL language allows the user to define the precision of a particular variable.
-/// In OpenGL's GLSL, these precision qualifiers have no effect; they are there for compatibility
-/// with OpenGL ES's precision qualifiers, where they @em do have an effect.
-/// 
-/// C++ has no language equivalent to precision qualifiers. So GLM provides the next-best thing:
-/// a number of typedefs of the @ref core_template that use a particular precision.
-/// 
-/// None of these types make any guarantees about the actual precision used.
-/// 
-/// @ingroup core
-/// 
-/// @defgroup core_template Template types
-/// 
-/// @brief The generic template types used as the basis for the core types. 
-/// 
-/// These types are all templates used to define the actual @ref core_types.
-/// These templetes are implementation details of GLM types and should not be used explicitly.
-/// 
-/// @ingroup core
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "core/_fixes.hpp"
-
-#ifndef glm_glm
-#define glm_glm
-
-#include <cmath>
-#include <climits>
-#include <cfloat>
-#include <limits>
-#include <cstdio>
-//#include <type_traits>
-#include "core/setup.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
-#	define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
-#	pragma message("GLM: Core library included")
-#endif//GLM_MESSAGE
-
-#include "./core/_detail.hpp"
-#include "./core/type.hpp"
-
-#include "./core/func_trigonometric.hpp"
-#include "./core/func_exponential.hpp"
-#include "./core/func_common.hpp"
-#include "./core/func_packing.hpp"
-#include "./core/func_geometric.hpp"
-#include "./core/func_matrix.hpp"
-#include "./core/func_vector_relational.hpp"
-#include "./core/func_integer.hpp"
-#include "./core/func_noise.hpp"
-#include "./core/_swizzle.hpp"
-
-////////////////////
-// check type sizes
-#ifndef GLM_STATIC_ASSERT_NULL
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int8) == 1, "int8 size isn't 1 byte on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int16) == 2, "int16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int32) == 4, "int32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::int64) == 8, "int64 size isn't 8 bytes on this platform");
-
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint8) == 1, "uint8 size isn't 1 byte on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
-
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float16) == 2, "float16 size isn't 2 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float32) == 4, "float32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::detail::float64) == 8, "float64 size isn't 8 bytes on this platform");
-#endif//GLM_STATIC_ASSERT_NULL
-
-#endif//glm_glm
diff --git a/thirdparty/glm/glm/gtc/half_float.hpp b/thirdparty/glm/glm/gtc/half_float.hpp
deleted file mode 100644
index 5eb438d6..00000000
--- a/thirdparty/glm/glm/gtc/half_float.hpp
+++ /dev/null
@@ -1,424 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_half_float
-/// @file glm/gtc/half_float.hpp
-/// @date 2009-04-29 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-///
-/// @defgroup gtc_half_float GLM_GTC_half_float: Half-precision floating-point based types and functions
-/// @ingroup gtc
-/// 
-/// Defines the half-precision floating-point type, along with various typedefs for vectors and matrices.
-/// <glm/gtc/half_float.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_half_float
-#define GLM_GTC_half_float GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_half_float extension included")
-#endif
-
-namespace glm{
-namespace detail
-{
-#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-	template <>
-	struct tvec2<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec2<half> type;
-		typedef tvec2<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y;
-
-		//////////////////////////////////////
-		// Accesses
-
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		tvec2();
-		tvec2(tvec2<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		explicit tvec2(ctor);
-		explicit tvec2(
-			half const & s);
-		explicit tvec2(
-			half const & s1, 
-			half const & s2);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		tvec2(tref2<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec2(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V> 
-		explicit tvec2(U const & x, V const & y);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec2(tvec2<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec2(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec2(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		tvec2<half>& operator= (tvec2<half> const & v);
-
-		tvec2<half>& operator+=(half const & s);
-		tvec2<half>& operator+=(tvec2<half> const & v);
-		tvec2<half>& operator-=(half const & s);
-		tvec2<half>& operator-=(tvec2<half> const & v);
-		tvec2<half>& operator*=(half const & s);
-		tvec2<half>& operator*=(tvec2<half> const & v);
-		tvec2<half>& operator/=(half const & s);
-		tvec2<half>& operator/=(tvec2<half> const & v);
-		tvec2<half>& operator++();
-		tvec2<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref2<half> swizzle(comp X, comp Y);
-	};
-
-	template <>
-	struct tvec3<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec3<half> type;
-		typedef tvec3<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y, z;
-
-		//////////////////////////////////////
-		// Accesses
-
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		tvec3();
-		tvec3(tvec3<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		explicit tvec3(ctor);
-		explicit tvec3(
-			half const & s);
-		explicit tvec3(
-			half const & s1, 
-			half const & s2, 
-			half const & s3);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		tvec3(tref3<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec3(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U, typename V, typename W> 
-		explicit tvec3(U const & x, V const & y, W const & z);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		explicit tvec3(tvec2<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		explicit tvec3(A const & s, tvec2<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec3(tvec3<U> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec3(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		tvec3<half>& operator= (tvec3<half> const & v);
-
-		tvec3<half>& operator+=(half const & s);
-		tvec3<half>& operator+=(tvec3<half> const & v);
-		tvec3<half>& operator-=(half const & s);
-		tvec3<half>& operator-=(tvec3<half> const & v);
-		tvec3<half>& operator*=(half const & s);
-		tvec3<half>& operator*=(tvec3<half> const & v);
-		tvec3<half>& operator/=(half const & s);
-		tvec3<half>& operator/=(tvec3<half> const & v);
-		tvec3<half>& operator++();
-		tvec3<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref3<half> swizzle(comp X, comp Y, comp Z);
-	};
-
-	template <>
-	struct tvec4<half>
-	{
-		enum ctor{null};
-		typedef half value_type;
-		typedef std::size_t size_type;
-        GLM_FUNC_DECL size_type length() const;
-		static GLM_FUNC_DECL size_type value_size();
-
-		typedef tvec4<half> type;
-		typedef tvec4<bool> bool_type;
-
-		//////////////////////////////////////
-		// Data
-
-		half x, y, z, w;
-
-		//////////////////////////////////////
-		// Accesses
-
-		half & operator[](size_type i);
-		half const & operator[](size_type i) const;
-
-		//////////////////////////////////////
-		// Implicit basic constructors
-
-		tvec4();
-		tvec4(tvec4<half> const & v);
-
-		//////////////////////////////////////
-		// Explicit basic constructors
-
-		explicit tvec4(ctor);
-		explicit tvec4(
-			half const & s);
-		explicit tvec4(
-			half const & s0, 
-			half const & s1, 
-			half const & s2, 
-			half const & s3);
-
-		//////////////////////////////////////
-		// Swizzle constructors
-
-		tvec4(tref4<half> const & r);
-
-		//////////////////////////////////////
-		// Convertion scalar constructors
-
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec4(U const & x);
-		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C, typename D> 
-		explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
-
-		//////////////////////////////////////
-		// Convertion vector constructors
-
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B, typename C> 
-		explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		explicit tvec4(tvec3<A> const & v, B const & s);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		explicit tvec4(A const & s, tvec3<B> const & v);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename A, typename B> 
-		explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
-		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
-		explicit tvec4(tvec4<U> const & v);
-
-		//////////////////////////////////////
-		// Unary arithmetic operators
-
-		tvec4<half>& operator= (tvec4<half> const & v);
-
-		tvec4<half>& operator+=(half const & s);
-		tvec4<half>& operator+=(tvec4<half> const & v);
-		tvec4<half>& operator-=(half const & s);
-		tvec4<half>& operator-=(tvec4<half> const & v);
-		tvec4<half>& operator*=(half const & s);
-		tvec4<half>& operator*=(tvec4<half> const & v);
-		tvec4<half>& operator/=(half const & s);
-		tvec4<half>& operator/=(tvec4<half> const & v);
-		tvec4<half>& operator++();
-		tvec4<half>& operator--();
-
-		//////////////////////////////////////
-		// Swizzle operators
-
-		half swizzle(comp X) const;
-		tvec2<half> swizzle(comp X, comp Y) const;
-		tvec3<half> swizzle(comp X, comp Y, comp Z) const;
-		tvec4<half> swizzle(comp X, comp Y, comp Z, comp W) const;
-		tref4<half> swizzle(comp X, comp Y, comp Z, comp W);
-	};
-#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-}
-//namespace detail
-
-	/// @addtogroup gtc_half_float
-	/// @{
-
-	/// Type for half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::half					half;
-
-	/// Vector of 2 half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::tvec2<detail::half>	hvec2;
-
-	/// Vector of 3 half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tvec3<detail::half>	hvec3;
-
-	/// Vector of 4 half-precision floating-point numbers. 
-	/// @see gtc_half_float
-	typedef detail::tvec4<detail::half>	hvec4;
-
-	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x2<detail::half>	hmat2;
-    
-	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x3<detail::half>	hmat3;
-
-	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x4<detail::half>	hmat4;
-
-	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x2<detail::half>	hmat2x2;
-    
-	/// 2 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x3<detail::half>	hmat2x3;
-    
-	/// 2 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat2x4<detail::half>	hmat2x4;
-
-	/// 3 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x2<detail::half>	hmat3x2;
-    
-	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x3<detail::half>	hmat3x3;
-    
-	/// 3 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat3x4<detail::half>	hmat3x4;
-
-	/// 4 * 2 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x2<detail::half>	hmat4x2;    
-
-	/// 4 * 3 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x3<detail::half>	hmat4x3;
-    
-	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see gtc_half_float
-	typedef detail::tmat4x4<detail::half>	hmat4x4;
-    
-	/// @}
-}// namespace glm
-
-#include "half_float.inl"
-
-#endif//GLM_GTC_half_float
diff --git a/thirdparty/glm/glm/gtc/half_float.inl b/thirdparty/glm/glm/gtc/half_float.inl
deleted file mode 100644
index 8a4a2c38..00000000
--- a/thirdparty/glm/glm/gtc/half_float.inl
+++ /dev/null
@@ -1,1009 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_half_float
-/// @file glm/gtc/half_float.inl
-/// @date 2009-04-29 / 2011-06-05
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-#if(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-
-	//////////////////////////////////////
-	// hvec2
-
-	GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::length() const
-	{
-		return 2;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::size_type tvec2<half>::value_size()
-	{
-		return 2;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec2<half>::operator[](tvec2<half>::size_type i)
-	{
-		assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size());
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec2<half>::operator[](tvec2<half>::size_type i) const
-	{
-		assert(/*i >= tvec2<half>::size_type(0) && */i < tvec2<half>::value_size());
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2() :
-		x(half(0.f)),
-		y(half(0.f))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec2<half> const & v
-	) :
-		x(v.x),
-		y(v.y)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		half const & s
-	) :
-		x(s),
-		y(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		half const & s1, 
-		half const & s2
-	) :
-		x(s1),
-		y(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tref2<half> const & r
-	) :
-		x(r.x),
-		y(r.y)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x))
-	{}
-
-	template <typename U, typename V> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		U const & x, 
-		V const & y
-	) :
-		x(half(x)),
-		y(half(y))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec2<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(	
-		tvec3<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec2<half>::tvec2
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator= 
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator+=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator-=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator*=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator/=
-	(
-		tvec2<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> & tvec2<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half>& tvec2<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec2<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec2<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec2<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec2<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref2<half> tvec2<half>::swizzle(comp x, comp y)
-	{
-		return tref2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	//////////////////////////////////////
-	// hvec3
-
-	GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::length() const
-	{
-		return 3;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::size_type tvec3<half>::value_size()
-	{
-		return 3;
-	}
-
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec3<half>::operator[]
-	(
-		tvec3<half>::size_type i
-	)
-	{
-		assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec3<half>::operator[]
-	(
-		tvec3<half>::size_type i
-	) const
-	{
-		assert(/*i >= tvec3<half>::size_type(0) &&*/ i < tvec3<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3() :
-		x(half(0)),
-		y(half(0)),
-		z(half(0))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec3<half> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		half const & s
-	) :
-		x(s),
-		y(s),
-		z(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		half const & s0, 
-		half const & s1, 
-		half const & s2
-	) :
-		x(s0),
-		y(s1),
-		z(s2)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tref3<half> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x)),
-		z(half(x))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		A const & x, 
-		B const & y, 
-		C const & z
-	) :
-		x(half(x)),
-		y(half(y)),
-		z(half(z))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec2<A> const & v, 
-		B const & s
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(s))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		A const & s, 
-		tvec2<B> const & v
-	) :
-		x(half(s)),
-		y(half(v.x)),
-		z(half(v.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec3<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec3<half>::tvec3
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator= 
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		this->z += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator+=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		this->z += v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		this->z -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator-=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		this->z -= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator*=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		this->z *= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator/=
-	(
-		tvec3<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		this->z /= v.z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> & tvec3<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec3<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec3<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec3<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec3<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref3<half> tvec3<half>::swizzle(comp x, comp y, comp z)
-	{
-		return tref3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	//////////////////////////////////////
-	// hvec4
-
-	GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::length() const
-	{
-		return 4;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::size_type tvec4<half>::value_size()
-	{
-		return 4;
-	}
-	
-	//////////////////////////////////////
-	// Accesses
-
-	GLM_FUNC_QUALIFIER half & tvec4<half>::operator[]
-	(
-		tvec4<half>::size_type i
-	)
-	{
-		assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	GLM_FUNC_QUALIFIER half const & tvec4<half>::operator[]
-	(
-		tvec4<half>::size_type i
-	) const
-	{
-		assert(/*i >= tvec4<half>::size_type(0) && */i < tvec4<half>::value_size());
-
-		return (&x)[i];
-	}
-
-	//////////////////////////////////////
-	// Implicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4() :
-		x(half(0)),
-		y(half(0)),
-		z(half(0)),
-		w(half(0))
-	{}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec4<half> const & v
-	) :
-		x(v.x),
-		y(v.y),
-		z(v.z),
-		w(v.w)
-	{}
-
-	//////////////////////////////////////
-	// Explicit basic constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		half const & s
-	) :
-		x(s),
-		y(s),
-		z(s),
-		w(s)
-	{}
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		half const & s1, 
-		half const & s2, 
-		half const & s3, 
-		half const & s4
-	) :
-		x(s1),
-		y(s2),
-		z(s3),
-		w(s4)
-	{}
-
-	//////////////////////////////////////
-	// Swizzle constructors
-
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tref4<half> const & r
-	) :
-		x(r.x),
-		y(r.y),
-		z(r.z),
-		w(r.w)
-	{}
-
-	//////////////////////////////////////
-	// Convertion scalar constructors
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		U const & x
-	) :
-		x(half(x)),
-		y(half(x)),
-		z(half(x)),
-		w(half(x))
-	{}
-
-	template <typename A, typename B, typename C, typename D> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & x, 
-		B const & y, 
-		C const & z, 
-		D const & w
-	) :
-		x(half(x)),
-		y(half(y)),
-		z(half(z)),
-		w(half(w))
-	{}
-
-	//////////////////////////////////////
-	// Convertion vector constructors
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec2<A> const & v, 
-		B const & s1, 
-		C const & s2
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(s1)),
-		w(half(s2))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s1, 
-		tvec2<B> const & v, 
-		C const & s2
-	) :
-		x(half(s1)),
-		y(half(v.x)),
-		z(half(v.y)),
-		w(half(s2))
-	{}
-
-	template <typename A, typename B, typename C> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s1, 
-		B const & s2, 
-		tvec2<C> const & v
-	) :
-		x(half(s1)),
-		y(half(s2)),
-		z(half(v.x)),
-		w(half(v.y))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec3<A> const & v, 
-		B const & s
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z)),
-		w(half(s))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		A const & s, 
-		tvec3<B> const & v
-	) :
-		x(half(s)),
-		y(half(v.x)),
-		z(half(v.y)),
-		w(half(v.z))
-	{}
-
-	template <typename A, typename B> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec2<A> const & v1, 
-		tvec2<B> const & v2
-	) :
-		x(half(v1.x)),
-		y(half(v1.y)),
-		z(half(v2.x)),
-		w(half(v2.y))
-	{}
-
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tvec4<half>::tvec4
-	(
-		tvec4<U> const & v
-	) :
-		x(half(v.x)),
-		y(half(v.y)),
-		z(half(v.z)),
-		w(half(v.w))
-	{}
-
-	//////////////////////////////////////
-	// Unary arithmetic operators
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator= 
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x = v.x;
-		this->y = v.y;
-		this->z = v.z;
-		this->w = v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+=
-	(
-		half const & s
-	)
-	{
-		this->x += s;
-		this->y += s;
-		this->z += s;
-		this->w += s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator+=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x += v.x;
-		this->y += v.y;
-		this->z += v.z;
-		this->w += v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-=
-	(
-		half const & s
-	)
-	{
-		this->x -= s;
-		this->y -= s;
-		this->z -= s;
-		this->w -= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator-=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x -= v.x;
-		this->y -= v.y;
-		this->z -= v.z;
-		this->w -= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*=
-	(
-		half const & s
-	)
-	{
-		this->x *= s;
-		this->y *= s;
-		this->z *= s;
-		this->w *= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator*=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x *= v.x;
-		this->y *= v.y;
-		this->z *= v.z;
-		this->w *= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/=
-	(
-		half const & s
-	)
-	{
-		this->x /= s;
-		this->y /= s;
-		this->z /= s;
-		this->w /= s;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator/=
-	(
-		tvec4<half> const & v
-	)
-	{
-		this->x /= v.x;
-		this->y /= v.y;
-		this->z /= v.z;
-		this->w /= v.w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator++()
-	{
-		++this->x;
-		++this->y;
-		++this->z;
-		++this->w;
-		return *this;
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half>& tvec4<half>::operator--()
-	{
-		--this->x;
-		--this->y;
-		--this->z;
-		--this->w;
-		return *this;
-	}
-
-	//////////////////////////////////////
-	// Swizzle operators
-
-	GLM_FUNC_QUALIFIER half tvec4<half>::swizzle(comp x) const
-	{
-		return (*this)[x];
-	}
-
-	GLM_FUNC_QUALIFIER tvec2<half> tvec4<half>::swizzle(comp x, comp y) const
-	{
-		return tvec2<half>(
-			(*this)[x],
-			(*this)[y]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec3<half> tvec4<half>::swizzle(comp x, comp y, comp z) const
-	{
-		return tvec3<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z]);
-	}
-
-	GLM_FUNC_QUALIFIER tvec4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w) const
-	{
-		return tvec4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-	GLM_FUNC_QUALIFIER tref4<half> tvec4<half>::swizzle(comp x, comp y, comp z, comp w)
-	{
-		return tref4<half>(
-			(*this)[x],
-			(*this)[y],
-			(*this)[z],
-			(*this)[w]);
-	}
-
-#endif//(GLM_COMPONENT == GLM_COMPONENT_CXX98)
-
-}//namespace detail
-}//namespace glm
diff --git a/thirdparty/glm/glm/gtc/matrix_transform.hpp b/thirdparty/glm/glm/gtc/matrix_transform.hpp
deleted file mode 100644
index b4ec5e22..00000000
--- a/thirdparty/glm/glm/gtc/matrix_transform.hpp
+++ /dev/null
@@ -1,291 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_matrix_transform
-/// @file glm/gtc/matrix_transform.hpp
-/// @date 2009-04-29 / 2011-05-16
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtx_transform
-/// @see gtx_transform2
-/// 
-/// @defgroup gtc_matrix_transform GLM_GTC_matrix_transform: Matrix transform functions
-/// @ingroup gtc
-/// 
-/// @brief Defines functions that generate common transformation matrices.
-/// 
-/// The matrices generated by this extension use standard OpenGL fixed-function
-/// conventions. For example, the lookAt function generates a transform from world
-/// space into the specific eye space that the projective matrix functions 
-/// (perspective, ortho, etc) are designed to expect. The OpenGL compatibility
-/// specifications defines the particular layout of this eye space.
-/// 
-/// <glm/gtc/matrix_transform.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_matrix_transform
-#define GLM_GTC_matrix_transform GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_matrix_transform extension included")
-#endif
-
-namespace glm
-{
-	/// @addtogroup gtc_matrix_transform
-	/// @{
-
-	/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
-	/// 
-	/// @param m Input matrix multiplied by this translation matrix.
-	/// @param v Coordinates of a translation vector.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @code
-	/// #include <glm/glm.hpp>
-	/// #include <glm/gtc/matrix_transform.hpp>
-	/// ...
-	/// glm::mat4 m = glm::translate(glm::mat4(1.0f), glm::vec3(1.0f));
-	/// // m[0][0] == 1.0f, m[0][1] == 0.0f, m[0][2] == 0.0f, m[0][3] == 0.0f
-	/// // m[1][0] == 0.0f, m[1][1] == 1.0f, m[1][2] == 0.0f, m[1][3] == 0.0f
-	/// // m[2][0] == 0.0f, m[2][1] == 0.0f, m[2][2] == 1.0f, m[2][3] == 0.0f
-	/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
-	/// @endcode
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - translate(T x, T y, T z)
-	/// @see - translate(detail::tmat4x4<T> const & m, T x, T y, T z)
-	/// @see - translate(detail::tvec3<T> const & v)
-	template <typename T> 
-	detail::tmat4x4<T> translate(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v);
-		
-	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees. 
-	/// 
-	/// @param m Input matrix multiplied by this rotation matrix.
-	/// @param angle Rotation angle expressed in degrees.
-	/// @param axis Rotation axis, recommanded to be normalized.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - rotate(T angle, T x, T y, T z) 
-	/// @see - rotate(detail::tmat4x4<T> const & m, T angle, T x, T y, T z) 
-	/// @see - rotate(T angle, detail::tvec3<T> const & v) 
-	template <typename T> 
-	detail::tmat4x4<T> rotate(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & axis);
-
-	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
-	/// 
-	/// @param m Input matrix multiplied by this scale matrix.
-	/// @param v Ratio of scaling for each axis.
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - scale(T x, T y, T z) scale(T const & x, T const & y, T const & z)
-	/// @see - scale(detail::tmat4x4<T> const & m, T x, T y, T z)
-	/// @see - scale(detail::tvec3<T> const & v)
-	template <typename T> 
-	detail::tmat4x4<T> scale(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v);
-
-	/// Creates a matrix for an orthographic parallel viewing volume.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @param zNear 
-	/// @param zFar 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	/// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top)
-	template <typename T> 
-	detail::tmat4x4<T> ortho(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top, 
-		T const & zNear, 
-		T const & zFar);
-
-	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    /// @see - glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar)
-	template <typename T> 
-	detail::tmat4x4<T> ortho(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top);
-
-	/// Creates a frustum matrix.
-	/// 
-	/// @param left 
-	/// @param right 
-	/// @param bottom 
-	/// @param top 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename T> 
-	detail::tmat4x4<T> frustum(
-		T const & left, 
-		T const & right, 
-		T const & bottom, 
-		T const & top, 
-		T const & near, 
-		T const & far);
-
-	/// Creates a matrix for a symetric perspective-view frustum.
-	/// 
-	/// @param fovy 
-	/// @param aspect 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename T> 
-	detail::tmat4x4<T> perspective(
-		T const & fovy, 
-		T const & aspect, 
-		T const & near, 
-		T const & far);
-
-	/// Builds a perspective projection matrix based on a field of view.
-	/// 
-	/// @param fov 
-	/// @param width 
-	/// @param height 
-	/// @param near 
-	/// @param far 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-	template <typename valType> 
-	detail::tmat4x4<valType> perspectiveFov(
-		valType const & fov, 
-		valType const & width, 
-		valType const & height, 
-		valType const & near, 
-		valType const & far);
-
-	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
-	/// 
-	/// @param fovy 
-	/// @param aspect 
-	/// @param near 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    template <typename T> 
-	detail::tmat4x4<T> infinitePerspective(
-		T fovy, T aspect, T near);
-
-	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
-	/// 
-	/// @param fovy 
-	/// @param aspect 
-	/// @param near 
-	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
-	/// @see gtc_matrix_transform
-    template <typename T> 
-	detail::tmat4x4<T> tweakedInfinitePerspective(
-		T fovy, T aspect, T near);
-
-	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
-	/// 
-	/// @param obj 
-	/// @param model 
-	/// @param proj
-	/// @param viewport 
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tvec3<T> project(
-		detail::tvec3<T> const & obj, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport);
-
-	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
-	/// 
-	/// @param win 
-	/// @param model 
-	/// @param proj
-	/// @param viewport 
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tvec3<T> unProject(
-		detail::tvec3<T> const & win, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport);
-
-	/// Define a picking region
-	/// 
-	/// @param center 
-	/// @param delta 
-	/// @param viewport
-	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
-	/// @tparam U Currently supported: Floating-point types and integer types.
-	/// @see gtc_matrix_transform
-	template <typename T, typename U> 
-	detail::tmat4x4<T> pickMatrix(
-		detail::tvec2<T> const & center, 
-		detail::tvec2<T> const & delta, 
-		detail::tvec4<U> const & viewport);
-
-	/// Build a look at view matrix.
-	/// 
-	/// @param eye Position of the camera
-	/// @param center Position where the camera is looking at
-	/// @param up Normalized up vector, how the camera is oriented. Typically (0, 0, 1)
-	/// @see gtc_matrix_transform
-	/// @see - frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal) frustum(T const & left, T const & right, T const & bottom, T const & top, T const & nearVal, T const & farVal)
-	template <typename T> 
-	detail::tmat4x4<T> lookAt(
-		detail::tvec3<T> const & eye, 
-		detail::tvec3<T> const & center, 
-		detail::tvec3<T> const & up);
-
-	/// @}
-}//namespace glm
-
-#include "matrix_transform.inl"
-
-#endif//GLM_GTC_matrix_transform
diff --git a/thirdparty/glm/glm/gtc/matrix_transform.inl b/thirdparty/glm/glm/gtc/matrix_transform.inl
deleted file mode 100644
index f2a1c80c..00000000
--- a/thirdparty/glm/glm/gtc/matrix_transform.inl
+++ /dev/null
@@ -1,410 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_matrix_transform
-/// @file glm/gtc/matrix_transform.inl
-/// @date 2009-04-29 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		return Result;
-	}
-		
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-	{
-		T a = radians(angle);
-		T c = cos(a);
-		T s = sin(a);
-
-		detail::tvec3<T> axis = normalize(v);
-
-		detail::tvec3<T> temp = (T(1) - c) * axis;
-
-		detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
-		Rotate[0][0] = c + temp[0] * axis[0];
-		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-
-		Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
-		Rotate[1][1] = c + temp[1] * axis[1];
-		Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
-
-		Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-		Rotate[2][2] = c + temp[2] * axis[2];
-
-		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-		Result[3] = m[3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * v[0];
-		Result[1] = m[1] * v[1];
-		Result[2] = m[2] * v[2];
-		Result[3] = m[3];
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(T(1));
-		Result[3] = detail::tvec4<T>(v, T(1));
-		return m * Result;
-
-		//detail::tmat4x4<valType> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
-		//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
-		//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
-		//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
-		//return Result;
-	}
-		
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-	{
-		T a = radians(angle);
-		T c = cos(a);
-		T s = sin(a);
-		detail::tmat4x4<T> Result;
-
-		detail::tvec3<T> axis = normalize(v);
-
-		Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
-		Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
-		Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
-		Result[0][3] = 0;
-
-		Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
-		Result[1][1] = c + (1 - c) * axis.y * axis.y;
-		Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
-		Result[1][3] = 0;
-
-		Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
-		Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
-		Result[2][2] = c + (1 - c) * axis.z * axis.z;
-		Result[2][3] = 0;
-
-		Result[3] = detail::tvec4<T>(0, 0, 0, 1);
-		return m * Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-	{
-		detail::tmat4x4<T> Result(T(1));
-		Result[0][0] = v.x;
-		Result[1][1] = v.y;
-		Result[2][2] = v.z;
-		return m * Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(2) / (zFar - zNear);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(1);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & nearVal, 
-		valType const & farVal
-	)
-	{
-		detail::tmat4x4<valType> Result(0);
-		Result[0][0] = (valType(2) * nearVal) / (right - left);
-		Result[1][1] = (valType(2) * nearVal) / (top - bottom);
-		Result[2][0] = (right + left) / (right - left);
-		Result[2][1] = (top + bottom) / (top - bottom);
-		Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
-		Result[2][3] = valType(-1);
-		Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
-	(
-		valType const & fovy, 
-		valType const & aspect, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		valType range = tan(radians(fovy / valType(2))) * zNear;	
-		valType left = -range * aspect;
-		valType right = range * aspect;
-		valType bottom = -range;
-		valType top = range;
-
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = (valType(2) * zNear) / (right - left);
-		Result[1][1] = (valType(2) * zNear) / (top - bottom);
-		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = - valType(1);
-		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
-	(
-		valType const & fov, 
-		valType const & width, 
-		valType const & height, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		valType rad = glm::radians(fov);
-		valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
-		valType w = h * height / width;
-
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = w;
-		Result[1][1] = h;
-		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = - valType(1);
-		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-		T range = tan(radians(fovy / T(2))) * zNear;	
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = - T(1);
-		Result[2][3] = - T(1);
-		Result[3][2] = - T(2) * zNear;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-		T range = tan(radians(fovy / T(2))) * zNear;	
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = T(0.0001) - T(1);
-		Result[2][3] = T(-1);
-		Result[3][2] = - (T(0.0001) - T(2)) * zNear;
-		return Result;
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> project
-	(
-		detail::tvec3<T> const & obj, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
-		tmp = model * tmp;
-		tmp = proj * tmp;
-
-		tmp /= tmp.w;
-		tmp = tmp * T(0.5) + T(0.5);
-		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
-		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
-
-		return detail::tvec3<T>(tmp);
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
-	(
-		detail::tvec3<T> const & win, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tmat4x4<T> inverse = glm::inverse(proj * model);
-
-		detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
-		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
-		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
-		tmp = tmp * T(2) - T(1);
-
-		detail::tvec4<T> obj = inverse * tmp;
-		obj /= obj.w;
-
-		return detail::tvec3<T>(obj);
-	}
-
-	template <typename T, typename U> 
-	detail::tmat4x4<T> pickMatrix
-	(
-		detail::tvec2<T> const & center, 
-		detail::tvec2<T> const & delta, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		assert(delta.x > T(0) && delta.y > T(0));
-		detail::tmat4x4<T> Result(1.0f);
-
-		if(!(delta.x > T(0) && delta.y > T(0))) 
-			return Result; // Error
-
-		detail::tvec3<T> Temp(
-			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
-			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
-			T(0));
-
-		// Translate and scale the picked region to the entire window
-		Result = translate(Result, Temp);
-		return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
-	(
-		detail::tvec3<T> const & eye,
-		detail::tvec3<T> const & center,
-		detail::tvec3<T> const & up
-	)
-	{
-		detail::tvec3<T> f = normalize(center - eye);
-		detail::tvec3<T> u = normalize(up);
-		detail::tvec3<T> s = normalize(cross(f, u));
-		u = cross(s, f);
-
-		detail::tmat4x4<T> Result(1);
-		Result[0][0] = s.x;
-		Result[1][0] = s.y;
-		Result[2][0] = s.z;
-		Result[0][1] = u.x;
-		Result[1][1] = u.y;
-		Result[2][1] = u.z;
-		Result[0][2] =-f.x;
-		Result[1][2] =-f.y;
-		Result[2][2] =-f.z;
-		Result[3][0] =-dot(s, eye);
-		Result[3][1] =-dot(u, eye);
-		Result[3][2] = dot(f, eye);
-		return Result;
-	}
-}//namespace glm
diff --git a/thirdparty/glm/glm/gtc/quaternion.hpp b/thirdparty/glm/glm/gtc/quaternion.hpp
deleted file mode 100644
index 037d16c7..00000000
--- a/thirdparty/glm/glm/gtc/quaternion.hpp
+++ /dev/null
@@ -1,282 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_quaternion
-/// @file glm/gtc/quaternion.hpp
-/// @date 2009-05-21 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// 
-/// @defgroup gtc_quaternion GLM_GTC_quaternion: Quaternion types and functions
-/// @ingroup gtc
-/// 
-/// @brief Defines a templated quaternion type and several quaternion operations.
-/// 
-/// <glm/gtc/quaternion.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_quaternion
-#define GLM_GTC_quaternion GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_quaternion extension included")
-#endif
-
-namespace glm{
-namespace detail
-{
-	/// @brief Template for quaternion. 
-	/// @see gtc_quaternion
-	/// @ingroup gtc_quaternion
-	template <typename T> 
-	struct tquat// : public genType<T, tquat>
-	{
-        enum ctor{null};
-        
-        typedef T value_type;
-        typedef std::size_t size_type;
-
-	public:
-		value_type x, y, z, w;
-        
-        GLM_FUNC_DECL size_type length() const;
-
-		// Constructors
-		tquat();
-		explicit tquat(
-			value_type const & s, 
-			glm::detail::tvec3<T> const & v);
-		explicit tquat(
-			value_type const & w, 
-			value_type const & x, 
-			value_type const & y, 
-			value_type const & z);
-
-		// Convertions
-		//explicit tquat(valType const & pitch, valType const & yaw, valType const & roll);
-		//! Build a quaternion from euler angles (pitch, yaw, roll), in radians.
-		explicit tquat(
-			tvec3<T> const & eulerAngles);
-		explicit tquat(
-			tmat3x3<T> const & m);
-		explicit tquat(
-			tmat4x4<T> const & m);
-
-		// Accesses
-		value_type & operator[](int i);
-		value_type const & operator[](int i) const;
-
-		// Operators
-		tquat<T> & operator*=(value_type const & s);
-		tquat<T> & operator/=(value_type const & s);
-	};
-
-	template <typename T> 
-	detail::tquat<T> operator- (
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator+ ( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p); 
-
-	template <typename T> 
-	detail::tquat<T> operator* ( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p); 
-
-	template <typename T> 
-	detail::tvec3<T> operator* (
-		detail::tquat<T> const & q, 
-		detail::tvec3<T> const & v);
-
-	template <typename T> 
-	detail::tvec3<T> operator* (
-		detail::tvec3<T> const & v,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tvec4<T> operator* (
-		detail::tquat<T> const & q, 
-		detail::tvec4<T> const & v);
-
-	template <typename T> 
-	detail::tvec4<T> operator* (
-		detail::tvec4<T> const & v,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator* (
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s);
-
-	template <typename T> 
-	detail::tquat<T> operator* (
-		typename detail::tquat<T>::value_type const & s,
-		detail::tquat<T> const & q);
-
-	template <typename T> 
-	detail::tquat<T> operator/ (
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s);
-
-} //namespace detail
-
-	/// @addtogroup gtc_quaternion
-	/// @{
-
-	/// Returns the length of the quaternion. 
-	/// 
-	/// @see gtc_quaternion
-    template <typename T> 
-    T length(
-		detail::tquat<T> const & q);
-
-    /// Returns the normalized quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> normalize(
-		detail::tquat<T> const & q);
-		
-    /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	T dot(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2);
-
-	/// Returns a SLERP interpolated quaternion of x and y according a. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> mix(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a);
-		
-	/// Returns the q conjugate. 
-	/// 
-	/// @see gtc_quaternion
-    template <typename T> 
-	detail::tquat<T> conjugate(
-		detail::tquat<T> const & q);
-
-	/// Returns the q inverse. 
-	/// 
-	/// @see gtc_quaternion
-    template <typename T> 
-	detail::tquat<T> inverse(
-		detail::tquat<T> const & q);
-
-	/// Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> rotate(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & angle, 
-		detail::tvec3<T> const & v);
-
-	/// Returns euler angles, yitch as x, yaw as y, roll as z. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tvec3<T> eulerAngles(
-        detail::tquat<T> const & x);
-    
-	/// Converts a quaternion to a 3 * 3 matrix. 
-	/// 
-	/// @see gtc_quaternion
-    template <typename T> 
-	detail::tmat3x3<T> mat3_cast(
-		detail::tquat<T> const & x);
-
-	/// Converts a quaternion to a 4 * 4 matrix. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tmat4x4<T> mat4_cast(
-		detail::tquat<T> const & x);
-
-	/// Converts a 3 * 3 matrix to a quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> quat_cast(
-		detail::tmat3x3<T> const & x);
-
-	/// Converts a 4 * 4 matrix to a quaternion. 
-	/// 
-	/// @see gtc_quaternion
-	template <typename T> 
-	detail::tquat<T> quat_cast(
-		detail::tmat4x4<T> const & x);
-
-	/// Quaternion of floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-    typedef detail::tquat<float> quat;
-
-	/// Quaternion of half-precision floating-point numbers.
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<detail::half>	hquat;
-
-	/// Quaternion of single-precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<float>	fquat;
-
-	/// Quaternion of double-precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<double>	dquat;
-
-	/// Quaternion of low precision floating-point numbers.
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<lowp_float>		lowp_quat;
-
-	/// Quaternion of medium precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<mediump_float>	mediump_quat;
-
-	/// Quaternion of high precision floating-point numbers. 
-	/// 
-	/// @see gtc_quaternion
-	typedef detail::tquat<highp_float>		highp_quat;
-
-	/// @}
-} //namespace glm
-
-#include "quaternion.inl"
-
-#endif//GLM_GTC_quaternion
diff --git a/thirdparty/glm/glm/gtc/quaternion.inl b/thirdparty/glm/glm/gtc/quaternion.inl
deleted file mode 100644
index 607a7209..00000000
--- a/thirdparty/glm/glm/gtc/quaternion.inl
+++ /dev/null
@@ -1,614 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_quaternion
-/// @file glm/gtc/quaternion.inl
-/// @date 2009-05-21 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include <limits>
-
-namespace glm{
-namespace detail
-{
-    template <typename T>
-    GLM_FUNC_QUALIFIER typename tquat<T>::size_type tquat<T>::length() const
-    {
-        return 4;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T>::tquat() : 
-        x(0),
-        y(0),
-        z(0),
-        w(1)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		value_type const & s, 
-		tvec3<T> const & v
-	) : 
-        x(v.x),
-        y(v.y),
-        z(v.z),
-        w(s)
-    {}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		value_type const & w, 
-		value_type const & x, 
-		value_type const & y, 
-		value_type const & z
-	) :
-        x(x),
-        y(y),
-        z(z),
-        w(w)
-    {}
-
-    //////////////////////////////////////////////////////////////
-    // tquat conversions
-
-	//template <typename valType> 
-	//GLM_FUNC_QUALIFIER tquat<valType>::tquat
-	//(
-	//	valType const & pitch, 
-	//	valType const & yaw, 
-	//	valType const & roll
-	//)
-	//{
-	//	tvec3<valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
-	//	tvec3<valType> c = glm::cos(eulerAngle * valType(0.5));
-	//	tvec3<valType> s = glm::sin(eulerAngle * valType(0.5));
-	//	
-	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
-	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
-	//	this->y = c.x * s.y * c.z + s.x * c.y * s.z;
-	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
-	//}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tvec3<T> const & eulerAngle
-	)
-	{
-		tvec3<T> c = glm::cos(eulerAngle * value_type(0.5));
-		tvec3<T> s = glm::sin(eulerAngle * value_type(0.5));
-		
-		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
-		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
-		this->y = c.x * s.y * c.z + s.x * c.y * s.z;
-		this->z = c.x * c.y * s.z - s.x * s.y * c.z;		
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tmat3x3<T> const & m
-	)
-    {
-		*this = quat_cast(m);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T>::tquat
-	(
-		tmat4x4<T> const & m
-	)
-    {
-		*this = quat_cast(m);
-    }
-
-    //////////////////////////////////////////////////////////////
-    // tquat<T> accesses
-
-    template <typename T> 
-	GLM_FUNC_QUALIFIER typename tquat<T>::value_type & tquat<T>::operator [] (int i)
-    {
-        return (&x)[i];
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER typename tquat<T>::value_type const & tquat<T>::operator [] (int i) const
-    {
-        return (&x)[i];
-    }
-
-    //////////////////////////////////////////////////////////////
-    // tquat<valType> operators
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator *=
-	(
-		value_type const & s
-	)
-    {
-        this->w *= s;
-        this->x *= s;
-        this->y *= s;
-        this->z *= s;
-        return *this;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator /=
-	(
-		value_type const & s
-	)
-    {
-        this->w /= s;
-        this->x /= s;
-        this->y /= s;
-        this->z /= s;
-        return *this;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // tquat<valType> external operators
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator- 
-	(
-		detail::tquat<T> const & q
-	)
-	{
-		return detail::tquat<T>(-q.w, -q.x, -q.y, -q.z);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator+
-	( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p
-	) 
-	{ 
-        return detail::tquat<T>(
-            q.w + p.w,
-	        q.x + p.x,
-	        q.y + p.y,
-	        q.z + p.z);
-	} 
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator*
-	( 
-		detail::tquat<T> const & q, 
-		detail::tquat<T> const & p
-	) 
-	{ 
-        return detail::tquat<T>(
-            q.w * p.w - q.x * p.x - q.y * p.y - q.z * p.z,
-	        q.w * p.x + q.x * p.w + q.y * p.z - q.z * p.y,
-	        q.w * p.y + q.y * p.w + q.z * p.x - q.x * p.z,
-	        q.w * p.z + q.z * p.w + q.x * p.y - q.y * p.x);
-	} 
-
-	// Transformation
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec3<T> const & v
-	)
-	{
-		typename detail::tquat<T>::value_type Two(2);
-
-		detail::tvec3<T> uv, uuv;
-		detail::tvec3<T> QuatVector(q.x, q.y, q.z);
-		uv = glm::cross(QuatVector, v);
-		uuv = glm::cross(QuatVector, uv);
-		uv *= (Two * q.w); 
-		uuv *= Two; 
-
-		return v + uv + uuv;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
-	(
-		detail::tvec3<T> const & v,
-		detail::tquat<T> const & q 
-	)
-	{
-		return inverse(q) * v;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		detail::tvec4<T> const & v
-	)
-	{
-		return detail::tvec4<T>(q * detail::tvec3<T>(v), v.w);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
-	(
-		detail::tvec4<T> const & v,
-		detail::tquat<T> const & q 
-	)
-	{
-		return inverse(q) * v;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s
-	)
-	{
-		return detail::tquat<T>(
-			q.w * s, q.x * s, q.y * s, q.z * s);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
-	(
-		typename detail::tquat<T>::value_type const & s,
-		detail::tquat<T> const & q
-	)
-	{
-		return q * s;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tquat<T> operator/ 
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & s
-	)
-	{
-		return detail::tquat<T>(
-			q.w / s, q.x / s, q.y / s, q.z / s);
-	}
-
-	//////////////////////////////////////
-	// Boolean operators
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator==
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER bool operator!=
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-	{
-		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
-	}
-
-}//namespace detail
-
-	////////////////////////////////////////////////////////
-    template <typename T> 
-	GLM_FUNC_QUALIFIER T length
-	(
-		detail::tquat<T> const & q
-	)
-    {
-		return glm::sqrt(dot(q, q));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> normalize
-	(
-		detail::tquat<T> const & q
-	)
-    {
-        typename detail::tquat<T>::value_type len = length(q);
-        if(len <= typename detail::tquat<T>::value_type(0)) // Problem
-            return detail::tquat<T>(1, 0, 0, 0);
-        typename detail::tquat<T>::value_type oneOverLen = typename detail::tquat<T>::value_type(1) / len;
-        return detail::tquat<T>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T dot
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-    {
-        return q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> cross
-	(
-		detail::tquat<T> const & q1, 
-		detail::tquat<T> const & q2
-	)
-    {
-        return detail::tquat<T>(
-            q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
-	        q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
-	        q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
-	        q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x);
-    }
-/*
-	// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tquat<T> mix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		typename detail::tquat<T>::value_type const & a
-	)
-    {
-        if(a <= typename detail::tquat<T>::value_type(0)) return x;
-        if(a >= typename detail::tquat<T>::value_type(1)) return y;
-
-        float fCos = dot(x, y);
-        detail::tquat<T> y2(y); //BUG!!! tquat<T> y2;
-        if(fCos < typename detail::tquat<T>::value_type(0))
-        {
-            y2 = -y;
-            fCos = -fCos;
-        }
-
-        //if(fCos > 1.0f) // problem
-        float k0, k1;
-        if(fCos > typename detail::tquat<T>::value_type(0.9999))
-        {
-            k0 = typename detail::tquat<T>::value_type(1) - a;
-            k1 = typename detail::tquat<T>::value_type(0) + a; //BUG!!! 1.0f + a;
-        }
-        else
-        {
-            typename detail::tquat<T>::value_type fSin = sqrt(T(1) - fCos * fCos);
-            typename detail::tquat<T>::value_type fAngle = atan(fSin, fCos);
-            typename detail::tquat<T>::value_type fOneOverSin = T(1) / fSin;
-            k0 = sin((typename detail::tquat<T>::value_type(1) - a) * fAngle) * fOneOverSin;
-            k1 = sin((typename detail::tquat<T>::value_type(0) + a) * fAngle) * fOneOverSin;
-        }
-
-        return detail::tquat<T>(
-            k0 * x.w + k1 * y2.w,
-            k0 * x.x + k1 * y2.x,
-            k0 * x.y + k1 * y2.y,
-            k0 * x.z + k1 * y2.z);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tquat<T> mix2
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-    {
-        bool flip = false;
-		if(a <= T(0)) return x;
-        if(a >= T(1)) return y;
-
-        T cos_t = dot(x, y);
-		if(cos_t < T(0))
-		{
-			cos_t = -cos_t;
-			flip = true;
-		}
-
-		T alpha(0), beta(0);
-
-		if(T(1) - cos_t < 1e-7)
-			beta = T(1) - alpha;
-		else
-		{
-			T theta = acos(cos_t);
-			T sin_t = sin(theta);
-			beta = sin(theta * (T(1) - alpha)) / sin_t;
-			alpha = sin(alpha * theta) / sin_t;
-		}
-
-		if(flip)
-			alpha = -alpha;
-		
-        return normalize(beta * x + alpha * y);
-    }
-*/
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tquat<T> mix
-	(
-		detail::tquat<T> const & x, 
-		detail::tquat<T> const & y, 
-		T const & a
-	)
-    {
-		T angle = acos(dot(x, y));
-		return (glm::sin((T(1) - a) * angle) * x + glm::sin(a * angle) * y) / glm::sin(angle);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> conjugate
-	(
-		detail::tquat<T> const & q
-	)
-    {
-        return detail::tquat<T>(q.w, -q.x, -q.y, -q.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> inverse
-	(
-		detail::tquat<T> const & q
-	)
-    {
-        return conjugate(q) / dot(q, q);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> rotate
-	(
-		detail::tquat<T> const & q, 
-		typename detail::tquat<T>::value_type const & angle, 
-		detail::tvec3<T> const & v
-	)
-    {
-		detail::tvec3<T> Tmp = v;
-
-        // Axis of rotation must be normalised
-        typename detail::tquat<T>::value_type len = glm::length(Tmp);
-        if(abs(len - T(1)) > T(0.001))
-        {
-            T oneOverLen = T(1) / len;
-            Tmp.x *= oneOverLen;
-            Tmp.y *= oneOverLen;
-            Tmp.z *= oneOverLen;
-        }
-
-        typename detail::tquat<T>::value_type AngleRad = radians(angle);
-        typename detail::tquat<T>::value_type fSin = sin(AngleRad * T(0.5));
-
-		return q * detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin);
-        //return gtc::quaternion::cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> eulerAngles
-	(
-        detail::tquat<T> const & x
-    )
-	{
-		return detail::tvec3<T>(pitch(x), yaw(x), roll(x));
-	}
-    
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> mat3_cast
-	(
-		detail::tquat<T> const & q
-	)
-    {
-        detail::tmat3x3<T> Result(T(1));
-        Result[0][0] = 1 - 2 * q.y * q.y - 2 * q.z * q.z;
-        Result[0][1] = 2 * q.x * q.y + 2 * q.w * q.z;
-        Result[0][2] = 2 * q.x * q.z - 2 * q.w * q.y;
-
-        Result[1][0] = 2 * q.x * q.y - 2 * q.w * q.z;
-        Result[1][1] = 1 - 2 * q.x * q.x - 2 * q.z * q.z;
-        Result[1][2] = 2 * q.y * q.z + 2 * q.w * q.x;
-
-        Result[2][0] = 2 * q.x * q.z + 2 * q.w * q.y;
-        Result[2][1] = 2 * q.y * q.z - 2 * q.w * q.x;
-        Result[2][2] = 1 - 2 * q.x * q.x - 2 * q.y * q.y;
-        return Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> mat4_cast
-	(
-		detail::tquat<T> const & q
-	)
-    {
-        return detail::tmat4x4<T>(mat3_cast(q));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
-	(
-		detail::tmat3x3<T> const & m
-	)
-    {
-        typename detail::tquat<T>::value_type fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
-        typename detail::tquat<T>::value_type fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
-        typename detail::tquat<T>::value_type fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
-        typename detail::tquat<T>::value_type fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
-        
-        int biggestIndex = 0;
-        typename detail::tquat<T>::value_type fourBiggestSquaredMinus1 = fourWSquaredMinus1;
-        if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
-        {
-            fourBiggestSquaredMinus1 = fourXSquaredMinus1;
-            biggestIndex = 1;
-        }
-        if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
-        {
-            fourBiggestSquaredMinus1 = fourYSquaredMinus1;
-            biggestIndex = 2;
-        }
-        if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
-        {
-            fourBiggestSquaredMinus1 = fourZSquaredMinus1;
-            biggestIndex = 3;
-        }
-
-        typename detail::tquat<T>::value_type biggestVal = sqrt(fourBiggestSquaredMinus1 + T(1)) * T(0.5);
-        typename detail::tquat<T>::value_type mult = T(0.25) / biggestVal;
-
-        detail::tquat<T> Result;
-        switch(biggestIndex)
-        {
-        case 0:
-            Result.w = biggestVal; 
-            Result.x = (m[1][2] - m[2][1]) * mult;
-            Result.y = (m[2][0] - m[0][2]) * mult;
-            Result.z = (m[0][1] - m[1][0]) * mult;
-            break;
-        case 1:
-            Result.w = (m[1][2] - m[2][1]) * mult;
-            Result.x = biggestVal;
-            Result.y = (m[0][1] + m[1][0]) * mult;
-            Result.z = (m[2][0] + m[0][2]) * mult;
-            break;
-        case 2:
-            Result.w = (m[2][0] - m[0][2]) * mult;
-            Result.x = (m[0][1] + m[1][0]) * mult;
-            Result.y = biggestVal;
-            Result.z = (m[1][2] + m[2][1]) * mult;
-            break;
-        case 3:
-            Result.w = (m[0][1] - m[1][0]) * mult;
-            Result.x = (m[2][0] + m[0][2]) * mult;
-            Result.y = (m[1][2] + m[2][1]) * mult;
-            Result.z = biggestVal;
-            break;
-        }
-        return Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
-	(
-		detail::tmat4x4<T> const & m4
-	)
-    {
-		return quat_cast(detail::tmat3x3<T>(m4));
-    }
-
-}//namespace glm
diff --git a/thirdparty/glm/glm/gtc/type_ptr.hpp b/thirdparty/glm/glm/gtc/type_ptr.hpp
deleted file mode 100644
index f4e9b70c..00000000
--- a/thirdparty/glm/glm/gtc/type_ptr.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_type_ptr
-/// @file glm/gtc/type_ptr.hpp
-/// @date 2009-05-06 / 2011-06-05
-/// @author Christophe Riccio
-///
-/// @see core (dependence)
-/// @see gtc_half_float (dependence)
-/// @see gtc_quaternion (dependence)
-///
-/// @defgroup gtc_type_ptr GLM_GTC_type_ptr: Memory layout access
-/// @ingroup gtc
-///
-/// @brief Handles the interaction between pointers and vector, matrix types.
-/// 
-/// This extension defines an overloaded function, glm::value_ptr, which
-/// takes any of the \ref core_template "core template types". It returns
-/// a pointer to the memory layout of the object. Matrix types store their values
-/// in column-major order.
-/// 
-/// This is useful for uploading data to matrices or copying data to buffer objects.
-///
-/// Example:
-/// @code
-/// #include <glm/glm.hpp>
-/// #include <glm/gtc/type_ptr.hpp>
-/// 
-/// glm::vec3 aVector(3);
-/// glm::mat4 someMatrix(1.0);
-/// 
-/// glUniform3fv(uniformLoc, 1, glm::value_ptr(aVector));
-/// glUniformMatrix4fv(uniformMatrixLoc, 1, GL_FALSE, glm::value_ptr(someMatrix));
-/// @endcode
-/// 
-/// <glm/gtc/type_ptr.hpp> need to be included to use these functionalities.
-///////////////////////////////////////////////////////////////////////////////////
-
-#ifndef GLM_GTC_type_ptr
-#define GLM_GTC_type_ptr GLM_VERSION
-
-// Dependency:
-#include "../glm.hpp"
-#include "../gtc/half_float.hpp"
-#include "../gtc/quaternion.hpp"
-#include <cstring>
-
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
-#	pragma message("GLM: GLM_GTC_type_ptr extension included")
-#endif
-
-namespace glm
-{ 
-	/// @addtogroup gtc_type_ptr
-	/// @{
-    
-	/// Return the constant address to the data of the input parameter.
-    /// @see gtc_type_ptr
-	template<typename genType>
-    typename genType::value_type const * value_ptr(genType const & vec);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec2<T> make_vec2(T const * const ptr);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec3<T> make_vec3(T const * const ptr);
-
-	/// Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tvec4<T> make_vec4(T const * const ptr);
-
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x2<T> make_mat2x2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x3<T> make_mat2x3(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x4<T> make_mat2x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x2<T> make_mat3x2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x3<T> make_mat3x3(T const * const ptr);
-
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x4<T> make_mat3x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x2<T> make_mat4x2(
-        T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x3<T> make_mat4x3(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x4<T> make_mat4x4(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat2x2<T> make_mat2(T const * const ptr);
-        
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat3x3<T> make_mat3(T const * const ptr);
-		
-	/// Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tmat4x4<T> make_mat4(T const * const ptr);
- 
-	/// Build a quaternion from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-    detail::tquat<T> make_quat(T const * const ptr);
-    
-	/// @}
-}//namespace glm
-
-#include "type_ptr.inl"
-
-#endif//GLM_GTC_type_ptr
-
diff --git a/thirdparty/glm/glm/gtc/type_ptr.inl b/thirdparty/glm/glm/gtc/type_ptr.inl
deleted file mode 100644
index f1638d28..00000000
--- a/thirdparty/glm/glm/gtc/type_ptr.inl
+++ /dev/null
@@ -1,462 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// 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 gtc_type_ptr
-/// @file glm/gtc/type_ptr.inl
-/// @date 2011-06-15 / 2011-12-07
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm
-{ 
-	/// @addtogroup gtc_type_ptr
-	/// @{
-
-	/// Return the constant address to the data of the input parameter.
-    /// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tvec2<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tvec2<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tvec3<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tvec3<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(	
-		detail::tvec4<T> const & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	//! From GLM_GTC_type_ptr extension.
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		detail::tvec4<T> & vec
-	)
-	{
-		return &(vec.x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x3<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	//! From GLM_GTC_type_ptr extension.
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat4x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x3<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat2x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat2x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x2<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(	
-		detail::tmat4x2<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat3x4<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr
-	(
-		detail::tmat3x4<T> & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-		
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-		detail::tmat4x3<T> const & mat
-	)
-	{
-		return &(mat[0].x);
-	}
-    
-	//! Return the constant address to the data of the input parameter.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T const * value_ptr
-	(
-        detail::tquat<T> const & q
-    )
-	{
-		return &(q[0]);
-	}
-    
-	//! Get the address of the matrix content.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
-	{
-		return &(mat[0].x);
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
-	{
-		detail::tvec2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
-		return Result;
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
-	{
-		detail::tvec3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
-		return Result;
-	}
-
-	//! Build a vector from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
-	{
-		detail::tvec4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
-		return Result;
-	}
-
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
-	{
-		detail::tmat2x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
-	{
-		detail::tmat2x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
-	{
-		detail::tmat2x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
-	{
-		detail::tmat3x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
-	{
-		detail::tmat3x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
-		return Result;
-	}
-
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
-	{
-		detail::tmat3x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
-	{
-		detail::tmat4x2<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
-	{
-		detail::tmat4x3<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
-	{
-		detail::tmat4x4<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
-		return Result;
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
-	{
-		return make_mat2x2(ptr);
-	}
-        
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
-	{
-		return make_mat3x3(ptr);
-	}
-		
-	//! Build a matrix from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
-	{
-		return make_mat4x4(ptr);
-	}
- 
-	//! Build a quaternion from a pointer.
-	/// @see gtc_type_ptr
-	template<typename T>
-	GLM_FUNC_QUALIFIER detail::tquat<T> make_quat(T const * const ptr)
-	{
-		detail::tquat<T> Result;
-		memcpy(value_ptr(Result), ptr, sizeof(detail::tquat<T>));
-		return Result;
-	}
-    
-	/// @}
-}//namespace glm
-
diff --git a/thirdparty/glm/readme.txt b/thirdparty/glm/readme.txt
deleted file mode 100644
index c65e7a5a..00000000
--- a/thirdparty/glm/readme.txt
+++ /dev/null
@@ -1,524 +0,0 @@
-================================================================================
-OpenGL Mathematics (GLM)
---------------------------------------------------------------------------------
-glm.g-truc.net
-glm@g-truc.net
-
-================================================================================
-The MIT License
---------------------------------------------------------------------------------
-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.
-
-================================================================================
-GLM Usage
---------------------------------------------------------------------------------
-GLM is a header only library, there is nothing to build, just include it.
-#include <glm/glm.hpp>
-
-More informations in GLM manual:
-http://glm.g-truc.net/glm-0.9.3.pdf
-
-================================================================================
-GLM 0.9.3.4: 2012-06-30
---------------------------------------------------------------------------------
-- Added SSE4 and AVX2 detection.
-- Removed VIRTREV_xstream and the incompatibility generated with GCC
-- Fixed C++11 compiler option for GCC
-- Removed MS language extension option for GCC (not fonctionnal)
-- Fixed bitfieldExtract for vector types
-- Fixed warnings
-- Fixed SSE includes
-
-================================================================================
-GLM 0.9.3.3: 2012-05-10
---------------------------------------------------------------------------------
-- Fixed isinf and isnan
-- Improved compatibility with Intel compiler
-- Added CMake test build options: SIMD, C++11, fast math and MS land ext
-- Fixed SIMD mat4 test on GCC
-- Fixed perspectiveFov implementation
-- Fixed matrixCompMult for none-square matrices
-- Fixed namespace issue on stream operators
-- Fixed various warnings
-- Added VC11 support
-
-================================================================================
-GLM 0.9.3.2: 2012-03-15
---------------------------------------------------------------------------------
-- Fixed doxygen documentation
-- Fixed Clang version detection
-- Fixed simd mat4 /= operator
-
-================================================================================
-GLM 0.9.3.1: 2012-01-25
---------------------------------------------------------------------------------
-- Fixed platform detection
-- Fixed warnings
-- Removed detail code from Doxygen doc
-
-================================================================================
-GLM 0.9.3.0: 2012-01-09
---------------------------------------------------------------------------------
-- Added CPP Check project
-- Fixed conflict with Windows headers
-- Fixed isinf implementation
-- Fixed Boost conflict
-- Fixed warnings
-
-================================================================================
-GLM 0.9.3.B: 2011-12-12
---------------------------------------------------------------------------------
-- Added support for Chrone Native Client
-- Added epsilon constant
-- Removed value_size function from vector types
-- Fixed roundEven on GCC
-- Improved API documentation
-- Fixed modf implementation
-- Fixed step function accuracy
-- Fixed outerProduct
-
-================================================================================
-GLM 0.9.3.A: 2011-11-11
---------------------------------------------------------------------------------
-- Improved doxygen documentation
-- Added new swizzle operators for C++11 compilers
-- Added new swizzle operators declared as functions
-- Added GLSL 4.20 length for vector and matrix types
-- Promoted GLM_GTC_noise extension: simplex, perlin, periodic noise functions
-- Promoted GLM_GTC_random extension: linear, gaussian and various random number 
-generation distribution
-- Added GLM_GTX_constants: provides usefull constants
-- Added extension versioning
-- Removed many unused namespaces
-- Fixed half based type contructors
-- Added GLSL core noise functions
-
-================================================================================
-GLM 0.9.2.7: 2011-10-24
---------------------------------------------------------------------------------
-- Added more swizzling constructors
-- Added missing none-squared matrix products
-
-================================================================================
-GLM 0.9.2.6: 2011-10-01
---------------------------------------------------------------------------------
-- Fixed half based type build on old GCC
-- Fixed /W4 warnings on Visual C++
-- Fixed some missing l-value swizzle operators
-
-================================================================================
-GLM 0.9.2.5: 2011-09-20
---------------------------------------------------------------------------------
-- Fixed floatBitToXint functions
-- Fixed pack and unpack functions
-- Fixed round functions
-
-================================================================================
-GLM 0.9.2.4: 2011-09-03
---------------------------------------------------------------------------------
-- Fixed extensions bugs
-
-================================================================================
-GLM 0.9.2.3: 2011-06-08
---------------------------------------------------------------------------------
-- Fixed build issues
-
-================================================================================
-GLM 0.9.2.2: 2011-06-02
---------------------------------------------------------------------------------
-- Expend matrix constructors flexibility
-- Improved quaternion implementation
-- Fixed many warnings across platforms and compilers
-
-================================================================================
-GLM 0.9.2.1: 2011-05-24
---------------------------------------------------------------------------------
-- Automatically detect CUDA support
-- Improved compiler detection
-- Fixed errors and warnings in VC with C++ extensions disabled
-- Fixed and tested GLM_GTX_vector_angle
-- Fixed and tested GLM_GTX_rotate_vector
-
-================================================================================
-GLM 0.9.2.0: 2011-05-09
---------------------------------------------------------------------------------
-- Added CUDA support
-- Added CTest test suite
-- Added GLM_GTX_ulp extension
-- Added GLM_GTX_noise extension
-- Added GLM_GTX_matrix_interpolation extension
-- Updated quaternion slerp interpolation
-
-================================================================================
-GLM 0.9.1.3: 2011-05-07
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.9.1.2: 2011-04-15
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.9.1.1: 2011-03-17
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.9.1.0: 2011-03-03
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.9.1.B: 2011-02-13
---------------------------------------------------------------------------------
-- Updated API documentation
-- Improved SIMD implementation
-- Fixed Linux build
-
-================================================================================
-GLM 0.9.0.8: 2011-02-13
---------------------------------------------------------------------------------
-- Added quaternion product operator.
-- Clarify that GLM is a header only library.
-
-================================================================================
-GLM 0.9.1.A: 2011-01-31
---------------------------------------------------------------------------------
-- Added SIMD support
-- Added new swizzle functions
-- Improved static assert error message with C++0x static_assert
-- New setup system
-- Reduced branching
-- Fixed trunc implementation
-
-================================================================================
-GLM 0.9.0.7: 2011-01-30
---------------------------------------------------------------------------------
-- Added GLSL 4.10 packing functions
-- Added == and != operators for every types.
-
-================================================================================
-GLM 0.9.0.6: 2010-12-21
---------------------------------------------------------------------------------
-- Many matrices bugs fixed
-
-================================================================================
-GLM 0.9.0.5: 2010-11-01
---------------------------------------------------------------------------------
-- Improved Clang support
-- Fixed bugs
-
-================================================================================
-GLM 0.9.0.4: 2010-10-04
---------------------------------------------------------------------------------
-- Added autoexp for GLM
-- Fixed bugs
-
-================================================================================
-GLM 0.9.0.3: 2010-08-26
---------------------------------------------------------------------------------
-- Fixed non-squared matrix operators
-
-================================================================================
-GLM 0.9.0.2: 2010-07-08
---------------------------------------------------------------------------------
-- Added GLM_GTX_int_10_10_10_2
-- Fixed bugs
-
-================================================================================
-GLM 0.9.0.1: 2010-06-21
---------------------------------------------------------------------------------
-- Fixed extensions errors
-
-================================================================================
-GLM 0.9.0.0: 2010-05-25
---------------------------------------------------------------------------------
-- Objective-C support
-- Fixed warnings
-- Updated documentation
-
-================================================================================
-GLM 0.9.B.2: 2010-04-30
---------------------------------------------------------------------------------
-- Git transition
-- Removed experimental code from releases
-- Fixed bugs
-
-================================================================================
-GLM 0.9.B.1: 2010-04-03
---------------------------------------------------------------------------------
-- Based on GLSL 4.00 specification
-- Added the new core functions
-- Added some implicit conversion support
-
-================================================================================
-GLM 0.9.A.2: 2010-02-20
---------------------------------------------------------------------------------
-- Improved some possible errors messages
-- Improved declarations and definitions match
-
-================================================================================
-GLM 0.9.A.1: 2010-02-09
---------------------------------------------------------------------------------
-- Removed deprecated features
-- Internal redesign
-
-================================================================================
-GLM 0.8.4.4 final: 2010-01-25
---------------------------------------------------------------------------------
-- Fixed warnings
-
-================================================================================
-GLM 0.8.4.3 final: 2009-11-16
---------------------------------------------------------------------------------
-- Fixed Half float arithmetic
-- Fixed setup defines
-
-================================================================================
-GLM 0.8.4.2 final: 2009-10-19
---------------------------------------------------------------------------------
-- Fixed Half float adds
-
-================================================================================
-GLM 0.8.4.1 final: 2009-10-05
---------------------------------------------------------------------------------
-- Updated documentation
-- Fixed MacOS X build
-
-================================================================================
-GLM 0.8.4.0 final: 2009-09-16
---------------------------------------------------------------------------------
-- Added GCC 4.4 and VC2010 support
-- Added matrix optimizations
-
-================================================================================
-GLM 0.8.3.5 final: 2009-08-11
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.8.3.4 final: 2009-08-10
---------------------------------------------------------------------------------
-- Updated GLM according GLSL 1.5 spec
-- Fixed bugs
-
-================================================================================
-GLM 0.8.3.3 final: 2009-06-25
---------------------------------------------------------------------------------
-- Fixed bugs
-
-================================================================================
-GLM 0.8.3.2 final: 2009-06-04
---------------------------------------------------------------------------------
-- Added GLM_GTC_quaternion
-- Added GLM_GTC_type_precision
-
-================================================================================
-GLM 0.8.3.1 final: 2009-05-21
---------------------------------------------------------------------------------
-- Fixed old extension system.
-
-================================================================================
-GLM 0.8.3.0 final: 2009-05-06
---------------------------------------------------------------------------------
-- Added stable extensions.
-- Added new extension system.
-
-================================================================================
-GLM 0.8.2.3 final: 2009-04-01
---------------------------------------------------------------------------------
-- Fixed bugs.
-
-================================================================================
-GLM 0.8.2.2 final: 2009-02-24
---------------------------------------------------------------------------------
-- Fixed bugs.
-
-================================================================================
-GLM 0.8.2.1 final: 2009-02-13
---------------------------------------------------------------------------------
-- Fixed bugs.
-
-================================================================================
-GLM 0.8.2 final: 2009-01-21
---------------------------------------------------------------------------------
-- Fixed bugs.
-
-================================================================================
-GLM 0.8.1 final: 2008-10-30
---------------------------------------------------------------------------------
-- Fixed bugs.
-
-================================================================================
-GLM 0.8.0 final: 2008-10-23
---------------------------------------------------------------------------------
-- New method to use extension.
-
-================================================================================
-GLM 0.8.0 beta3: 2008-10-10
---------------------------------------------------------------------------------
-- Added CMake support for GLM tests.
-
-================================================================================
-GLM 0.8.0 beta2: 2008-10-04
---------------------------------------------------------------------------------
-- Improved half scalars and vectors support.
-
-================================================================================
-GLM 0.8.0 beta1: 2008-09-26
---------------------------------------------------------------------------------
-- Improved GLSL conformance
-- Added GLSL 1.30 support
-- Improved API documentation
-
-================================================================================
-GLM 0.7.6 final: 2008-08-08
---------------------------------------------------------------------------------
-- Improved C++ standard comformance
-- Added Static assert for types checking
-
-================================================================================
-GLM 0.7.5 final: 2008-07-05
---------------------------------------------------------------------------------
-- Added build message system with Visual Studio
-- Pedantic build with GCC
-
-================================================================================
-GLM 0.7.4 final: 2008-06-01
---------------------------------------------------------------------------------
-- Added external dependencies system.
-
-================================================================================
-GLM 0.7.3 final: 2008-05-24
---------------------------------------------------------------------------------
-- Fixed bugs
-- Added new extension group
-
-================================================================================
-GLM 0.7.2 final: 2008-04-27
---------------------------------------------------------------------------------
-- Updated documentation
-- Added preprocessor options
-
-================================================================================
-GLM 0.7.1 final: 2008-03-24
---------------------------------------------------------------------------------
-- Disabled half on GCC
-- Fixed extensions
-
-================================================================================
-GLM 0.7.0 final: 2008-03-22
---------------------------------------------------------------------------------
-- Changed to MIT license
-- Added new documentation
-
-================================================================================
-GLM 0.6.4 : 2007-12-10
---------------------------------------------------------------------------------
-- Fixed swizzle operators
-
-================================================================================
-GLM 0.6.3 : 2007-11-05
---------------------------------------------------------------------------------
-- Fixed type data accesses
-- Fixed 3DSMax sdk conflict
-
-================================================================================
-GLM 0.6.2 : 2007-10-08
---------------------------------------------------------------------------------
-- Fixed extension
-
-================================================================================
-GLM 0.6.1 : 2007-10-07
---------------------------------------------------------------------------------
-- Fixed a namespace error
-- Added extensions
-
-================================================================================
-GLM 0.6.0 : 2007-09-16
---------------------------------------------------------------------------------
-- Added new extension namespace mecanium
-- Added Automatic compiler detection
-
-================================================================================
-GLM 0.5.1 : 2007-02-19
---------------------------------------------------------------------------------
-- Fixed swizzle operators
-
-================================================================================
-GLM 0.5.0 : 2007-01-06
---------------------------------------------------------------------------------
-- Upgrated to GLSL 1.2
-- Added swizzle operators
-- Added setup settings
-
-================================================================================
-GLM 0.4.1 : 2006-05-22
---------------------------------------------------------------------------------
-- Added OpenGL examples
-
-================================================================================
-GLM 0.4.0 : 2006-05-17
---------------------------------------------------------------------------------
-- Added missing operators to vec* and mat*
-- Added first GLSL 1.2 features
-- Fixed windows.h before glm.h when windows.h required
-
-================================================================================
-GLM 0.3.2 : 2006-04-21
---------------------------------------------------------------------------------
-- Fixed texcoord components access.
-- Fixed mat4 and imat4 division operators.
-
-================================================================================
-GLM 0.3.1 : 2006-03-28
---------------------------------------------------------------------------------
-- Added GCC 4.0 support under MacOS X.
-- Added GCC 4.0 and 4.1 support under Linux.
-- Added code optimisations.
-
-================================================================================
-GLM 0.3 : 2006-02-19
---------------------------------------------------------------------------------
-- Improved GLSL type conversion and construction compliance.
-- Added experimental extensions.
-- Added Doxygen Documentation.
-- Added code optimisations.
-- Fixed bugs.
-
-================================================================================
-GLM 0.2: 2005-05-05
---------------------------------------------------------------------------------
-- Improve adaptative from GLSL.
-- Add experimental extensions based on OpenGL extension process.
-- Fixe bugs.
-
-================================================================================
-GLM 0.1: 2005-02-21
---------------------------------------------------------------------------------
-- Add vec2, vec3, vec4 GLSL types
-- Add ivec2, ivec3, ivec4 GLSL types
-- Add bvec2, bvec3, bvec4 GLSL types
-- Add mat2, mat3, mat4 GLSL types
-- Add almost all functions
-
-================================================================================
diff --git a/thirdparty/imgui b/thirdparty/imgui
deleted file mode 160000
index 0b10bec7..00000000
--- a/thirdparty/imgui
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0b10bec71ff7178bc16239bfc3e7604f5c457df0
diff --git a/thirdparty/libusb b/thirdparty/libusb
deleted file mode 160000
index 648fb869..00000000
--- a/thirdparty/libusb
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 648fb8691f8b9701d7406bc339ce64b57545934b
diff --git a/thirdparty/protobuf b/thirdparty/protobuf
index c404c2a2..3e1bd5b8 160000
--- a/thirdparty/protobuf
+++ b/thirdparty/protobuf
@@ -1 +1 @@
-Subproject commit c404c2a2e3e9a05096fc86f080b6d966b2b0043c
+Subproject commit 3e1bd5b81e6d3d806c8b7e1282face57ef7bb0be
diff --git a/thirdparty/type_index b/thirdparty/type_index
index f5884463..afd1b6cd 160000
--- a/thirdparty/type_index
+++ b/thirdparty/type_index
@@ -1 +1 @@
-Subproject commit f58844637c8aeadcd9f7bac3a10fe7a2f4d50b11
+Subproject commit afd1b6cdc88c516d72a6a2f7a7dd3585f7a8f20c