Merge fixes

Export Getter/Setter alternate currency methods to Perl and Lua.

.gitignore

@@ -23,20 +23,11 @@ CMakeFiles
 Makefile
 cmake_install.cmake
 install_manifest.txt
-Build/
-build/
-Build32/
-build32/
-Build64/
-build64/
-Build_32/
-build_32/
-Build_64/
-build_64/
-x64/
-x86/
+[Bb]uild*/
 log/
 logs/
 vcpkg/
 
-.idea/*
+.idea/*
+*cbp
+.editorconfig

.gitmodules

@@ -0,0 +1,21 @@
+[submodule "submodules/glm"]
+	path = submodules/glm
+	url = https://github.com/g-truc/glm.git
+[submodule "submodules/fmt"]
+	path = submodules/fmt
+	url = https://github.com/fmtlib/fmt.git
+[submodule "submodules/libuv"]
+	path = submodules/libuv
+	url = https://github.com/libuv/libuv.git
+[submodule "submodules/cereal"]
+	path = submodules/cereal
+	url = https://github.com/USCiLab/cereal.git
+[submodule "submodules/websocketpp"]
+	path = submodules/websocketpp
+	url = https://github.com/zaphoyd/websocketpp.git
+[submodule "submodules/recastnavigation"]
+	path = submodules/recastnavigation
+	url = https://github.com/EQEmu/recastnavigation.git
+[submodule "submodules/zlibng"]
+	path = submodules/zlibng
+	url = https://github.com/zlib-ng/zlib-ng.git

CMakeLists.txt

@@ -1,119 +1,24 @@
-#EQEmu CMake
-#Variables used:
-#EQEMU_DISABLE_CRT_SECURE_WARNINGS
-#EQEMU_FAST_FLOATINGPOINT
-#EQEMU_ENABLE_CRASH_LOGGING
-#EQEMU_DISABLE_SAFESEH
-#EQEMU_BUILD_MSVC_MP
-#EQEMU_DEBUG_LEVEL
-#EQEMU_LOG_LEVEL_STATUS
-#EQEMU_LOG_LEVEL_NORMAL
-#EQEMU_LOG_LEVEL_ERROR
-#EQEMU_LOG_LEVEL_DEBUG
-#EQEMU_LOG_LEVEL_QUEST
-#EQEMU_LOG_LEVEL_COMMANDS
-#EQEMU_LOG_LEVEL_CRASH
-#EQEMU_DEPOP_INVALIDATES_CACHE
-#EQEMU_ENABLE_BOTS
-#EQEMU_DISABLE_LOGSYS
-#EQEMU_COMMANDS_LOGGING
-#EQEMU_BUILD_SERVER
-#EQEMU_BUILD_LOGIN
-#EQEMU_BUILD_TESTS
-#EQEMU_BUILD_PERL
-#EQEMU_BUILD_LUA
-#EQEMU_SANITIZE_LUA_LIBS
-#EQEMU_BUILD_CLIENT_FILES
-#EQEMU_USE_MAP_MMFS
-#EQEMU_MAP_DIR
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-
-#FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
 
-#Our project name is EQEmu
 PROJECT(EQEmu)
 
-#Default build type is set to RelWithDebInfo for generators that honor that like makefiles
 IF(NOT CMAKE_BUILD_TYPE)
 	SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose the type of build." FORCE)
 ENDIF(NOT CMAKE_BUILD_TYPE)
 
-SET(CMAKE_PREFIX_PATH "${CMAKE_CURRENT_SOURCE_DIR}/dependencies" "${CMAKE_PREFIX_PATH}")
-
-#Add our various windows definitions
-IF(MSVC OR MINGW)
-	ADD_DEFINITIONS(-D_WINDOWS)
-	IF(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN64)
-	ELSE(CMAKE_CL_64)
-		ADD_DEFINITIONS(-DWIN32)
-	ENDIF(CMAKE_CL_64)
-ENDIF(MSVC OR MINGW)
+SET(CMAKE_CXX_STANDARD 14)
+SET(CMAKE_CXX_STANDARD_REQUIRED ON)
+SET(CMAKE_CXX_EXTENSIONS OFF)
 
 IF(MSVC)
-	IF(CMAKE_CL_64)
-		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
-		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
-		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x64")
-		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x64")
-		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-		IF(MSVC_VERSION GREATER 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v140/dynamic")
-		ELSEIF(MSVC_VERSION EQUAL 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v120/dynamic")
-		ELSE()
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v110/dynamic")
-		ENDIF()
-	ELSE(CMAKE_CL_64)
-		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
-		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
-		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
-		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
-		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86")
-		IF(MSVC_VERSION GREATER 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic")
-		ELSEIF(MSVC_VERSION EQUAL 1800)
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v120/dynamic")
-		ELSE()
-			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v110/dynamic")
-		ENDIF()
-	ENDIF(CMAKE_CL_64)
-
-	#disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
-	OPTION(EQEMU_DISABLE_CRT_SECURE_WARNINGS "Disable Secure CRT Warnings" ON)
-	IF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-		ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
-	ENDIF(EQEMU_DISABLE_CRT_SECURE_WARNINGS)
-
-	#fast FP if you'd like it
-	OPTION(EQEMU_FAST_FLOATINGPOINT "Use MSVC /fp:fast option" ON)
-	IF(EQEMU_FAST_FLOATINGPOINT)
-		ADD_DEFINITIONS(/fp:fast)
-	ENDIF(EQEMU_FAST_FLOATINGPOINT)
-
-	#crash logging currently only works on windows x86/x64
-	OPTION(EQEMU_ENABLE_CRASH_LOGGING "Enable crash logging" ON)
-	IF(EQEMU_ENABLE_CRASH_LOGGING)
-		ADD_DEFINITIONS(-DCRASH_LOGGING)
-	ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
-
-	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
-	IF(EQEMU_BUILD_MSVC_MP)
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-	ENDIF(EQEMU_BUILD_MSVC_MP)
-
-	#We want to compile /MT not /MD so we change that
-	FOREACH(flag_var CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_RELWITHDEBINFO)
-		IF(${flag_var} MATCHES "/MD")
-			STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-		ENDIF(${flag_var} MATCHES "/MD")
-	ENDFOREACH(flag_var)
-
+	ADD_DEFINITIONS(-D_CRT_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-DNOMINMAX)
+	ADD_DEFINITIONS(-DCRASH_LOGGING)
+	
+	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
 ELSE(MSVC)
-	#Normally set by perl but we don't use the perl flags anymore so we set it.
 	ADD_DEFINITIONS(-DHAS_UNION_SEMUN)
 ENDIF(MSVC)
 
@@ -130,177 +35,239 @@ IF(UNIX)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
 ENDIF(UNIX)
 
-#debug level, 5 is default. Most people wont ever change this but it's there if you want to
-SET(EQEMU_DEBUG_LEVEL 5 CACHE STRING "EQEmu debug level:
-	0 - Quiet mode Errors to file Status and Normal ignored
-	1 - Status and Normal to console, Errors to logfile
-	2 - Status, Normal, and Error to console and logfile
-	3 - Light debug release errors and status
-	4 - Moderate debug release errors and status
-	5 - Maximum debug release errors and status
-	10 - More errors than you ever wanted to see"
-)
+ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
+ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
+ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
 
-SET(EQEMU_LOG_LEVEL_STATUS 2 CACHE STRING "EQEmu logging level for [Status]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+#Find everything we need
+FIND_PACKAGE(MySQL)
+FIND_PACKAGE(MariaDB)
+FIND_PACKAGE(Boost REQUIRED)
+FIND_PACKAGE(ZLIB)
+FIND_PACKAGE(OpenSSL)
+FIND_PACKAGE(Lua51)
+FIND_PACKAGE(PerlLibs)
+FIND_PACKAGE(Sodium)
+FIND_PACKAGE(mbedTLS)
 
-SET(EQEMU_LOG_LEVEL_NORMAL 3 CACHE STRING "EQEmu logging level for [Normal]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Detection                              *")
+MESSAGE(STATUS "**************************************************")
 
-SET(EQEMU_LOG_LEVEL_ERROR 2 CACHE STRING "EQEmu logging level for [Error]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(MYSQL_FOUND)
+	MESSAGE(STATUS "* MySQL:                                   FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MySQL:                                 MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_DEBUG 3 CACHE STRING "EQEmu logging level for [Debug]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(MARIADB_FOUND)
+	MESSAGE(STATUS "* MariaDB:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* MariaDB:                               MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_QUEST 2 CACHE STRING "EQEmu logging level for [Quest]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(ZLIB_FOUND)
+	MESSAGE(STATUS "* ZLIB:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* ZLIB:                                  MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_COMMANDS 1 CACHE STRING "EQEmu logging level for [Commands]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(Lua51_FOUND)
+	MESSAGE(STATUS "* Lua:                                     FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Lua:                                   MISSING *")
+ENDIF()
 
-SET(EQEMU_LOG_LEVEL_CRASH 3 CACHE STRING "EQEmu logging level for [Crash]:
-	0 - Disabled
-	1 - Ouput to File Enabled
-	2 - Output to stdout Enabled
-	3 - Output to File and stdout Enabled
-	8 - Output to stderr Enabled
-	9 - Output to File and stderr Enabled
-	11 - Output to File, stdout and stderr Enabled"
-)
+IF(PerlLibs_FOUND)
+	MESSAGE(STATUS "* Perl:                                    FOUND *")
+ELSE()
+	MESSAGE(STATUS "* Perl:                                  MISSING *")
+ENDIF()
 
-MARK_AS_ADVANCED(EQEMU_LOG_LEVEL_STATUS EQEMU_LOG_LEVEL_NORMAL EQEMU_LOG_LEVEL_ERROR EQEMU_LOG_LEVEL_DEBUG EQEMU_LOG_LEVEL_QUEST EQEMU_LOG_LEVEL_COMMANDS EQEMU_LOG_LEVEL_CRASH)
+IF(SODIUM_FOUND)
+	MESSAGE(STATUS "* libsodium:                               FOUND *")
+ELSE()
+	MESSAGE(STATUS "* libsodium:                             MISSING *")
+ENDIF()
 
-#NPC Types Cache Behavior
+IF(OpenSSL_FOUND)
+	MESSAGE(STATUS "* OpenSSL:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* OpenSSL:                               MISSING *")
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+	MESSAGE(STATUS "* mbedTLS:                                 FOUND *")
+ELSE()
+	MESSAGE(STATUS "* mbedTLS:                               MISSING *")
+ENDIF()
+
+MESSAGE(STATUS "**************************************************")
+
+#options
 OPTION(EQEMU_DEPOP_INVALIDATES_CACHE "#repop invalidates the npc_types cache (will cause a larger database hit on #repop but is more convienent)." ON)
-
-#Bots are a compile time option so on/off
 OPTION(EQEMU_ENABLE_BOTS "Enable Bots" OFF)
-
-#Disable entire _mlog system (excludes trade/command logs)
-OPTION(EQEMU_DISABLE_LOGSYS "Disable Logging INI System" ON)
-
-#Enable GM Command log system
 OPTION(EQEMU_COMMANDS_LOGGING "Enable GM Command logs" ON)
+OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
+OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
+OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
+OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
 
 IF(EQEMU_COMMANDS_LOGGING)
 	ADD_DEFINITIONS(-DCOMMANDS_LOGGING)
 ENDIF(EQEMU_COMMANDS_LOGGING)
 
-IF(EQEMU_DISABLE_LOGSYS)
-	ADD_DEFINITIONS(-DDISABLE_LOGSYS)
-ENDIF(EQEMU_DISABLE_LOGSYS)
-
 IF(EQEMU_ENABLE_BOTS)
 	ADD_DEFINITIONS(-DBOTS)
 ENDIF(EQEMU_ENABLE_BOTS)
 
-#What to build
-OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
-OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
-OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
-OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
-OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
-OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
-OPTION(EQEMU_BUILD_CLIENT_FILES "Build Client Import/Export Data Programs." ON)
+#database
+#prefer mariadb to mysql (arbitrary)
+IF(MySQL_FOUND AND MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "MariaDB")
+	SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+ELSEIF(MariaDB_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "MariaDB")
+	SET(DATABASE_LIBRARY_LIBS ${MariaDB_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MariaDB_INCLUDE_DIR})
+ELSEIF(MySQL_FOUND)
+	SET(DATABASE_LIBRARY_TYPE "  MySQL")
+	SET(DATABASE_LIBRARY_LIBS ${MySQL_LIBRARIES})
+	SET(DATABASE_LIBRARY_INCLUDE ${MySQL_INCLUDE_DIR})
+ELSE()
+	MESSAGE(FATAL_ERROR "One of MySQL or MariaDB is a required dependency.")
+ENDIF()
 
-#C++11 stuff
-IF(NOT MSVC)
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-	IF("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reserved-user-defined-literal")
-	ENDIF()
-ENDIF(NOT MSVC)
+#security
+#prefer openssl to mbedtls (arbitrary)
+IF(OpenSSL_FOUND AND MBEDTLS_FOUND)
+	SET(SSL_LIBRARY_TYPE " OpenSSL")
+	SET(SSL_LIBRARY_ENABLED ON)
+	SET(SSL_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+	SET(SSL_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+ELSEIF(OpenSSL_FOUND)
+	SET(SSL_LIBRARY_TYPE " OpenSSL")
+	SET(SSL_LIBRARY_ENABLED ON)
+	SET(SSL_LIBRARY_LIBS ${OPENSSL_LIBRARIES})
+	SET(SSL_LIBRARY_INCLUDE ${OPENSSL_INCLUDE_DIR})
+ELSEIF(MBEDTLS_FOUND)
+	SET(SSL_LIBRARY_TYPE " mbedTLS")
+	SET(SSL_LIBRARY_ENABLED ON)
+	SET(SSL_LIBRARY_LIBS ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
+	SET(SSL_LIBRARY_INCLUDE ${MBEDTLS_INCLUDE_DIR})
+ELSE()
+	SET(SSL_LIBRARY_TYPE "Disabled")
+	SET(SSL_LIBRARY_ENABLED OFF)
+ENDIF()
 
-#Various definitions
-IF(EQEMU_BUILD_PERL)
-	ADD_DEFINITIONS(-DEMBPERL)
-	ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
-ENDIF(EQEMU_BUILD_PERL)
-IF(EQEMU_BUILD_LUA)
-	ADD_DEFINITIONS(-DLUA_EQEMU)
-ENDIF(EQEMU_BUILD_LUA)
-
-OPTION(EQEMU_USE_MAP_MMFS "Create and use Zone Map MMF files." OFF)
-IF(EQEMU_USE_MAP_MMFS)
-	ADD_DEFINITIONS(-DUSE_MAP_MMFS)
-ENDIF(EQEMU_USE_MAP_MMFS)
-
-SET(EQEMU_MAP_DIR "./Maps" CACHE STRING "The dir that maps, water maps, and paths are located in.")
-
-ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
-ADD_DEFINITIONS(-DINVERSEXY)
-ADD_DEFINITIONS(-DFIELD_ITEMS)
-ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
-ADD_DEFINITIONS(-DLOG_LEVEL_STATUS=${EQEMU_LOG_LEVEL_STATUS})
-ADD_DEFINITIONS(-DLOG_LEVEL_NORMAL=${EQEMU_LOG_LEVEL_NORMAL})
-ADD_DEFINITIONS(-DLOG_LEVEL_ERROR=${EQEMU_LOG_LEVEL_ERROR})
-ADD_DEFINITIONS(-DLOG_LEVEL_DEBUG=${EQEMU_LOG_LEVEL_DEBUG})
-ADD_DEFINITIONS(-DLOG_LEVEL_QUEST=${EQEMU_LOG_LEVEL_QUEST})
-ADD_DEFINITIONS(-DLOG_LEVEL_COMMANDS=${EQEMU_LOG_LEVEL_COMMANDS})
-ADD_DEFINITIONS(-DLOG_LEVEL_CRASH=${EQEMU_LOG_LEVEL_CRASH})
-ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)
-
-#Find everything we need
-FIND_PACKAGE(ZLIB REQUIRED)
-FIND_PACKAGE(MySQL REQUIRED)
-IF(EQEMU_BUILD_PERL)
-	FIND_PACKAGE(PerlLibs REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
-ENDIF(EQEMU_BUILD_PERL)
-
-SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt recast_navigation)
-
-FIND_PACKAGE(Sodium REQUIRED)
 IF(SODIUM_FOUND)
-	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
-	IF(EQEMU_ENABLE_SECURITY)
-		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
-		ADD_DEFINITIONS(-DENABLE_SECURITY)
-		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_TYPE "Libsodium")
+	SET(SODIUM_LIBRARY_ENABLED ON)
+	SET(SODIUM_LIBRARY_LIBS ${SODIUM_LIBRARIES})
+	SET(SODIUM_LIBRARY_INCLUDE ${SODIUM_INCLUDE_DIRS})
+	ADD_DEFINITIONS(-DENABLE_SECURITY)
+ELSE()
+	SET(SODIUM_LIBRARY_TYPE " Disabled")
+	SET(SODIUM_LIBRARY_ENABLED OFF)
+ENDIF()
+
+IF(Lua51_FOUND)
+	SET(LUA_LIBRARY_TYPE " Lua 5.1")
+	SET(LUA_LIBRARY_LIBS ${LUA_LIBRARY} luabind)
+	SET(LUA_LIBRARY_INCLUDE ${LUA_INCLUDE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
+	
+	OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
+	IF(EQEMU_BUILD_LUA)
+		ADD_DEFINITIONS(-DLUA_EQEMU)
+		OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
+		IF(EQEMU_SANITIZE_LUA_LIBS)
+			ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
+		ENDIF()
 	ENDIF()
+ELSE()
+	SET(LUA_LIBRARY_TYPE "Disabled")
+ENDIF()
+
+IF(PerlLibs_FOUND)
+	SET(PERL_LIBRARY_TYPE "    Perl")
+	SET(PERL_LIBRARY_LIBS ${PERL_LIBRARY})
+	SET(PERL_LIBRARY_INCLUDE ${PERL_INCLUDE_PATH})
+	
+	OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
+	IF(EQEMU_BUILD_PERL)
+		ADD_DEFINITIONS(-DEMBPERL)
+		ADD_DEFINITIONS(-DEMBPERL_PLUGIN)
+	ENDIF()
+ELSE()
+	SET(PERL_LIBRARY_TYPE "Disabled")
+ENDIF()
+
+#use zlib if exists
+IF(ZLIB_FOUND)
+	OPTION(EQEMU_BUILD_ZLIB "Build internal version of zlib." OFF)
+	IF(EQEMU_BUILD_ZLIB)
+		SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+		SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+		SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/submodules/zlibng")
+	ELSE()
+		SET(ZLIB_LIBRARY_TYPE "  zlib")
+		SET(ZLIB_LIBRARY_LIBS ${ZLIB_LIBRARY})
+		SET(ZLIB_LIBRARY_INCLUDE ${ZLIB_INCLUDE_DIRS})
+	ENDIF()
+ELSE()
+	SET(ZLIB_LIBRARY_TYPE "zlib-ng")
+	SET(ZLIB_LIBRARY_LIBS "zlibstatic")
+	SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/submodules/zlibng")
+ENDIF()
+
+MESSAGE(STATUS "")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Library Usage                                  *")
+MESSAGE(STATUS "**************************************************")
+MESSAGE(STATUS "* Database:                              ${DATABASE_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* TLS:                                  ${SSL_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Sodium:                              ${SODIUM_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Lua:                                  ${LUA_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* Perl:                                 ${PERL_LIBRARY_TYPE} *")
+MESSAGE(STATUS "* zlib:                                   ${ZLIB_LIBRARY_TYPE} *")
+MESSAGE(STATUS "**************************************************")
+
+#setup server libs and headers
+SET(SERVER_LIBS common ${DATABASE_LIBRARY_LIBS} ${ZLIB_LIBRARY_LIBS} ${Boost_LIBRARIES} uv_a fmt RecastNavigation::Detour)
+
+INCLUDE_DIRECTORIES(SYSTEM "${DATABASE_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_LIBRARY_INCLUDE}")
+INCLUDE_DIRECTORIES(SYSTEM "${Boost_INCLUDE_DIRS}")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/cereal/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/fmt/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/libuv/include" )
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DebugUtils/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Detour/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourCrowd/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/DetourTileCache/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/recastnavigation/Recast/Include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/submodules/websocketpp")
+
+IF(SSL_LIBRARY_ENABLED)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${SSL_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${SSL_LIBRARY_INCLUDE}")
+ENDIF()
+
+IF(SODIUM_LIBRARY_ENABLED)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_LIBRARY_INCLUDE}")
+ENDIF()
+
+IF(EQEMU_BUILD_LUA)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${LUA_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${LUA_LIBRARY_INCLUDE}")
+ENDIF()
+
+IF(EQEMU_BUILD_PERL)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${PERL_LIBRARY_LIBS})
+	INCLUDE_DIRECTORIES(SYSTEM "${PERL_LIBRARY_INCLUDE}")
 ENDIF()
 
 IF(WIN32)
@@ -315,37 +282,30 @@ IF(UNIX)
 	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
 ENDIF()
 
-IF(EQEMU_BUILD_LUA)
-	FIND_PACKAGE(EQLua51 REQUIRED)
-	SET(Boost_USE_STATIC_LIBS OFF)
-	SET(Boost_USE_MULTITHREADED ON)
-	SET(Boost_USE_STATIC_RUNTIME OFF)
-	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
-
-	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/luabind")
-
-	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
-	IF(EQEMU_SANITIZE_LUA_LIBS)
-		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
-	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
-ENDIF(EQEMU_BUILD_LUA)
-
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
-INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" )
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/detour/include")
-INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/recast/include")
+IF(EQEMU_BUILD_LOGIN AND NOT SSL_LIBRARY_ENABLED)
+	MESSAGE(FATAL_ERROR "Login server requires a SSL Library to build.")
+ENDIF()
 
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)
 	ADD_SUBDIRECTORY(libs)
+	ADD_SUBDIRECTORY(submodules/fmt)
+	ADD_SUBDIRECTORY(submodules/libuv)
+	
+	IF(EQEMU_BUILD_ZLIB)
+		SET(ZLIB_COMPAT ON CACHE BOOL "Compile with zlib compatible API")
+		SET(ZLIB_ENABLE_TESTS OFF CACHE BOOL "Build test binaries")
+		ADD_SUBDIRECTORY(submodules/zlibng)
+	ENDIF()
+	
+	SET(RECASTNAVIGATION_DEMO OFF CACHE BOOL "Build demo")
+	SET(RECASTNAVIGATION_TESTS OFF CACHE BOOL "Build tests")
+	SET(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "Build examples")
+	ADD_SUBDIRECTORY(submodules/recastnavigation)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
+
+MESSAGE(STATUS "Libs: ${SERVER_LIBS}")
+
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -354,6 +314,7 @@ IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(queryserv)
 	ADD_SUBDIRECTORY(eqlaunch)
 ENDIF(EQEMU_BUILD_SERVER)
+
 IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)

README.md

@@ -70,3 +70,9 @@ forum, although pull requests will be much quicker and easier on all parties.
   * GPL Perl - GPL / ActiveState (under the assumption that this is a free project)
   * CPPUnit - GLP StringUtilities - Apache
   * LUA - MIT
+
+## Contributors
+
+<a href="https://github.com/EQEmu/server/graphs/contributors">
+  <img src="https://contributors-img.firebaseapp.com/image?repo=EQEmu/server" />
+</a>

SECURITY.md

@@ -0,0 +1,3 @@
+# Security Policy - Reporting Vulnerabilities
+
+When reporting active hacks, exploits and other vulnerabilities, please describe how to reproduce said report and if you can provide context into a possible solution

changelog.txt

@@ -1,5 +1,436 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+== 8/16/2019 ==
+Akkadius: Simplified the use of roamboxes and improved the AI for roambox pathing https://i.imgur.com/z33u7y9.gif
+Akkadius: Implemented command #roambox set <box_size> [move_delay]
+Akkadius: Implemented command #roambox remove
+Akkadius: Implemented LUA NPC:SetSimpleRoamBox(box_size, [move_distance], [move_delay]);
+Akkadius: Implemented Perl $npc->SetSimpleRoamBox(box_size, [move_distance], [move_delay]);
+Akkadius: Spawngroup data now hot reloads on #repop
+Akkadius: Command #npceditmass now lists column options when one isn't properly specified
+Akkadius: Implemented command #spawneditmass <search> <option> <value> with options [respawn_time] currently implemented
+
+== 8/11/2019 ==
+Akkadius: Added bulk edit command #npceditmass <column-to-search> <column-search-value> <change-column> <change-value>
+Akkadius: Modified #findzone to include clickable saylinks to both regular zone (if able) and private gmzone instances
+Akkadius: Added #findzone expansion <expansion-number> to show zones via expansion
+
+== 8/6/2019 ==
+Akkadius: Optimizations to movement updates to eliminate ghosting possibilities in larger zones
+
+== 7/22/2019 ==
+Uleat: Added script 'vcxproj_dependencies.py' - a script to help determine conflicting project dependencies (alpha-stage)
+
+== 7/10/2019 ==
+
+Akkadius: Add #npcedit flymode [0 = ground, 1 = flying, 2 = levitate, 3 = water, 4 = floating]
+Akkadius: Added "flymode" to npc_types database table
+
+== 7/3/2019 ==
+
+Akkadius/KLS:
+    - Optimizations to packet updates introduced back into the source post network code overhaul
+    - Optimizations made to position update packets by sending updates far less frequently when not in line with zone:max_movement_update_range
+    - Optimizations made to position updates in respect to the much higher resolution of navmesh path-finding that we were using. We have cut down
+        on the resolution of path finding / updating so that we reduce the CPU overhead of path-finding and subsequent client update packets that
+        get generated this action
+    - Optimization made by adjusting ZLIB compression rate that was accidentally set to a compression level of 4 a long time ago
+    - Added #netstats admin command to troubleshoot connection issues in detail
+    - Websocket server is now available in zone and is bound to the same UDP port that the zoneserver listens on
+        - Currently implemented websocket API calls at the zone level
+             get_packet_statistics
+             get_opcode_list
+             get_npc_list_detail
+             get_door_list_detail
+             get_corpse_list_detail
+             get_object_list_detail
+             get_mob_list_detail
+             get_client_list_detail
+             get_zone_attributes
+             get_logsys_categories
+             set_logging_level
+         - Example of a Typescript client: https://gist.github.com/Akkadius/52d12d0379f36cf81c51b3b7da13db37
+     - Library Changes
+        - We now use git submodules for libraries / dependencies versus manually downloading to the dependencies folder and/or storing
+            said dependencies within our codebase itself
+        - To update dependencies (Required for compiling)
+            - git submodule init
+            - git submodule update
+        - Libraries now in submodules
+            - [glm] https://github.com/g-truc/glm.git
+            - [flm] https://github.com/fmtlib/fmt.git
+            - [libuv] https://github.com/libuv/libuv.git
+            - [cereal] https://github.com/USCiLab/cereal.git
+            - [websocketpp] https://github.com/zaphoyd/websocketpp.git
+            - [recastnavigation] https://github.com/EQEmu/recastnavigation.git
+
+== 6/24/2019 ==
+Uleat: Reworked BotDatabase into a functional add-on for ZoneDatabase
+	- Eliminated the database connection associated with class BotDatabase
+	- All behaviors remain the same with the exception of the calling object
+	 -- To invoke a BotDatabase function, use database.botdb.<f> rather than botdb.<f>
+
+== 3/1/2019 ==
+Noudess: Major faction conversion to use client data.
+
+	Pull request #802 New min/max personal faction per faction. Use of actual 
+	client mods for race/class/deity.
+
+	This PR involves major changes to your database and your quests.
+
+	The clients recently exposed raw data included 
+
+	- the min/max personal faction for each faction
+	- the actual faction id the client uses for each faction
+	- the actual mods that come into play when a PC cons an opponent that 
+	  determine your overall con to that faction.
+
+
+	The approach I took resulted in minimal change to the code base.  I did 
+	alter the code to enforce the new validated min/max from the client.  This 
+	min/max applies to personally earned faction.  So if a faction has a min 
+	of 0 and a max of 2000, that means your personally earned value can never 
+	go below 0 or over 2000.  The actual con, will, however often do so because 
+	of class/race/deity modifications.  I also changed the con ranges, per 
+	Mackal's data that was proven to be accurate:
+
+	Ally = 1100+ 
+	Warmly = 750 to 1099 
+	Kindly = 500 to 749 
+	Amiable = 100 to 499 
+	Indifferent = 0 to 99 
+	Apprehensive = -1 to -100 
+	Dubious = -101 to -500 
+	Threateningly = -501 to -750 
+	Ready to Attack = -751 
+
+	The above means that dubious is a much smaller range now.  For that reason 
+	the scripts modify any custom faction base values to put them in the same 
+	range, hopefully as the creators of the custom factions intended.
+
+	Also to be noted as characters that have a faction between -501 and -700 
+	wont be dubious anymore, they will be threateningly.  This is expected with 
+	the new ranges, but might take players by suprise as the old ranges we used 
+	were more liberal but were incorrect.
+
+	The database is changed extensively, but really only content.  We're 
+	translating faction_list to use the clients ids.  As such every place a 
+	faction_is is used, namely (see below) are being converted.
+
+	- faction_list
+	- faction_list_mod
+	- npc_faction (primary_faction field only)
+	- npc_faction_entries (faction_id field only)
+	- faction_values
+
+	Quests will also automatically be adjusted.  This MUST be done after the 
+	PR sql and before starting the server.  This is automated by 
+	eqemu_server.pl (or starting world)
+
+	Be assured, custom factions that you may have created, or obsolete or 
+	duplicate factions in our original faction_list, that you may have used, 
+	will be preserved.  Anything that does not map directly is being moved to 
+	the 5000 range in faction_list and any references are corrected to point 
+	there.
+
+	A great example of this is Ebon Mask and Hall of the Ebon Mask.  Many peqdb 
+	style servers have both of these.  Some have used one, some the other.  We 
+	map Ebon Mask to the clients Ebon mask and the Hall of the Ebon Mask gets 
+	moved to the 5000 range, and all its references are preserved.  However, 
+	if you would like to make proper use of client mobs to Ebon mask, or other 
+	factions that have duplicitous entries, I recommend you manually move to 
+	using the correct one.  In that way all of the new raw data mapped in from 
+	the client into faction_list_mod will get used instead of what your db had 
+	before these values were known.
+
+	In my experience converting 4 different server's data, there are only 
+	about 20 factions moved into the 5000 range.
+
+	This PR has only 1 new, permanent table faction_base_data, which is taken 
+	right from the client.  The base field is left in case you want to mod your 
+	server, but we are very sure that the client doesn't use a base.  It uses 
+	global mods to race or class for this as you'll see in the 
+	new faction_list_mod.
+
+	The PR makes many backup tables, and two mapping tables that are used during
+	the conversion process to fix quests.  This table was hand created by 
+	analysis.  This table serves no purpose after conversion except an audit 
+	trail if we see any issues.
+
+	I will release a new PR that will clean up all these backups and temporary 
+	tables in about a month.
+
+== 2/7/2019 ==
+Uleat: Put merc and bot classes on the same stance standard (mercs)
+	- Both classes will now use the same stance standard
+	- Pushed stance types up to EQEmu::constants
+
+== 2/4/2019 ==
+Uleat: Added command 'profanity' (aliased 'prof')
+	- This is a server-based tool for redacting any language that an admin deems as profanity (socially unacceptable within their community)
+	- Five options are available under this command..
+	 -- 'list' - shows the current list of banned words
+	 -- 'clear' - clears the current list of banned words
+	 -- 'add <word>' - adds <word> to the banned word list
+	 -- 'del <word>' - deletes <word> from the banned word list
+	 -- 'reload' - forces a reload of the banned word list
+	- All actions are immediate and a world broadcast refreshes other active zones
+	- The system is in stand-by when the list is empty..just add a word to the list to begin censorship
+	- Redaction only occurs on genuine occurences of any banned word
+	 -- Banned words are replaced with a series of '*' characters
+	 -- Compounded words are ignored to avoid issues with allowed words containing a banned sub-string
+	 -- If 'test' is banned, 'testing' will not be banned .. it must be added separately
+	- Extreme care should be exercised when adding words to the banned list..
+	 -- Quest failures and limited social interactions may alienate players if they become inhibiting
+	 -- System commands are allowed to be processed before redaction occurs in the 'say' channel
+	- A longer list requires more clock cycles to process - so, try to keep them to the most offensible occurrences
+Uleat: Fix for bots ceasing combat when their 'follow me' mob dies
+	- Bots will revert to their client leash owner (bot owner or client group leader) when their FollowID() mob is no longer valid
+	- Combat will no longer be interrupted in these cases
+	- Does not apply to bot owner death...
+
+== 1/26/2019 ==
+Uleat: Fix for class Bot not honoring NPCType data reference
+	- Fixes bots not moving on spawn/grouping issue
+	- Report any issues with non movement-related behavior
+
+== 1/24/2019 ==
+Uleat: Extended server spellbook entries to RoF2 standard and added per-client restriction of spell id max
+	- Bumped server spellbook entry capacity to 720 spells
+	- Server keeps all 'learned' spells as found
+	  -- Access is limited by the clients' limitations of spellbook capacities and max spell ids
+	  -- This is done to avoid losing spells by switching from newer clients to older ones
+	  -- Existing behavior is kept in place for illegal access conditions
+	- Each client is still restricted to its spellbook capacity (400, 480, 480, 720, 720, 720 - respectively)
+	- Each client is restricted to its max supported spell id (9999, 15999, 23000, 28000, 45000, 45000 - respectively)
+	- Please report any abnormal behavior so it may be addressed
+Uleat: Removed server-side checksum of player profile..wasted calculation since it's performed again in all translators
+
+== 1/20/2019 ==
+Uleat: Added 'spells' entry to EQDictionary
+Akkadius:
+    - [Command] Extended #goto via #goto <player_name> -
+        - This will work cross zone, cross instance, in zone etc.
+        - It works on top of the original #goto (target) and #goto x y z
+    - [Command] Implemented server side #who Example: https://bit.ly/2TZ2hvI
+        - Searches can be filtered by
+            - Account Name
+            - Base Class Name
+            - Guild Name
+            - IP
+            - Player Name
+            - Race Name
+            - Zone Short Name
+        - Features a clickable (Goto) saylink that will bring you directly to a player regardless of
+            whether or not they are in an instance
+    - [Command] Implemented: #gmzone [zone_short_name] [zone_version=0] [identifier=gmzone]
+        - Zones to a private GM instance
+            - Example: https://i.imgur.com/qswdrzO.gif
+    - [NPC] Fix issue where NPC's clip into the world and the client interprets them at 0,0,0
+        - This issue would show itself when NPC's would bunch up by a zone-in
+
+== 1/15/2019 ==
+Uleat: Activated per-expansion support for active inventory slot addressing
+	- Server honors expansions that alter bank size and power source, general9 and general10 slots
+	- Server honors gm flag behaviors for the active inventory slots of each client
+
+== 1/11/2019 ==
+Uleat: Modified rules system to ignore all runtime modifications of 'World:ExpansionSettings' and 'World:UseClientBasedExpansionSettings' fields.
+	- These fields are no longer allowed to be changed during server runtime through the command system
+	- Major syncronization issues between server and clients result when these fields are altered in-game
+	- It is not recommended to update these fields via sql queries while the server is in operation
+	- Failure to observe these warnings will result in abhorant behavior and loss of items
+	- Modify these fields during server operation at your own risk!
+
+== 1/4/2019 ==
+Akkadius: [Scaling] Global base scaling data has been updated in new database binary revision
+
+== 1/1/2019 ==
+Akkadius:
+    - [Logging] Added new logging category "MobAppearance"
+    - [DevTools] Proximity show of NPC now shows a "Path finding" circle around the proximity nodes to more clearly display
+    - [Scaling] Global base scaling data now refreshes from the database on #repop
+    - [Commands] Implemented command #killallnpcs [npc_name] for testing, leave blank for all attackable NPC's
+    - NPC and Player Textures
+        - Textures that have been changed with #wearchange / #wc or any wearchange quest script call will now stick
+            for new clients entering a zone
+        - Weapon models for NPCs changed using wearchange will stick as well during combat and when new clients enter the zone
+        - The above changes allow for customization of a zone and NPC's without needing static data configured on npc_types
+            table data and allows for much more customization options
+        - Implemented Quest API Calls
+            Perl
+                $client->SetPrimaryWeaponOrnamentation(uint32 model_id);
+                $client->SetSecondaryWeaponOrnamentation(uint32 model_id);
+            Lua
+                client:SetPrimaryWeaponOrnamentation(uint32 model_id);
+                client:SetSecondaryWeaponOrnamentation(uint32 model_id);
+            - Both of these API calls persist an ornamentation to the weapon in the inventory table and will load both
+                in character select and cross zone
+
+== 12/30/2018 ==
+
+Akkadius (KLS):
+
+# NPC Movement Overhaul
+
+"Recently, we landed massive changes to pathing logic (Navmesh) with NPC's that took a while to iron out but has been
+    an immensely positive addition to the EQEmu server core. With that, it's made us realize how much some related
+    functionality needed to be addressed and that involves "NPC movement logic". We've been needing to address
+    NPC movement logic for years as it has been fragmented and inconsistent all over the code which has made
+    fixing actual movement related issues a nightmare. There are many other technical things that we can go
+    into about it but the important part is that it is much improved! Special thanks to KLS for putting in a
+    lot of work to make this happen"
+
+    - NPC's should now smoothly path between source and destination, rather than "skipping" all over the place between
+        path points and sending sometimes several position updates, there should only be one update until NPC
+        changes heading or speed
+    - NPC pathing during flee and fear should be far improved
+    - NPC pathing inside of water should be far improved
+    - NPC transitions between water and land should now be seamless
+    - NPC transitions over verticals (hills) should be smoother as well
+    - NPC "Stuck" logic during path finding should be improved
+    - NPC Z coordinate plane correction now occurs during path calculation projection properly (as it should) instead of
+        brute forcing the current Z location along different path projections
+        - Example: https://bit.ly/2Ssn4Yp
+
+== 12/16/2018 ==
+Akkadius:
+    - Implemented: Global Base Scaling: https://github.com/EQEmu/Server/wiki/NPC-Scaling
+    - Implemented: Beginning of DevTools - more to be added over time (Status >= 200)
+        - Display NPC info on target
+        - Display Client info on target
+        - Display NPC show commands on target
+            - Loot
+            - Grids
+            - Emotes
+    - Implemented: Support for saylinks to be used in GM commands
+    - Deprecated: Commands
+        - #listnpcs
+    - Implemented: Commands
+        - #list [npcs|players|corpses|doors|objects] [search]
+            - Provides clickable saylinks to go to entities
+        - #scale [static/dynamic] (With targeted NPC)
+        - #scale [npc_name_search] [static/dynamic] (To make zone-wide changes)
+        - #scale all [static/dynamic]
+        - #devtools (alias #dev)
+    - Implemented: New Logging categories automatically injected into `logsys_categories` table
+        - Fixed an issue where newly injected categories were turned on by default
+
+== 12/15/2018 ==
+Kinglykrab: Added multiple new instance related quest functions.
+	1. quest::GetInstanceIDByCharID(const char *zone, int16 version, uint32 char_id)
+		- Allows you to pull the instance ID of a client by character ID.
+	2. quest::AssignToInstanceByCharID(uint16 instance_id, uint32 char_id)
+		- Allows you to assign an instance to a client by character ID.
+	3. quest::RemoveFromInstanceByCharID(uint16 instance_id, uint32 char_id)
+		- Allows you to remove a client from an instance by character ID.
+
+	Added spell buckets, similar to spell globals.
+		- Uses a new spell_buckets table and the Spells:EnableSpellBuckets rule.
+	
+	Added max level by data bucket.
+		- Uses data bucket char_id-CharMaxLevel and Character:PerCharacterBucketMaxLevel rule.
+
+== 10/09/2018 ==
+Uleat: Added bot owner options
+	- usage: ^owneroption [option] (or aliased as: ^oo [option])
+	- options are saved in the database and therefore, persistent
+	- Implemented option 'deathmarquee'
+	-- toggles client owner flag to show marquee message when a bot dies (default: disabled)
+	
+== 10/07/2018 ==
+Uleat: Fixed a few bot issues..
+	- Fix for bot item trades not attuning
+	- Fix for bot mana, endurance not updating properly
+
+== 10/06/2018 ==
+Uleat: Fixed a few bot issues..
+	- Fix for bot 'stop melee level' not honoring setting level over rule level
+	- Fix for missing bot combat spell casting when within melee range
+	- Fix (in-work) for bots 'forgetting' current target when it flees
+
+== 09/18/2018 ==
+Uleat: Notes for manual conversion of quest script inventory slot values
+	- You should use reference/lookup values provided by the lua and perl apis to avoid skirting safety checks
+		and to ensure that the values used are the correct ones for your needs
+	
+	[perl api examples]
+		old:
+			1) my $charmitem = $client->GetItemIDAt(0);
+			2) for($for_x = 22; $for_x < 30; $for_x++) {...}
+			3) for($slot1 = 0; $slot1 <= 30; $slot1++) {...}
+		
+		new:
+			1) my $charmitem = $client->GetItemIDAt(quest::getinventoryslotid("charm"));
+			2) for($for_x = quest::getinventoryslotid("general.begin"); $for_x <= quest::getinventoryslotid("general.end"); $for_x++) {...} ** notice change of conditional
+			3) for($slot1 = quest::getinventoryslotid("possessions.begin"); $slot1 <= quest::getinventoryslotid("possessions.end"); $slot1++) {...}
+	
+	[lua api examples]
+		old:
+			1) if(e.self:GetItemIDAt(30) == 31599) then ...
+			2) for i = 0, 30, 1 do ...
+			
+		new:
+			1) if(e.self:GetItemIDAt(Slot.Cursor) == 31599) then ...
+			2) for i = Slot.PossessionsBegin, Slot.PossessionsEnd, 1 do ...
+	
+	- If you need to manually assign bag slot ranges to individual 'general' slots, use this assignment for now:
+		-- General1  (23) = 251 .. 260
+		-- General2  (24) = 261 .. 270
+		-- General3  (25) = 271 .. 280
+		-- General4  (26) = 281 .. 290
+		-- General5  (27) = 291 .. 300
+		-- General6  (28) = 301 .. 310
+		-- General7  (29) = 311 .. 320
+		-- General8  (30) = 321 .. 330
+		-- General9  (31) = 331 .. 340
+		-- General10 (32) = 341 .. 350
+		-- Cursor    (33) = 351 .. 360
+	
+	- If you need to manually assign ammo or powersource slots, use these values:
+		-- PowerSource = 21
+		-- Ammo = 22
+	
+	- All slot values not addressed above remain the same
+	
+	- Additional information can be found at:
+		-- https://github.com/EQEmu/Server/wiki/Inventory-Slots
+		-- https://github.com/EQEmu/Server/wiki/Perl-API
+		-- https://github.com/EQEmu/Server/wiki/Lua-API
+
+== 09/03/2018 ==
+Uleat: Rework of 'invsnapshot' command and implementation of automatic inventory snapshots.
+	- Inventory snapshots are now taken automatically using the interval rule values - if snapshots are enabled
+	- Command 'invsnapshot' now has more options available to include a restore feature
+	-- A pop-up help menu is available
+	-- argument 'capture' is available to anyone with status high enough to register the command
+	-- Advanced options are only available to players with 150 status or greater
+	-- argument 'list' provides a list of "timestamp : item count" entries
+	-- argument 'parse' displays a "slot : item id : item name" listing of valid snapshots by timestamp
+	-- argument 'compare' shows a 'difference' comparison of "snapshot-to-inventory" changes
+	-- argument 'restore' applies a saved snapshot to the player's inventory (with a pre-clearing call)
+
+== 08/13/2018 ==
+Uleat: Activation of RoF+ clients' two additional general slots and integration of SoF+ clients' PowerSource slot
+	- Inventory 'Possessions' main slots are now contiguous and implemented to RoF2 standards
+	-- 'slotGeneral9'(31) and 'slotGeneral10'(32) are now active
+	-- Possessions slot enumerations are now defined as between 'slotCharm'(0) and 'slotCursor'(33)
+	-- 'slotPowerSource'(21) is no longer a special case slot(9999)
+	- Special code has been added to exclude 'slotPowerSource,' 'slotGeneral9' and 'slotGeneral10' from server
+		actions in clients that do not support them.
+	- The lua api has been updated to use the new slot enumeration as well as having some slot range definitions added
+	- The perl api now has a look-up function to provide token-to-value translations .. definitions are similar to lua
+	- In both lua and perl, it is HIGHLY recommended that any custom scripts using hard-coded inventory slot values be
+		updated to use the constants/lookup methods as any old values are no longer guaranteed to be accurate
+	- Database will have existing inventory slot values modified to the new standard and table `items` entries will
+		also be updated to the 'correct' equipable slot bitmask
+	- Script (quest) updates are required with this change
+	
+Note: The proper way to reference inventory slots is to use either instrinsic lookups (c/c++ & perl) or to use valid
+	const ref declarations (c/c++ & lua). Any other method is not guaranteed to be accurate and may result in item loss
+	and/or unexpected/undefined behavior.
+	
+
 == 07/10/2018 ==
 Akkadius: Adjusted DataBuckets to use other acceptable time formats
     Example: quest::set_data('key', 'value', '1d');

client_files/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 
 add_subdirectory(import)
 add_subdirectory(export)

client_files/export/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 
 SET(export_sources
 	main.cpp

client_files/export/main.cpp

@@ -60,6 +60,29 @@ int main(int argc, char **argv) {
 	database.LoadLogSettings(LogSys.log_settings);
 	LogSys.StartFileLogs();
 
+	std::string arg_1;
+
+	if (argv[1]) {
+		arg_1 = argv[1];
+	}
+
+	if (arg_1 == "spells") {
+		ExportSpells(&database);
+		return 0;
+	}
+	if (arg_1 == "skills") {
+		ExportSkillCaps(&database);
+		return 0;
+	}
+	if (arg_1 == "basedata") {
+		ExportBaseData(&database);
+		return 0;
+	}
+	if (arg_1 == "dbstring") {
+		ExportDBStrings(&database);
+		return 0;
+	}
+
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);

client_files/import/CMakeLists.txt

@@ -1,4 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 
 SET(import_sources
 	main.cpp

cmake/FindEQLua51.cmake

@@ -1,124 +0,0 @@
-#CMake - Cross Platform Makefile Generator
-#Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
-#All rights reserved.
-#
-#Redistribution and use in source and binary forms, with or without
-#modification, are permitted provided that the following conditions
-#are met:
-#
-#* Redistributions of source code must retain the above copyright
-#  notice, this list of conditions and the following disclaimer.
-#
-#* Redistributions in binary form must reproduce the above copyright
-#  notice, this list of conditions and the following disclaimer in the
-#  documentation and/or other materials provided with the distribution.
-#
-#* Neither the names of Kitware, Inc., the Insight Software Consortium,
-#  nor the names of their contributors may be used to endorse or promote
-#  products derived from this software without specific prior written
-#  permission.
-#
-#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-#"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-#LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-#A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-#HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-#SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-#LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-#DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-#THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-#(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# This module defines
-#  LUA51_FOUND, if false, do not try to link to Lua
-#  LUA_LIBRARIES
-#  LUA_INCLUDE_DIR, where to find lua.h
-#  LUA_VERSION_STRING, the version of Lua found (since CMake 2.8.8)
-
-IF(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include src
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		${LUA_ROOT}
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ELSE(LUA_ROOT)
-	FIND_PATH(LUA_INCLUDE_DIR
-		NAMES lua.h
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES include/lua51 include/lua5.1 include/lua include
-	)
-	
-	FIND_LIBRARY(LUA_LIBRARY
-		NAMES lua51 lua5.1 lua-5.1 lua
-		HINTS
-			ENV LUA_DIR
-		PATHS
-		~/Library/Frameworks
-		/Library/Frameworks
-		/sw
-		/opt/local
-		/opt/csw
-		/opt
-		PATH_SUFFIXES lib bin
-	)
-ENDIF(LUA_ROOT)
-
-IF(LUA_LIBRARY)
-	# include the math library for Unix
-	IF(UNIX AND NOT APPLE)
-		FIND_LIBRARY(LUA_MATH_LIBRARY m)
-	SET(LUA_LIBRARIES "${LUA_LIBRARY};${LUA_MATH_LIBRARY}" CACHE STRING "Lua Libraries")
-	# For Windows and Mac, don't need to explicitly include the math library
-	ELSE()
-		SET( LUA_LIBRARIES "${LUA_LIBRARY}" CACHE STRING "Lua Libraries")
-	ENDIF()
-ENDIF()
-
-IF(LUA_INCLUDE_DIR AND EXISTS "${LUA_INCLUDE_DIR}/lua.h")
-	FILE(STRINGS "${LUA_INCLUDE_DIR}/lua.h" lua_version_str REGEX "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua .+\"")
-
-	STRING(REGEX REPLACE "^#define[ \t]+LUA_RELEASE[ \t]+\"Lua ([^\"]+)\".*" "\\1" LUA_VERSION_STRING "${lua_version_str}")
-	UNSET(lua_version_str)
-ENDIF()
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(Lua51
-                                  REQUIRED_VARS LUA_LIBRARIES LUA_INCLUDE_DIR
-                                  VERSION_VAR LUA_VERSION_STRING)
-
-MARK_AS_ADVANCED(LUA_INCLUDE_DIR LUA_LIBRARIES LUA_LIBRARY LUA_MATH_LIBRARY)
-
-

cmake/FindMariaDB.cmake

@@ -0,0 +1,87 @@
+# - Find mariadbclient
+#
+# -*- cmake -*-
+#
+# Find the native MariaDB includes and library
+#
+#	MariaDB_INCLUDE_DIR	- where to find mysql.h, etc.
+#	MariaDB_LIBRARIES		- List of libraries when using MariaDB.
+#	MariaDB_FOUND			- True if MariaDB found.
+#	The following can be used as a hint as to where to search:
+#	MARIADB_ROOT
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+	# Already in cache, be silent
+	SET(MariaDB_FIND_QUIETLY TRUE)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARIES)
+
+# Include dir
+IF(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATHS ${MARIADB_ROOT}/include
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_PATH(MariaDB_INCLUDE_DIR
+		NAMES mariadb_version.h
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+# Library
+SET(MariaDB_NAMES libmariadb)
+IF(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATHS ${MARIADB_ROOT}/lib
+		PATH_SUFFIXES mysql mariadb
+		NO_DEFAULT_PATH
+		NO_SYSTEM_ENVIRONMENT_PATH
+	)
+	
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES}
+		PATH_SUFFIXES mysql mariadb
+	)
+ELSE(MARIADB_ROOT)
+	FIND_LIBRARY(MariaDB_LIBRARY
+		NAMES ${MariaDB_NAMES} mariadbclient_r mariadbclient
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql mariadb
+	)
+ENDIF(MARIADB_ROOT)
+
+IF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND TRUE)
+	SET(MariaDB_LIBRARIES ${MariaDB_LIBRARY})
+ELSE (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+	SET(MariaDB_FOUND FALSE)
+	SET(MariaDB_LIBRARIES)
+ENDIF (MariaDB_INCLUDE_DIR AND MariaDB_LIBRARY)
+
+
+# handle the QUIETLY and REQUIRED arguments and set MariaDB_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MariaDB DEFAULT_MSG MariaDB_LIBRARY MariaDB_INCLUDE_DIR)
+
+IF(MariaDB_FOUND)
+	SET( MariaDB_LIBRARY_RELEASE ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARY_DEBUG ${MariaDB_LIBRARY} )
+	SET( MariaDB_LIBRARIES ${MariaDB_LIBRARY_RELEASE} ${MariaDB_LIBRARY_DEBUG} )
+ELSE(MariaDB_FOUND)
+	SET( MariaDB_LIBRARIES )
+ENDIF(MariaDB_FOUND)
+
+MARK_AS_ADVANCED(
+	MariaDB_LIBRARY_DEBUG
+	MariaDB_LIBRARY_RELEASE
+	MariaDB_INCLUDE_DIR
+	)

cmake/FindmbedTLS.cmake

@@ -0,0 +1,93 @@
+# - Try to find mbedTLS
+# Once done this will define
+#
+# Read-Only variables
+#  MBEDTLS_FOUND - system has mbedTLS
+#  MBEDTLS_INCLUDE_DIR - the mbedTLS include directory
+#  MBEDTLS_LIBRARY_DIR - the mbedTLS library directory
+#  MBEDTLS_LIBRARIES - Link these to use mbedTLS
+#  MBEDTLS_LIBRARY - path to mbedTLS library
+#  MBEDX509_LIBRARY - path to mbedTLS X.509 library
+#  MBEDCRYPTO_LIBRARY - path to mbedTLS Crypto library
+#
+# Hint
+#  MBEDTLS_ROOT_DIR can be pointed to a local mbedTLS installation.
+
+SET(_MBEDTLS_ROOT_HINTS
+    ${MBEDTLS_ROOT_DIR}
+    ENV MBEDTLS_ROOT_DIR
+)
+
+SET(_MBEDTLS_ROOT_HINTS_AND_PATHS
+    HINTS ${_MBEDTLS_ROOT_HINTS}
+    PATHS ${_MBEDTLS_ROOT_PATHS}
+)
+
+FIND_PATH(MBEDTLS_INCLUDE_DIR
+    NAMES mbedtls/version.h
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES include
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARIES)
+    # Already in cache, be silent
+    SET(MBEDTLS_FIND_QUIETLY TRUE)
+ENDIF()
+
+FIND_LIBRARY(MBEDTLS_LIBRARY
+    NAMES mbedtls libmbedtls
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDX509_LIBRARY
+    NAMES mbedx509 libmbedx509
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+FIND_LIBRARY(MBEDCRYPTO_LIBRARY
+    NAMES mbedcrypto libmbedcrypto
+    ${_MBEDTLS_ROOT_HINTS_AND_PATHS}
+    PATH_SUFFIXES library
+)
+
+IF(MBEDTLS_INCLUDE_DIR AND MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
+     SET(MBEDTLS_FOUND TRUE)
+ENDIF()
+
+IF(MBEDTLS_FOUND)
+    # split mbedTLS into -L and -l linker options, so we can set them for pkg-config
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_DIR ${MBEDTLS_LIBRARY} PATH)
+    GET_FILENAME_COMPONENT(MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY} NAME_WE)
+    GET_FILENAME_COMPONENT(MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY} NAME_WE)
+    STRING(REGEX REPLACE "^lib" "" MBEDTLS_LIBRARY_FILE ${MBEDTLS_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDX509_LIBRARY_FILE ${MBEDX509_LIBRARY_FILE})
+    STRING(REGEX REPLACE "^lib" "" MBEDCRYPTO_LIBRARY_FILE ${MBEDCRYPTO_LIBRARY_FILE})
+    SET(MBEDTLS_LIBRARIES "-L${MBEDTLS_LIBRARY_DIR} -l${MBEDTLS_LIBRARY_FILE} -l${MBEDX509_LIBRARY_FILE} -l${MBEDCRYPTO_LIBRARY_FILE}")
+
+    IF(NOT MBEDTLS_FIND_QUIETLY)
+        MESSAGE(STATUS "Found mbedTLS:")
+        FILE(READ ${MBEDTLS_INCLUDE_DIR}/mbedtls/version.h MBEDTLSCONTENT)
+        STRING(REGEX MATCH "MBEDTLS_VERSION_STRING +\"[0-9|.]+\"" MBEDTLSMATCH ${MBEDTLSCONTENT})
+        IF (MBEDTLSMATCH)
+            STRING(REGEX REPLACE "MBEDTLS_VERSION_STRING +\"([0-9|.]+)\"" "\\1" MBEDTLS_VERSION ${MBEDTLSMATCH})
+            MESSAGE(STATUS "  version ${MBEDTLS_VERSION}")
+        ENDIF(MBEDTLSMATCH)
+        MESSAGE(STATUS "  TLS: ${MBEDTLS_LIBRARY}")
+        MESSAGE(STATUS "  X509: ${MBEDX509_LIBRARY}")
+        MESSAGE(STATUS "  Crypto: ${MBEDCRYPTO_LIBRARY}")
+    ENDIF(NOT MBEDTLS_FIND_QUIETLY)
+ELSE(MBEDTLS_FOUND)
+    IF(MBEDTLS_FIND_REQUIRED)
+        MESSAGE(FATAL_ERROR "Could not find mbedTLS")
+    ENDIF(MBEDTLS_FIND_REQUIRED)
+ENDIF(MBEDTLS_FOUND)
+
+MARK_AS_ADVANCED(
+    MBEDTLS_INCLUDE_DIR
+    MBEDTLS_LIBRARY_DIR
+    MBEDTLS_LIBRARIES
+    MBEDTLS_LIBRARY
+    MBEDX509_LIBRARY
+    MBEDCRYPTO_LIBRARY
+)

common/CMakeLists.txt

@@ -1,5 +1,4 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10)
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
@@ -55,6 +54,7 @@ SET(common_sources
 	perl_eqdb.cpp
 	perl_eqdb_res.cpp
 	proc_launcher.cpp
+	profanity_manager.cpp
 	ptimer.cpp
 	races.cpp
 	rdtsc.cpp
@@ -72,7 +72,6 @@ SET(common_sources
 	unix.cpp
 	xml_parser.cpp
 	platform.cpp
-	event/event_loop.cpp
 	json/jsoncpp.cpp
 	net/console_server.cpp
 	net/console_server_connection.cpp
@@ -86,6 +85,8 @@ SET(common_sources
 	net/servertalk_server_connection.cpp
 	net/tcp_connection.cpp
 	net/tcp_server.cpp
+	net/websocket_server.cpp
+	net/websocket_server_connection.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sod_limits.cpp
@@ -136,6 +137,7 @@ SET(common_headers
 	eqemu_config.h
 	eqemu_config_elements.h
 	eqemu_logsys.h
+	eqemu_logsys_fmt.h
 	eq_limits.h
 	eq_packet.h
 	eq_stream_ident.h
@@ -181,6 +183,7 @@ SET(common_headers
 	packet_functions.h
 	platform.h
 	proc_launcher.h
+	profanity_manager.h
 	profiler.h
 	ptimer.h
 	queue.h
@@ -207,8 +210,9 @@ SET(common_headers
 	version.h
 	xml_parser.h
 	zone_numbers.h
-	event/background_task.h
 	event/event_loop.h
+	event/idle.h
+	event/task.h
 	event/timer.h
 	json/json.h
 	json/json-forwards.h
@@ -228,6 +232,8 @@ SET(common_headers
 	net/servertalk_server_connection.h
 	net/tcp_connection.h
 	net/tcp_server.h
+	net/websocket_server.h
+	net/websocket_server_connection.h
 	patches/patches.h
 	patches/sod.h
 	patches/sod_limits.h
@@ -265,10 +271,10 @@ SET(common_headers
 )
 
 SOURCE_GROUP(Event FILES
-	event/background_task.h
-	event/event_loop.cpp
 	event/event_loop.h
+	event/idle.h
 	event/timer.h
+	event/task.h
 )
 
 SOURCE_GROUP(Json FILES
@@ -308,6 +314,10 @@ SOURCE_GROUP(Net FILES
 	net/tcp_connection.h
 	net/tcp_server.cpp
 	net/tcp_server.h
+	net/websocket_server.cpp
+	net/websocket_server.h
+	net/websocket_server_connection.cpp
+	net/websocket_server_connection.h
 )
 
 SOURCE_GROUP(Patches FILES

common/StackWalker/StackWalker.cpp

@@ -23,7 +23,7 @@
  *  2005-08-05   v5    - Removed most Lint (http://www.gimpel.com/) errors... thanks to Okko Willeboordse!
  *
  **********************************************************************/
-#ifdef _WINDOWS
+#ifdef _WIN32
 #include <windows.h>
 #include <tchar.h>
 #include <stdio.h>

common/StackWalker/StackWalker.h

@@ -9,7 +9,7 @@
  * 2013-01-26          - Modified by KimLS(KLS) for EQEmu's purposes
  *
  **********************************************************************/
-#ifdef _WINDOWS
+#ifdef _WIN32
 // #pragma once is supported starting with _MCS_VER 1000, 
 // so we need not to check the version (because we only support _MSC_VER >= 1100)!
 #pragma once

common/base_packet.h

@@ -23,7 +23,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#ifdef _WINDOWS
+#ifdef _WIN32
 	#include <time.h>
 	#include <winsock2.h>
 	#include <windows.h>
@@ -75,6 +75,7 @@ public:
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }
+	void ReadString(std::string &str) { str = reinterpret_cast<char *>(pBuffer + _rpos); _rpos += str.length() + 1; }
 	void ReadString(char *str, uint32 Offset, uint32 MaxLength) const;
 
 	uint32 GetWritePosition() { return _wpos; }

common/condition.cpp

@@ -18,7 +18,7 @@
 
 #include "condition.h"
 
-#ifdef _WINDOWS
+#ifdef _WIN32
 
 	Condition::Condition()
 	{

common/condition.h

@@ -20,7 +20,7 @@
 
 #include "global_define.h"
 #include "mutex.h"
-#ifndef WIN32
+#ifndef _WIN32
 #include <pthread.h>
 #endif
 
@@ -30,7 +30,7 @@
 
 class Condition {
 	private:
-#ifdef WIN32
+#ifdef _WIN32
 		enum {
 			SignalEvent = 0,
 			BroadcastEvent,

common/crash.cpp

@@ -2,7 +2,7 @@
 #include "eqemu_logsys.h"
 #include "crash.h"
 
-#if defined(_WINDOWS) && defined(CRASH_LOGGING)
+#if defined(_WIN32) && defined(CRASH_LOGGING)
 #include "StackWalker.h"
 
 class EQEmuStackWalker : public StackWalker

common/data_verification.h

@@ -17,11 +17,10 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
-#ifndef COMMON_DATA_VERIFICATION_H
-#define COMMON_DATA_VERIFICATION_H
+#pragma once
 
 #include <algorithm>
-
+#include <cmath>
 
 namespace EQEmu
 {
@@ -52,4 +51,3 @@ namespace EQEmu
 
 } /*EQEmu*/
 
-#endif /*COMMON_DATA_VERIFICATION_H*/

common/database.cpp

@@ -30,7 +30,7 @@
 #include <string.h>
 
 // Disgrace: for windows compile
-#ifdef _WINDOWS
+#ifdef _WIN32
 #include <windows.h>
 #define snprintf	_snprintf
 #define strncasecmp	_strnicmp
@@ -171,30 +171,27 @@ void Database::LoginIP(uint32 AccountID, const char* LoginIP) {
 	QueryDatabase(query); 
 }
 
-int16 Database::CheckStatus(uint32 account_id) {
-	std::string query = StringFormat("SELECT `status`, UNIX_TIMESTAMP(`suspendeduntil`) as `suspendeduntil`, UNIX_TIMESTAMP() as `current`"
-							" FROM `account` WHERE `id` = %i", account_id);
+int16 Database::CheckStatus(uint32 account_id)
+{
+	std::string query = StringFormat(
+	    "SELECT `status`, TIMESTAMPDIFF(SECOND, NOW(), `suspendeduntil`) FROM `account` WHERE `id` = %i",
+	    account_id);
 
-	auto results = QueryDatabase(query); 
-	if (!results.Success()) {
+	auto results = QueryDatabase(query);
+	if (!results.Success())
 		return 0;
-	}
 
 	if (results.RowCount() != 1)
 		return 0;
-	
-	auto row = results.begin(); 
-	int16 status = atoi(row[0]); 
-	int32 suspendeduntil = 0;
 
-	// MariaDB initalizes with NULL if unix_timestamp() is out of range
-	if (row[1] != nullptr) {
-		suspendeduntil = atoi(row[1]);
-	}
+	auto row = results.begin();
+	int16 status = atoi(row[0]);
+	int32 date_diff = 0;
 
-	int32 current = atoi(row[2]);
+	if (row[1] != nullptr)
+		date_diff = atoi(row[1]);
 
-	if(suspendeduntil > current)
+	if (date_diff > 0)
 		return -1;
 
 	return status;
@@ -1408,25 +1405,39 @@ uint8 Database::GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16
 	return base_cap;
 }
 
-uint32 Database::GetCharacterInfo(const char* iName, uint32* oAccID, uint32* oZoneID, uint32* oInstanceID, float* oX, float* oY, float* oZ) { 
-	std::string query = StringFormat("SELECT `id`, `account_id`, `zone_id`, `zone_instance`, `x`, `y`, `z` FROM `character_data` WHERE `name` = '%s'", iName);
+uint32 Database::GetCharacterInfo(
+	const char *iName,
+	uint32 *oAccID,
+	uint32 *oZoneID,
+	uint32 *oInstanceID,
+	float *oX,
+	float *oY,
+	float *oZ
+)
+{
+	std::string query = StringFormat(
+		"SELECT `id`, `account_id`, `zone_id`, `zone_instance`, `x`, `y`, `z` FROM `character_data` WHERE `name` = '%s'",
+		EscapeString(iName).c_str()
+	);
+
 	auto results = QueryDatabase(query);
 
 	if (!results.Success()) {
 		return 0;
 	}
 
-	if (results.RowCount() != 1)
+	if (results.RowCount() != 1) {
 		return 0;
+	}
 
-	auto row = results.begin();
+	auto   row    = results.begin();
 	uint32 charid = atoi(row[0]);
-	if (oAccID){ *oAccID = atoi(row[1]); }
-	if (oZoneID){ *oZoneID = atoi(row[2]); }
-	if (oInstanceID){ *oInstanceID = atoi(row[3]); }
-	if (oX){ *oX = atof(row[4]); }
-	if (oY){ *oY = atof(row[5]); }
-	if (oZ){ *oZ = atof(row[6]); }
+	if (oAccID) { *oAccID = atoi(row[1]); }
+	if (oZoneID) { *oZoneID = atoi(row[2]); }
+	if (oInstanceID) { *oInstanceID = atoi(row[3]); }
+	if (oX) { *oX = atof(row[4]); }
+	if (oY) { *oY = atof(row[5]); }
+	if (oZ) { *oZ = atof(row[6]); }
 
 	return charid;
 }
@@ -2063,58 +2074,114 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)
 	return atoi(row[0]);
 }
 
-void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
-{
+void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings) {
 	// log_settings previously initialized to '0' by EQEmuLogSys::LoadLogSettingsDefaults()
-	
-	std::string query = 
-		"SELECT "
-		"log_category_id, "
-		"log_category_description, "
-		"log_to_console, "
-		"log_to_file, "
-		"log_to_gmsay "
-		"FROM "
-		"logsys_categories "
-		"ORDER BY log_category_id";
+
+	std::string query =
+					"SELECT "
+					"log_category_id, "
+					"log_category_description, "
+					"log_to_console, "
+					"log_to_file, "
+					"log_to_gmsay "
+					"FROM "
+					"logsys_categories "
+					"ORDER BY log_category_id";
+
 	auto results = QueryDatabase(query);
 
-	int log_category = 0;
-	LogSys.file_logs_enabled = false;
+	int log_category_id = 0;
+
+	int categories_in_database[1000] = {};
 
 	for (auto row = results.begin(); row != results.end(); ++row) {
-		log_category = atoi(row[0]);
-		if (log_category <= Logs::None || log_category >= Logs::MaxCategoryID)
+		log_category_id = atoi(row[0]);
+		if (log_category_id <= Logs::None || log_category_id >= Logs::MaxCategoryID) {
 			continue;
+		}
 
-		log_settings[log_category].log_to_console = atoi(row[2]);
-		log_settings[log_category].log_to_file = atoi(row[3]);
-		log_settings[log_category].log_to_gmsay = atoi(row[4]);
+		log_settings[log_category_id].log_to_console = static_cast<uint8>(atoi(row[2]));
+		log_settings[log_category_id].log_to_file    = static_cast<uint8>(atoi(row[3]));
+		log_settings[log_category_id].log_to_gmsay   = static_cast<uint8>(atoi(row[4]));
 
-		/* Determine if any output method is enabled for the category 
-			and set it to 1 so it can used to check if category is enabled */
-		const bool log_to_console = log_settings[log_category].log_to_console > 0;
-		const bool log_to_file = log_settings[log_category].log_to_file > 0;
-		const bool log_to_gmsay = log_settings[log_category].log_to_gmsay > 0;
+		/**
+		 * Determine if any output method is enabled for the category
+		 * and set it to 1 so it can used to check if category is enabled
+		 */
+		const bool log_to_console      = log_settings[log_category_id].log_to_console > 0;
+		const bool log_to_file         = log_settings[log_category_id].log_to_file > 0;
+		const bool log_to_gmsay        = log_settings[log_category_id].log_to_gmsay > 0;
 		const bool is_category_enabled = log_to_console || log_to_file || log_to_gmsay;
 
-		if (is_category_enabled)
-			log_settings[log_category].is_category_enabled = 1;
+		if (is_category_enabled) {
+			log_settings[log_category_id].is_category_enabled = 1;
+		}
 
-		/* 
-			This determines whether or not the process needs to actually file log anything.
-			If we go through this whole loop and nothing is set to any debug level, there is no point to create a file or keep anything open
-		*/
-		if (log_settings[log_category].log_to_file > 0){
+		/**
+		 * This determines whether or not the process needs to actually file log anything.
+		 * If we go through this whole loop and nothing is set to any debug level, there is no point to create a file or keep anything open
+		 */
+		if (log_settings[log_category_id].log_to_file > 0) {
 			LogSys.file_logs_enabled = true;
 		}
+
+		categories_in_database[log_category_id] = 1;
+	}
+
+	/**
+	 * Auto inject categories that don't exist in the database...
+	 */
+	for (int log_index = Logs::AA; log_index != Logs::MaxCategoryID; log_index++) {
+		if (!categories_in_database[log_index]) {
+
+			Log(Logs::General,
+				Logs::Status,
+				"New Log Category '%s' doesn't exist... Automatically adding to `logsys_categories` table...",
+				Logs::LogCategoryName[log_index]
+			);
+
+			std::string inject_query = StringFormat(
+				"INSERT INTO logsys_categories "
+				"(log_category_id, "
+				"log_category_description, "
+				"log_to_console, "
+				"log_to_file, "
+				"log_to_gmsay) "
+				"VALUES "
+				"(%i, '%s', %i, %i, %i)",
+				log_index,
+				EscapeString(Logs::LogCategoryName[log_index]).c_str(),
+				log_settings[log_category_id].log_to_console,
+				log_settings[log_category_id].log_to_file,
+				log_settings[log_category_id].log_to_gmsay
+			);
+
+			QueryDatabase(inject_query);
+		}
 	}
 }
 
-void Database::ClearInvSnapshots(bool use_rule)
-{
+int Database::CountInvSnapshots() {
+	std::string query = StringFormat("SELECT COUNT(*) FROM (SELECT * FROM `inventory_snapshots` a GROUP BY `charid`, `time_index`) b");
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return -1;
+
+	auto row = results.begin();
+
+	int64 count = atoll(row[0]);
+	if (count > 2147483647)
+		return -2;
+	if (count < 0)
+		return -3;
+
+	return count;
+}
+
+void Database::ClearInvSnapshots(bool from_now) {
 	uint32 del_time = time(nullptr);
-	if (use_rule) { del_time -= RuleI(Character, InvSnapshotHistoryD) * 86400; }
+	if (!from_now) { del_time -= RuleI(Character, InvSnapshotHistoryD) * 86400; }
 
 	std::string query = StringFormat("DELETE FROM inventory_snapshots WHERE time_index <= %lu", (unsigned long)del_time);
 	QueryDatabase(query);

common/database.h

@@ -82,17 +82,9 @@ struct VarCache_Struct {
 };
 
 class PTimerList;
+#	define _ISNAN_(a) std::isnan(a)
 
-#ifdef _WINDOWS
-#if _MSC_VER > 1700 // greater than 2012 (2013+)
-#	define _ISNAN_(a) std::isnan(a)
-#else
-#	include <float.h>
-#	define _ISNAN_(a) _isnan(a)
-#endif
-#else
-#	define _ISNAN_(a) std::isnan(a)
-#endif
+#define SQL(...) #__VA_ARGS__
 
 class Database : public DBcore {
 public:
@@ -264,7 +256,8 @@ public:
 	void	SetLFP(uint32 CharID, bool LFP);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
 
-	void	ClearInvSnapshots(bool use_rule = true);
+	int		CountInvSnapshots();
+	void	ClearInvSnapshots(bool from_now = false);
 
 	/* EQEmuLogSys */
 	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);

common/database_conversions.cpp

@@ -28,7 +28,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include <iostream>
 
 // Disgrace: for windows compile
-#ifdef _WINDOWS
+#ifdef _WIN32
 #include <windows.h>
 #define snprintf	_snprintf
 #define strncasecmp	_strnicmp
@@ -217,7 +217,7 @@ namespace Convert {
 		/*0245*/	uint8							guildbanker;
 		/*0246*/	uint8							unknown0246[6];		//
 		/*0252*/	uint32							intoxication;
-		/*0256*/	uint32							spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
+		/*0256*/	uint32							spellSlotRefresh[9];	//in ms
 		/*0292*/	uint32							abilitySlotRefresh;
 		/*0296*/	uint8							haircolor;			// Player hair color
 		/*0297*/	uint8							beardcolor;			// Player beard color
@@ -256,9 +256,9 @@ namespace Convert {
 		/*2505*/	uint8							unknown2541[47];	// ?
 		/*2552*/	uint8							languages[MAX_PP_LANGUAGE];
 		/*2580*/	uint8							unknown2616[4];
-		/*2584*/	uint32							spell_book[MAX_PP_REF_SPELLBOOK];
+		/*2584*/	uint32							spell_book[480];
 		/*4504*/	uint8							unknown4540[128];	// Was [428] all 0xff
-		/*4632*/	uint32							mem_spells[MAX_PP_REF_MEMSPELL];
+		/*4632*/	uint32							mem_spells[9];
 		/*4668*/	uint8							unknown4704[32];	//
 		/*4700*/	float							y;					// Player y position
 		/*4704*/	float							x;					// Player x position
@@ -476,7 +476,7 @@ bool Database::CheckDatabaseConversions() {
 	CheckDatabaseConvertCorpseDeblob();
 
 	/* Run EQEmu Server script (Checks for database updates) */
-	system("perl eqemu_server.pl ran_from_world");
+	if(system("perl eqemu_server.pl ran_from_world"));
 
 	return true;
 }
@@ -1360,7 +1360,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Spell Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < MAX_PP_REF_SPELLBOOK; i++){
+				for (i = 0; i < 480; i++){
 					if (pp->spell_book[i] > 0 && pp->spell_book[i] != 4294967295 && pp->spell_book[i] < 40000 && pp->spell_book[i] != 1){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_spells` (id, slot_id, spell_id) VALUES (%u, %u, %u)", character_id, i, pp->spell_book[i]);
@@ -1372,7 +1372,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Max Memmed Spell Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < MAX_PP_REF_MEMSPELL; i++){
+				for (i = 0; i < 9; i++){
 					if (pp->mem_spells[i] > 0 && pp->mem_spells[i] != 65535 && pp->mem_spells[i] != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_memmed_spells` (id, slot_id, spell_id) VALUES (%u, %u, %u)", character_id, i, pp->mem_spells[i]);

common/database_instances.cpp

@@ -27,7 +27,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include <iostream>
 
 // Disgrace: for windows compile
-#ifdef _WINDOWS
+#ifdef _WIN32
 #include <windows.h>
 #define snprintf	_snprintf
 #define strncasecmp	_strnicmp
@@ -38,16 +38,23 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #include <sys/time.h>
 #endif
 
+/**
+ * @param instance_id
+ * @param char_id
+ * @return
+ */
 bool Database::AddClientToInstance(uint16 instance_id, uint32 char_id)
 {
 	std::string query = StringFormat(
 		"REPLACE INTO `instance_list_player` (id, charid) "
 		"VALUES "
 		"(%lu, %lu)",
-		(unsigned long)instance_id,
-		(unsigned long)char_id
-		);
+		(unsigned long) instance_id,
+		(unsigned long) char_id
+	);
+
 	auto results = QueryDatabase(query);
+
 	return results.Success();
 }
 

common/dbcore.cpp

@@ -1,4 +1,4 @@
-#ifdef _WINDOWS
+#ifdef _WIN32
 #include <winsock2.h>
 #endif
 
@@ -13,7 +13,7 @@
 #include <mysqld_error.h>
 #include <string.h>
 
-#ifdef _WINDOWS
+#ifdef _WIN32
 	#define snprintf	_snprintf
 	#define strncasecmp	_strnicmp
 	#define strcasecmp	_stricmp

common/dbcore.h

@@ -1,7 +1,7 @@
 #ifndef DBCORE_H
 #define DBCORE_H
 
-#ifdef _WINDOWS
+#ifdef _WIN32
 	#include <winsock2.h>
 	#include <windows.h>
 #endif

common/emu_constants.cpp

@@ -118,3 +118,37 @@ EQEmu::bug::CategoryID EQEmu::bug::CategoryNameToCategoryID(const char* category
 	
 	return catOther;
 }
+
+const char *EQEmu::constants::GetStanceName(StanceType stance_type) {
+	switch (stance_type) {
+	case stanceUnknown:
+		return "Unknown";
+	case stancePassive:
+		return "Passive";
+	case stanceBalanced:
+		return "Balanced";
+	case stanceEfficient:
+		return "Efficient";
+	case stanceReactive:
+		return "Reactive";
+	case stanceAggressive:
+		return "Aggressive";
+	case stanceAssist:
+		return "Assist";
+	case stanceBurn:
+		return "Burn";
+	case stanceEfficient2:
+		return "Efficient2";
+	case stanceBurnAE:
+		return "BurnAE";
+	default:
+		return "Invalid";
+	}
+}
+
+int EQEmu::constants::ConvertStanceTypeToIndex(StanceType stance_type) {
+	if (stance_type >= EQEmu::constants::stancePassive && stance_type <= EQEmu::constants::stanceBurnAE)
+		return (stance_type - EQEmu::constants::stancePassive);
+
+	return 0;
+}

common/emu_constants.h

@@ -77,29 +77,40 @@ namespace EQEmu
 
 	} // namespace invtype
 
-	namespace invslot {
-		using namespace Titanium::invslot::enum_;
+	namespace DevTools {
+		const int32 GM_ACCOUNT_STATUS_LEVEL = 150;
+	}
 
-		const int16 SLOT_POWER_SOURCE = 9999;
+	namespace popupresponse {
+		const int32 SERVER_INTERNAL_USE_BASE = 2000000000;
+		const int32 MOB_INFO_DISMISS         = 2000000001;
+	}
+
+	namespace invslot {
+		using namespace RoF2::invslot::enum_;
 
 		using RoF2::invslot::SLOT_INVALID;
 		using RoF2::invslot::SLOT_BEGIN;
 
-		using Titanium::invslot::POSSESSIONS_BEGIN;
-		using Titanium::invslot::POSSESSIONS_END;
-		using SoF::invslot::POSSESSIONS_COUNT;
+		using Titanium::invslot::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
 
-		using Titanium::invslot::EQUIPMENT_BEGIN;
-		using Titanium::invslot::EQUIPMENT_END;
-		using Titanium::invslot::EQUIPMENT_COUNT;
+		const int16 SLOT_AUGMENT_GENERIC_RETURN = 1001; // clients don't appear to use this method... (internal inventory return value)
 
-		using Titanium::invslot::GENERAL_BEGIN;
-		using Titanium::invslot::GENERAL_END;
-		using Titanium::invslot::GENERAL_COUNT;
+		using RoF2::invslot::POSSESSIONS_BEGIN;
+		using RoF2::invslot::POSSESSIONS_END;
+		using RoF2::invslot::POSSESSIONS_COUNT;
 
-		using Titanium::invslot::BONUS_BEGIN;
-		using Titanium::invslot::BONUS_STAT_END;
-		using Titanium::invslot::BONUS_SKILL_END;
+		using RoF2::invslot::EQUIPMENT_BEGIN;
+		using RoF2::invslot::EQUIPMENT_END;
+		using RoF2::invslot::EQUIPMENT_COUNT;
+
+		using RoF2::invslot::GENERAL_BEGIN;
+		using RoF2::invslot::GENERAL_END;
+		using RoF2::invslot::GENERAL_COUNT;
+
+		using RoF2::invslot::BONUS_BEGIN;
+		using RoF2::invslot::BONUS_STAT_END;
+		using RoF2::invslot::BONUS_SKILL_END;
 
 		using Titanium::invslot::BANK_BEGIN;
 		using SoF::invslot::BANK_END;
@@ -124,6 +135,9 @@ namespace EQEmu
 		const int16 CORPSE_BEGIN = invslot::slotGeneral1;
 		const int16 CORPSE_END = CORPSE_BEGIN + invslot::slotCursor;
 
+		using RoF2::invslot::EQUIPMENT_BITMASK;
+		using RoF2::invslot::GENERAL_BITMASK;
+		using RoF2::invslot::CURSOR_BITMASK;
 		using RoF2::invslot::POSSESSIONS_BITMASK;
 		using RoF2::invslot::CORPSE_BITMASK;
 
@@ -145,7 +159,7 @@ namespace EQEmu
 		const int16 GENERAL_BAGS_8_COUNT = 8 * SLOT_COUNT;
 		const int16 GENERAL_BAGS_8_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_8_COUNT) - 1;
 
-		const int16 CURSOR_BAG_BEGIN = 331;
+		const int16 CURSOR_BAG_BEGIN = 351;
 		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
 		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
 
@@ -181,6 +195,10 @@ namespace EQEmu
 	namespace constants {
 		const EQEmu::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQEmu::versions::ClientVersion::Titanium;
 
+		using RoF2::constants::EXPANSION;
+		using RoF2::constants::EXPANSION_BIT;
+		using RoF2::constants::EXPANSIONS_MASK;
+
 		using RoF2::constants::CHARACTER_CREATION_LIMIT;
 		
 		const size_t SAY_LINK_OPENER_SIZE = 1;
@@ -189,13 +207,25 @@ namespace EQEmu
 		const size_t SAY_LINK_CLOSER_SIZE = 1;
 		const size_t SAY_LINK_MAXIMUM_SIZE = (SAY_LINK_OPENER_SIZE + SAY_LINK_BODY_SIZE + SAY_LINK_TEXT_SIZE + SAY_LINK_CLOSER_SIZE);
 
-		const int LongBuffs = RoF2::constants::LongBuffs;
-		const int ShortBuffs = RoF2::constants::ShortBuffs;
-		const int DiscBuffs = RoF2::constants::DiscBuffs;
-		const int TotalBuffs = RoF2::constants::TotalBuffs;
-		const int NPCBuffs = RoF2::constants::NPCBuffs;
-		const int PetBuffs = RoF2::constants::PetBuffs;
-		const int MercBuffs = RoF2::constants::MercBuffs;
+		enum StanceType : int {
+			stanceUnknown = 0,
+			stancePassive,
+			stanceBalanced,
+			stanceEfficient,
+			stanceReactive,
+			stanceAggressive,
+			stanceAssist,
+			stanceBurn,
+			stanceEfficient2,
+			stanceBurnAE
+		};
+
+		const char *GetStanceName(StanceType stance_type);
+		int ConvertStanceTypeToIndex(StanceType stance_type);
+
+		const int STANCE_TYPE_FIRST = stancePassive;
+		const int STANCE_TYPE_LAST = stanceBurnAE;
+		const int STANCE_TYPE_COUNT = stanceBurnAE;
 
 	} /*constants*/
 
@@ -214,6 +244,42 @@ namespace EQEmu
 
 	} // namespace behavior
 
+	namespace spells {
+		enum class CastingSlot : uint32 { // hybrid declaration
+			Gem1 = 0,
+			Gem2 = 1,
+			Gem3 = 2,
+			Gem4 = 3,
+			Gem5 = 4,
+			Gem6 = 5,
+			Gem7 = 6,
+			Gem8 = 7,
+			Gem9 = 8,
+			Gem10 = 9,
+			Gem11 = 10,
+			Gem12 = 11,
+			MaxGems = 12,
+			Ability = 20, // HT/LoH for Tit
+			PotionBelt = 21, // Tit uses a different slot for PB
+			Item = 22,
+			Discipline = 23,
+			AltAbility = 0xFF
+		};
+
+		using RoF2::spells::SPELL_ID_MAX;
+		using RoF2::spells::SPELLBOOK_SIZE;
+		using UF::spells::SPELL_GEM_COUNT; // RoF+ clients define more than UF client..but, they are not valid beyond UF
+
+		using RoF2::spells::LONG_BUFFS;
+		using RoF2::spells::SHORT_BUFFS;
+		using RoF2::spells::DISC_BUFFS;
+		using RoF2::spells::TOTAL_BUFFS;
+		using RoF2::spells::NPC_BUFFS;
+		using RoF2::spells::PET_BUFFS;
+		using RoF2::spells::MERC_BUFFS;
+
+	} // namespace spells
+
 	namespace bug {
 		enum CategoryID : uint32 {
 			catOther = 0,
@@ -245,25 +311,10 @@ namespace EQEmu
 
 	} // namespace bug
 
-	enum class CastingSlot : uint32 {
-		Gem1       = 0,
-		Gem2       = 1,
-		Gem3       = 2,
-		Gem4       = 3,
-		Gem5       = 4,
-		Gem6       = 5,
-		Gem7       = 6,
-		Gem8       = 7,
-		Gem9       = 8,
-		Gem10      = 9,
-		Gem11      = 10,
-		Gem12      = 11,
-		MaxGems    = 12,
-		Ability    = 20, // HT/LoH for Tit
-		PotionBelt = 21, // Tit uses a different slot for PB
-		Item       = 22,
-		Discipline = 23,
-		AltAbility = 0xFF
+	enum WaypointStatus : int {
+		RoamBoxPauseInProgress = -3,
+		QuestControlNoGrid = -2,
+		QuestControlGrid = -1
 	};
 
 } /*EQEmu*/

common/emu_limits.h

@@ -70,7 +70,10 @@ namespace EntityLimits
 		} // namespace invtype
 
 		namespace invslot {
-			const uint64 POSSESSIONS_BITMASK = 0x00000000007FFFFF; // based on 34-slot count (RoF+)
+			const uint64 EQUIPMENT_BITMASK = 0x00000000007FFFFF;
+			const uint64 GENERAL_BITMASK = 0x0000000000000000;
+			const uint64 CURSOR_BITMASK = 0x0000000000000000;
+			const uint64 POSSESSIONS_BITMASK = (EQUIPMENT_BITMASK | GENERAL_BITMASK | CURSOR_BITMASK); // based on 34-slot count (RoF+)
 
 		} // namespace invslot
 

common/emu_versions.cpp

@@ -18,6 +18,7 @@
 */
 
 #include "emu_versions.h"
+#include "emu_constants.h"
 
 
 bool EQEmu::versions::IsValidClientVersion(ClientVersion client_version)
@@ -63,32 +64,26 @@ const char* EQEmu::versions::ClientVersionName(ClientVersion client_version)
 uint32 EQEmu::versions::ConvertClientVersionToClientVersionBit(ClientVersion client_version)
 {
 	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-		return bit_Unknown;
 	case ClientVersion::Titanium:
-		return bit_Titanium;
+		return bitTitanium;
 	case ClientVersion::SoF:
-		return bit_SoF;
+		return bitSoF;
 	case ClientVersion::SoD:
-		return bit_SoD;
+		return bitSoD;
 	case ClientVersion::UF:
-		return bit_UF;
+		return bitUF;
 	case ClientVersion::RoF:
-		return bit_RoF;
+		return bitRoF;
 	case ClientVersion::RoF2:
-		return bit_RoF2;
+		return bitRoF2;
 	default:
-		return bit_Unknown;
+		return bitUnknown;
 	}
 }
 
 EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientVersion(uint32 client_version_bit)
 {
 	switch (client_version_bit) {
-	case (uint32)static_cast<unsigned int>(ClientVersion::Unknown) :
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)) :
-		return ClientVersion::Unknown;
 	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)) :
 		return ClientVersion::Titanium;
 	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)) :
@@ -106,27 +101,6 @@ EQEmu::versions::ClientVersion EQEmu::versions::ConvertClientVersionBitToClientV
 	}
 }
 
-uint32 EQEmu::versions::ConvertClientVersionToExpansion(ClientVersion client_version)
-{
-	switch (client_version) {
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-	case ClientVersion::Titanium:
-		return 0x000007FFU;
-	case ClientVersion::SoF:
-		return 0x00007FFFU;
-	case ClientVersion::SoD:
-		return 0x0000FFFFU;
-	case ClientVersion::UF:
-		return 0x0001FFFFU;
-	case ClientVersion::RoF:
-	case ClientVersion::RoF2:
-		return 0x000FFFFFU;
-	default:
-		return 0;
-	}
-}
-
 bool EQEmu::versions::IsValidMobVersion(MobVersion mob_version)
 {
 	if (mob_version <= MobVersion::Unknown || mob_version > LastMobVersion)
@@ -368,3 +342,217 @@ EQEmu::versions::MobVersion EQEmu::versions::ConvertClientVersionToOfflinePCMobV
 		return MobVersion::Unknown;
 	}
 }
+
+const char* EQEmu::expansions::ExpansionName(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::EverQuest:
+		return "EverQuest";
+	case Expansion::RoK:
+		return "The Ruins of Kunark";
+	case Expansion::SoV:
+		return "The Scars of Velious";
+	case Expansion::SoL:
+		return "The Shadows of Luclin";
+	case Expansion::PoP:
+		return "The Planes of Power";
+	case Expansion::LoY:
+		return "The Legacy of Ykesha";
+	case Expansion::LDoN:
+		return "Lost Dungeons of Norrath";
+	case Expansion::GoD:
+		return "Gates of Discord";
+	case Expansion::OoW:
+		return "Omens of War";
+	case Expansion::DoN:
+		return "Dragons of Norrath";
+	case Expansion::DoD:
+		return "Depths of Darkhollow";
+	case Expansion::PoR:
+		return "Prophecy of Ro";
+	case Expansion::TSS:
+		return "The Serpent's Spine";
+	case Expansion::TBS:
+		return "The Buried Sea";
+	case Expansion::SoF:
+		return "Secrets of Faydwer";
+	case Expansion::SoD:
+		return "Seeds of Destruction";
+	case Expansion::UF:
+		return "Underfoot";
+	case Expansion::HoT:
+		return "House of Thule";
+	case Expansion::VoA:
+		return "Veil of Alaris";
+	case Expansion::RoF:
+		return "Rain of Fear";
+	case Expansion::CotF:
+		return "Call of the Forsaken";
+	default:
+		return "Invalid Expansion";
+	}
+}
+
+const char* EQEmu::expansions::ExpansionName(uint32 expansion_bit)
+{
+	return ExpansionName(ConvertExpansionBitToExpansion(expansion_bit));
+}
+
+uint32 EQEmu::expansions::ConvertExpansionToExpansionBit(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::RoK:
+		return bitRoK;
+	case Expansion::SoV:
+		return bitSoV;
+	case Expansion::SoL:
+		return bitSoL;
+	case Expansion::PoP:
+		return bitPoP;
+	case Expansion::LoY:
+		return bitLoY;
+	case Expansion::LDoN:
+		return bitLDoN;
+	case Expansion::GoD:
+		return bitGoD;
+	case Expansion::OoW:
+		return bitOoW;
+	case Expansion::DoN:
+		return bitDoN;
+	case Expansion::DoD:
+		return bitDoD;
+	case Expansion::PoR:
+		return bitPoR;
+	case Expansion::TSS:
+		return bitTSS;
+	case Expansion::TBS:
+		return bitTBS;
+	case Expansion::SoF:
+		return bitSoF;
+	case Expansion::SoD:
+		return bitSoD;
+	case Expansion::UF:
+		return bitUF;
+	case Expansion::HoT:
+		return bitHoT;
+	case Expansion::VoA:
+		return bitVoA;
+	case Expansion::RoF:
+		return bitRoF;
+	case Expansion::CotF:
+		return bitCotF;
+	default:
+		return bitEverQuest;
+	}
+}
+
+EQEmu::expansions::Expansion EQEmu::expansions::ConvertExpansionBitToExpansion(uint32 expansion_bit)
+{
+	switch (expansion_bit) {
+	case bitRoK:
+		return Expansion::RoK;
+	case bitSoV:
+		return Expansion::SoV;
+	case bitSoL:
+		return Expansion::SoL;
+	case bitPoP:
+		return Expansion::PoP;
+	case bitLoY:
+		return Expansion::LoY;
+	case bitLDoN:
+		return Expansion::LDoN;
+	case bitGoD:
+		return Expansion::GoD;
+	case bitOoW:
+		return Expansion::OoW;
+	case bitDoN:
+		return Expansion::DoN;
+	case bitDoD:
+		return Expansion::DoD;
+	case bitPoR:
+		return Expansion::PoR;
+	case bitTSS:
+		return Expansion::TSS;
+	case bitTBS:
+		return Expansion::TBS;
+	case bitSoF:
+		return Expansion::SoF;
+	case bitSoD:
+		return Expansion::SoD;
+	case bitUF:
+		return Expansion::UF;
+	case bitHoT:
+		return Expansion::HoT;
+	case bitVoA:
+		return Expansion::VoA;
+	case bitRoF:
+		return Expansion::RoF;
+	case bitCotF:
+		return Expansion::CotF;
+	default:
+		return Expansion::EverQuest;
+	}
+}
+
+uint32 EQEmu::expansions::ConvertExpansionToExpansionsMask(Expansion expansion)
+{
+	switch (expansion) {
+	case Expansion::RoK:
+		return maskRoK;
+	case Expansion::SoV:
+		return maskSoV;
+	case Expansion::SoL:
+		return maskSoL;
+	case Expansion::PoP:
+		return maskPoP;
+	case Expansion::LoY:
+		return maskLoY;
+	case Expansion::LDoN:
+		return maskLDoN;
+	case Expansion::GoD:
+		return maskGoD;
+	case Expansion::OoW:
+		return maskOoW;
+	case Expansion::DoN:
+		return maskDoN;
+	case Expansion::DoD:
+		return maskDoD;
+	case Expansion::PoR:
+		return maskPoR;
+	case Expansion::TSS:
+		return maskTSS;
+	case Expansion::TBS:
+		return maskTBS;
+	case Expansion::SoF:
+		return maskSoF;
+	case Expansion::SoD:
+		return maskSoD;
+	case Expansion::UF:
+		return maskUF;
+	case Expansion::HoT:
+		return maskHoT;
+	case Expansion::VoA:
+		return maskVoA;
+	case Expansion::RoF:
+		return maskRoF;
+	case Expansion::CotF:
+		return maskCotF;
+	default:
+		return maskEverQuest;
+	}
+}
+
+EQEmu::expansions::Expansion EQEmu::expansions::ConvertClientVersionToExpansion(versions::ClientVersion client_version)
+{
+	return EQEmu::constants::StaticLookup(client_version)->Expansion;
+}
+
+uint32 EQEmu::expansions::ConvertClientVersionToExpansionBit(versions::ClientVersion client_version)
+{
+	return EQEmu::constants::StaticLookup(client_version)->ExpansionBit;
+}
+
+uint32 EQEmu::expansions::ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version)
+{
+	return EQEmu::constants::StaticLookup(client_version)->ExpansionsMask;
+}

common/emu_versions.h

@@ -39,26 +39,27 @@ namespace EQEmu
 			RoF2		// Build: 'May 10 2013 23:30:08'
 		};
 
-		enum ClientVersionBit : uint32 {
-			bit_Unknown = 0,
-			bit_Client62 = 0x00000001, // unsupported (placeholder for scripts)
-			bit_Titanium = 0x00000002,
-			bit_SoF = 0x00000004,
-			bit_SoD = 0x00000008,
-			bit_UF = 0x00000010,
-			bit_RoF = 0x00000020,
-			bit_RoF2 = 0x00000040,
-			bit_TitaniumAndEarlier = 0x00000003,
-			bit_SoFAndEarlier = 0x00000007,
-			bit_SoDAndEarlier = 0x0000000F,
-			bit_UFAndEarlier = 0x0000001F,
-			bit_RoFAndEarlier = 0x0000003F,
-			bit_SoFAndLater = 0xFFFFFFFC,
-			bit_SoDAndLater = 0xFFFFFFF8,
-			bit_UFAndLater = 0xFFFFFFF0,
-			bit_RoFAndLater = 0xFFFFFFE0,
-			bit_RoF2AndLater = 0xFFFFFFC0,
-			bit_AllClients = 0xFFFFFFFF
+		enum ClientVersionBitmask : uint32 {
+			bitUnknown = 0x00000000,
+			bitClient62 = 0x00000001, // unsupported (placeholder for scripts)
+			bitTitanium = 0x00000002,
+			bitSoF = 0x00000004,
+			bitSoD = 0x00000008,
+			bitUF = 0x00000010,
+			bitRoF = 0x00000020,
+			bitRoF2 = 0x00000040,
+			maskUnknown = 0x00000000,
+			maskTitaniumAndEarlier = 0x00000003,
+			maskSoFAndEarlier = 0x00000007,
+			maskSoDAndEarlier = 0x0000000F,
+			maskUFAndEarlier = 0x0000001F,
+			maskRoFAndEarlier = 0x0000003F,
+			maskSoFAndLater = 0xFFFFFFFC,
+			maskSoDAndLater = 0xFFFFFFF8,
+			maskUFAndLater = 0xFFFFFFF0,
+			maskRoFAndLater = 0xFFFFFFE0,
+			maskRoF2AndLater = 0xFFFFFFC0,
+			maskAllClients = 0xFFFFFFFF
 		};
 
 		const ClientVersion LastClientVersion = ClientVersion::RoF2;
@@ -69,9 +70,7 @@ namespace EQEmu
 		const char* ClientVersionName(ClientVersion client_version);
 		uint32 ConvertClientVersionToClientVersionBit(ClientVersion client_version);
 		ClientVersion ConvertClientVersionBitToClientVersion(uint32 client_version_bit);
-		uint32 ConvertClientVersionToExpansion(ClientVersion client_version);
-
-
+		
 		enum class MobVersion : uint32 {
 			Unknown = 0,
 			Client62,
@@ -137,6 +136,87 @@ namespace EQEmu
 
 	} /*versions*/
 
+	namespace expansions {
+		enum class Expansion : uint32 {
+			EverQuest = 0,
+			RoK,
+			SoV,
+			SoL,
+			PoP,
+			LoY,
+			LDoN,
+			GoD,
+			OoW,
+			DoN,
+			DoD,
+			PoR,
+			TSS,
+			TBS,
+			SoF,
+			SoD,
+			UF,
+			HoT,
+			VoA,
+			RoF,
+			CotF
+		};
+
+		enum ExpansionBitmask : uint32 {
+			bitEverQuest = 0x00000000,
+			bitRoK = 0x00000001,
+			bitSoV = 0x00000002,
+			bitSoL = 0x00000004,
+			bitPoP = 0x00000008,
+			bitLoY = 0x00000010,
+			bitLDoN = 0x00000020,
+			bitGoD = 0x00000040,
+			bitOoW = 0x00000080,
+			bitDoN = 0x00000100,
+			bitDoD = 0x00000200,
+			bitPoR = 0x00000400,
+			bitTSS = 0x00000800,
+			bitTBS = 0x00001000,
+			bitSoF = 0x00002000,
+			bitSoD = 0x00004000,
+			bitUF = 0x00008000,
+			bitHoT = 0x00010000,
+			bitVoA = 0x00020000,
+			bitRoF = 0x00040000,
+			bitCotF = 0x00080000,
+			maskEverQuest = 0x00000000,
+			maskRoK = 0x00000001,
+			maskSoV = 0x00000003,
+			maskSoL = 0x00000007,
+			maskPoP = 0x0000000F,
+			maskLoY = 0x0000001F,
+			maskLDoN = 0x0000003F,
+			maskGoD = 0x0000007F,
+			maskOoW = 0x000000FF,
+			maskDoN = 0x000001FF,
+			maskDoD = 0x000003FF,
+			maskPoR = 0x000007FF,
+			maskTSS = 0x00000FFF,
+			maskTBS = 0x00001FFF,
+			maskSoF = 0x00003FFF,
+			maskSoD = 0x00007FFF,
+			maskUF = 0x0000FFFF,
+			maskHoT = 0x0001FFFF,
+			maskVoA = 0x0003FFFF,
+			maskRoF = 0x0007FFFF,
+			maskCotF = 0x000FFFFF
+		};
+
+		const char* ExpansionName(Expansion expansion);
+		const char* ExpansionName(uint32 expansion_bit);
+		uint32 ConvertExpansionToExpansionBit(Expansion expansion);
+		Expansion ConvertExpansionBitToExpansion(uint32 expansion_bit);
+		uint32 ConvertExpansionToExpansionsMask(Expansion expansion);
+		Expansion ConvertClientVersionToExpansion(versions::ClientVersion client_version);
+		uint32 ConvertClientVersionToExpansionBit(versions::ClientVersion client_version);
+		uint32 ConvertClientVersionToExpansionsMask(versions::ClientVersion client_version);
+
+	} /*expansions*/
+
 } /*EQEmu*/
 
 #endif /*COMMON_EMU_VERSIONS_H*/

common/eq_constants.h

@@ -71,7 +71,7 @@
 //#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)
 
 // animations for AT_Anim
-#define ANIM_FREEZE	102
+#define ANIM_FREEZE	    102
 #define	ANIM_STAND		0x64
 #define	ANIM_SIT		0x6e
 #define	ANIM_CROUCH		0x6f
@@ -87,199 +87,114 @@ typedef enum {
 	_eaMaxAppearance
 } EmuAppearance;
 
-// msg_type's for custom usercolors
-#define MT_Say					256
-#define MT_Tell					257
-#define MT_Group				258
-#define MT_Guild				259
-#define MT_OOC					260
-#define MT_Auction				261
-#define MT_Shout				262
-#define MT_Emote				263
-#define MT_Spells				264
-#define MT_YouHitOther			265
-#define MT_OtherHitsYou			266
-#define MT_YouMissOther			267
-#define MT_OtherMissesYou		268
-#define MT_Broadcasts			269
-#define MT_Skills				270
-#define MT_Disciplines			271
-#define	MT_Unused1				272
-#define MT_DefaultText			273
-#define MT_Unused2				274
-#define MT_MerchantOffer		275
-#define MT_MerchantBuySell		276
-#define	MT_YourDeath			277
-#define MT_OtherDeath			278
-#define MT_OtherHits			279
-#define MT_OtherMisses			280
-#define	MT_Who					281
-#define MT_YellForHelp			282
-#define MT_NonMelee				283
-#define MT_WornOff				284
-#define MT_MoneySplit			285
-#define MT_LootMessages			286
-#define MT_DiceRoll				287
-#define MT_OtherSpells			288
-#define MT_SpellFailure			289
-#define MT_Chat					290
-#define MT_Channel1				291
-#define MT_Channel2				292
-#define MT_Channel3				293
-#define MT_Channel4				294
-#define MT_Channel5				295
-#define MT_Channel6				296
-#define MT_Channel7				297
-#define MT_Channel8				298
-#define MT_Channel9				299
-#define MT_Channel10			300
-#define MT_CritMelee			301
-#define MT_SpellCrits			302
-#define MT_TooFarAway			303
-#define MT_NPCRampage			304
-#define MT_NPCFlurry			305
-#define MT_NPCEnrage			306
-#define MT_SayEcho				307
-#define MT_TellEcho				308
-#define MT_GroupEcho			309
-#define MT_GuildEcho			310
-#define MT_OOCEcho				311
-#define MT_AuctionEcho			312
-#define MT_ShoutECho			313
-#define MT_EmoteEcho			314
-#define MT_Chat1Echo			315
-#define MT_Chat2Echo			316
-#define MT_Chat3Echo			317
-#define MT_Chat4Echo			318
-#define MT_Chat5Echo			319
-#define MT_Chat6Echo			320
-#define MT_Chat7Echo			321
-#define MT_Chat8Echo			322
-#define MT_Chat9Echo			323
-#define MT_Chat10Echo			324
-#define MT_DoTDamage			325
-#define MT_ItemLink				326
-#define MT_RaidSay				327
-#define MT_MyPet				328
-#define MT_DS					329
-#define MT_Leadership			330
-#define MT_PetFlurry			331
-#define MT_PetCrit				332
-#define MT_FocusEffect			333
-#define MT_Experience			334
-#define MT_System				335
-#define MT_PetSpell				336
-#define MT_PetResponse			337
-#define MT_ItemSpeech			338
-#define MT_StrikeThrough		339
-#define MT_Stun					340
+namespace Chat {
+	const uint16 White       = 0;
+	const uint16 DimGray     = 1;
+	const uint16 Default     = 1;
+	const uint16 Green       = 2;
+	const uint16 BrightBlue  = 3;
+	const uint16 LightBlue   = 4;
+	const uint16 Magenta     = 5;
+	const uint16 Gray        = 6;
+	const uint16 LightGray   = 7;
+	const uint16 NPCQuestSay = 10;
+	const uint16 DarkGray    = 12;
+	const uint16 Red         = 13;
+	const uint16 Lime        = 14;
+	const uint16 Yellow      = 15;
+	const uint16 Blue        = 16;
+	const uint16 LightNavy   = 17;
+	const uint16 Cyan        = 18;
+	const uint16 Black       = 20;
 
-// TODO: Really should combine above and below into one
-
-//from showeq
-enum ChatColor
-{
-	/*
-	CC_Default					= 0,
-	CC_DarkGrey					= 1,
-	CC_DarkGreen				= 2,
-	CC_DarkBlue					= 3,
-	CC_Purple					= 5,
-	CC_LightGrey				= 6,
-	*/
-
-	CC_WhiteSmoke				= 0,	// FF|F0F0F0
-	CC_Green					= 2,	// FF|008000
-	CC_BrightBlue				= 3,	// FF|0040FF
-	CC_Magenta					= 5,	// FF|F000F0
-	CC_Gray						= 6,	// FF|808080
-	CC_LightGray				= 7,	// FF|E0E0E0
-	//CC_WhiteSmoke2				= 10,	// FF|F0F0F0
-	CC_DarkGray					= 12,	// FF|A0A0A0
-	CC_Red						= 13,	// FF|F00000
-	CC_Lime						= 14,	// FF|00F000
-	CC_Yellow					= 15,	// FF|F0F000
-	CC_Blue						= 16,	// FF|0000F0
-	CC_LightNavy				= 17,	// FF|0000AF
-	CC_Cyan						= 18,	// FF|00F0F0
-	CC_Black					= 20,	// FF|000000
-	
-	// any index <= 255 that is not defined above
-	CC_DimGray					= 1,	// FF|606060
-	CC_Default					= 1,
-
-	CC_User_Say					= 256,
-	CC_User_Tell				= 257,
-	CC_User_Group				= 258,
-	CC_User_Guild				= 259,
-	CC_User_OOC					= 260,
-	CC_User_Auction				= 261,
-	CC_User_Shout				= 262,
-	CC_User_Emote				= 263,
-	CC_User_Spells				= 264,
-	CC_User_YouHitOther			= 265,
-	CC_User_OtherHitYou			= 266,
-	CC_User_YouMissOther		= 267,
-	CC_User_OtherMissYou		= 268,
-	CC_User_Duels				= 269,
-	CC_User_Skills				= 270,
-	CC_User_Disciplines			= 271,
-	CC_User_Default				= 273,
-	CC_User_MerchantOffer		= 275,
-	CC_User_MerchantExchange	= 276,
-	CC_User_YourDeath			= 277,
-	CC_User_OtherDeath			= 278,
-	CC_User_OtherHitOther		= 279,
-	CC_User_OtherMissOther		= 280,
-	CC_User_Who					= 281,
-	CC_User_Yell				= 282,
-	CC_User_NonMelee			= 283,
-	CC_User_SpellWornOff		= 284,
-	CC_User_MoneySplit			= 285,
-	CC_User_Loot				= 286,
-	CC_User_Random				= 287,
-	CC_User_OtherSpells			= 288,
-	CC_User_SpellFailure		= 289,
-	CC_User_ChatChannel			= 290,
-	CC_User_Chat1				= 291,
-	CC_User_Chat2				= 292,
-	CC_User_Chat3				= 293,
-	CC_User_Chat4				= 294,
-	CC_User_Chat5				= 295,
-	CC_User_Chat6				= 296,
-	CC_User_Chat7				= 297,
-	CC_User_Chat8				= 298,
-	CC_User_Chat9				= 299,
-	CC_User_Chat10				= 300,
-	CC_User_MeleeCrit			= 301,
-	CC_User_SpellCrit			= 302,
-	CC_User_TooFarAway			= 303,
-	CC_User_NPCRampage			= 304,
-	CC_User_NPCFurry			= 305,
-	CC_User_NPCEnrage			= 306,
-	CC_User_EchoSay				= 307,
-	CC_User_EchoTell			= 308,
-	CC_User_EchoGroup			= 309,
-	CC_User_EchoGuild			= 310,
-	CC_User_EchoOOC				= 311,
-	CC_User_EchoAuction			= 312,
-	CC_User_EchoShout			= 313,
-	CC_User_EchoEmote			= 314,
-	CC_User_EchoChat1			= 315,
-	CC_User_EchoChat2			= 316,
-	CC_User_EchoChat3			= 317,
-	CC_User_EchoChat4			= 318,
-	CC_User_EchoChat5			= 319,
-	CC_User_EchoChat6			= 320,
-	CC_User_EchoChat7			= 321,
-	CC_User_EchoChat8			= 322,
-	CC_User_EchoChat9			= 323,
-	CC_User_EchoChat10			= 324,
-	CC_User_UnusedAtThisTime	= 325,
-	CC_User_ItemTags			= 326,
-	CC_User_RaidSay				= 327,
-	CC_User_MyPet				= 328,
-	CC_User_DamageShield		= 329,
+	/**
+	 * User colors
+	 */
+	const uint16 Say              = 256;
+	const uint16 Tell             = 257;
+	const uint16 Group            = 258;
+	const uint16 Guild            = 259;
+	const uint16 OOC              = 260;
+	const uint16 Auction          = 261;
+	const uint16 Shout            = 262;
+	const uint16 Emote            = 263;
+	const uint16 Spells           = 264;
+	const uint16 YouHitOther      = 265;
+	const uint16 OtherHitYou      = 266;
+	const uint16 YouMissOther     = 267;
+	const uint16 OtherMissYou     = 268;
+	const uint16 Broadcasts       = 269;
+	const uint16 Skills           = 270;
+	const uint16 Disciplines      = 271;
+	const uint16 Unused1          = 272;
+	const uint16 DefaultText      = 273;
+	const uint16 Unused2          = 274;
+	const uint16 MerchantOffer    = 275;
+	const uint16 MerchantExchange = 276;
+	const uint16 YourDeath        = 277;
+	const uint16 OtherDeath       = 278;
+	const uint16 OtherHitOther    = 279;
+	const uint16 OtherMissOther   = 280;
+	const uint16 Who              = 281;
+	const uint16 YellForHelp      = 282;
+	const uint16 NonMelee         = 283;
+	const uint16 SpellWornOff     = 284;
+	const uint16 MoneySplit       = 285;
+	const uint16 Loot             = 286;
+	const uint16 DiceRoll         = 287;
+	const uint16 OtherSpells      = 288;
+	const uint16 SpellFailure     = 289;
+	const uint16 ChatChannel      = 290;
+	const uint16 Chat1            = 291;
+	const uint16 Chat2            = 292;
+	const uint16 Chat3            = 293;
+	const uint16 Chat4            = 294;
+	const uint16 Chat5            = 295;
+	const uint16 Chat6            = 296;
+	const uint16 Chat7            = 297;
+	const uint16 Chat8            = 298;
+	const uint16 Chat9            = 299;
+	const uint16 Chat10           = 300;
+	const uint16 MeleeCrit        = 301;
+	const uint16 SpellCrit        = 302;
+	const uint16 TooFarAway       = 303;
+	const uint16 NPCRampage       = 304;
+	const uint16 NPCFlurry        = 305;
+	const uint16 NPCEnrage        = 306;
+	const uint16 EchoSay          = 307;
+	const uint16 EchoTell         = 308;
+	const uint16 EchoGroup        = 309;
+	const uint16 EchoGuild        = 310;
+	const uint16 EchoOOC          = 311;
+	const uint16 EchoAuction      = 312;
+	const uint16 EchoShout        = 313;
+	const uint16 EchoEmote        = 314;
+	const uint16 EchoChat1        = 315;
+	const uint16 EchoChat2        = 316;
+	const uint16 EchoChat3        = 317;
+	const uint16 EchoChat4        = 318;
+	const uint16 EchoChat5        = 319;
+	const uint16 EchoChat6        = 320;
+	const uint16 EchoChat7        = 321;
+	const uint16 EchoChat8        = 322;
+	const uint16 EchoChat9        = 323;
+	const uint16 EchoChat10       = 324;
+	const uint16 DotDamage        = 325;
+	const uint16 ItemLink         = 326;
+	const uint16 RaidSay          = 327;
+	const uint16 MyPet            = 328;
+	const uint16 DamageShield     = 329;
+	const uint16 LeaderShip       = 330;
+	const uint16 PetFlurry        = 331;
+	const uint16 PetCritical      = 332;
+	const uint16 FocusEffect      = 333;
+	const uint16 Experience       = 334;
+	const uint16 System           = 335;
+	const uint16 PetSpell         = 336;
+	const uint16 PetResponse      = 337;
+	const uint16 ItemSpeech       = 338;
+	const uint16 StrikeThrough    = 339;
+	const uint16 Stun             = 340;
 };
 
 //ZoneChange_Struct->success values
@@ -523,18 +438,25 @@ static const uint8 SkillDamageTypes[EQEmu::skills::HIGHEST_SKILL + 1] = // chang
 
 static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
 
-namespace EQEmu
+enum ChatChannelNames : uint16
 {
-	namespace legacy {
-		enum InventorySlot {
-			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
-			SLOT_TRADESKILL = 1000,
-			SLOT_AUGMENT = 1001,
-			//SLOT_INVALID = (int16)0xFFFF,
-		};
+	ChatChannel_Guild = 0,
+	ChatChannel_Group = 2,
+	ChatChannel_Shout = 3,
+	ChatChannel_Auction = 4,
+	ChatChannel_OOC = 5,
+	ChatChannel_Broadcast = 6,
+	ChatChannel_Tell = 7,
+	ChatChannel_Say = 8,
+	ChatChannel_Petition = 10,
+	ChatChannel_GMSAY = 11,
+	ChatChannel_TellEcho = 14,
+	ChatChannel_Raid = 15,
 
-	} // namespace legacy
-
-}
+	ChatChannel_UNKNOWN_Guild = 17,
+	ChatChannel_UNKNOWN_GMSAY = 18,
+	ChatChannel_UCSRelay = 20,
+	ChatChannel_Emotes = 22
+};
 
 #endif /*COMMON_EQ_CONSTANTS_H*/

common/eq_limits.h

@@ -33,33 +33,90 @@
 
 namespace EQEmu
 {
+	void InitializeDynamicLookups();
+
 	namespace constants {
-		class LookupEntry {
-		public:
+		struct LookupEntry {
+			EQEmu::expansions::Expansion Expansion;
+			uint32 ExpansionBit;
+			uint32 ExpansionsMask;
 			int16 CharacterCreationLimit;
-			int LongBuffs;
-			int ShortBuffs;
-			int DiscBuffs;
-			int TotalBuffs;
-			int NPCBuffs;
-			int PetBuffs;
-			int MercBuffs;
+			size_t SayLinkBodySize;
+			
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				EQEmu::expansions::Expansion Expansion,
+				uint32 ExpansionBit,
+				uint32 ExpansionsMask,
+				int16 CharacterCreationLimit,
+				size_t SayLinkBodySize
+			) :
+				Expansion(Expansion),
+				ExpansionBit(ExpansionBit),
+				ExpansionsMask(ExpansionsMask),
+				CharacterCreationLimit(CharacterCreationLimit),
+				SayLinkBodySize(SayLinkBodySize)
+			{ }
 		};
 
-		const LookupEntry* Lookup(versions::ClientVersion client_version);
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::ClientVersion client_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* DynamicGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* StaticLookup(versions::ClientVersion client_version);
 
 	} /*constants*/
 	
 	namespace inventory {
-		class LookupEntry {
-		public:
+		struct LookupEntry {
 			// note: 'PossessionsBitmask' needs to be attuned to the client version with the highest number
 			// of possessions slots and 'InventoryTypeSize[typePossessions]' should reflect the same count
 			// with translators adjusting for valid slot indices. Server-side validations will be performed
-			// against 'PossessionsBitmask' (note: the same applies to Corpse type size and bitmask)
+			// against 'PossessionsBitmask' (note: the same applies to CorpseBitmask..size is not dependent)
 
-			int16 InventoryTypeSize[25]; // should reflect EQEmu::invtype::TYPE_COUNT referenced in emu_constants.h
+			struct InventoryTypeSize_Struct { // should reflect count and naming conventions referenced in emu_constants.h
+				int16 Possessions,	Bank,				SharedBank;
+				int16 Trade,		World,				Limbo;
+				int16 Tribute,		TrophyTribute,		GuildTribute;
+				int16 Merchant,		Deleted,			Corpse;
+				int16 Bazaar,		Inspect,			RealEstate;
+				int16 ViewMODPC,	ViewMODBank,		ViewMODSharedBank;
+				int16 ViewMODLimbo,	AltStorage,			Archived;
+				int16 Mail,			GuildTrophyTribute,	Krono;
+				int16 Other;
 
+				InventoryTypeSize_Struct(
+					int16 Possessions,	int16 Bank,					int16 SharedBank,
+					int16 Trade,		int16 World,				int16 Limbo,
+					int16 Tribute,		int16 TrophyTribute,		int16 GuildTribute,
+					int16 Merchant,		int16 Deleted,				int16 Corpse,
+					int16 Bazaar,		int16 Inspect,				int16 RealEstate,
+					int16 ViewMODPC,	int16 ViewMODBank,			int16 ViewMODSharedBank,
+					int16 ViewMODLimbo,	int16 AltStorage,			int16 Archived,
+					int16 Mail,			int16 GuildTrophyTribute,	int16 Krono,
+					int16 Other
+				) :
+					Possessions(Possessions),	Bank(Bank),								SharedBank(SharedBank),
+					Trade(Trade),				World(World),							Limbo(Limbo),
+					Tribute(Tribute),			TrophyTribute(TrophyTribute),			GuildTribute(GuildTribute),
+					Merchant(Merchant),			Deleted(Deleted),						Corpse(Corpse),
+					Bazaar(Bazaar),				Inspect(Inspect),						RealEstate(RealEstate),
+					ViewMODPC(ViewMODPC),		ViewMODBank(ViewMODBank),				ViewMODSharedBank(ViewMODSharedBank),
+					ViewMODLimbo(ViewMODLimbo),	AltStorage(AltStorage),					Archived(Archived),
+					Mail(Mail),					GuildTrophyTribute(GuildTrophyTribute),	Krono(Krono),
+					Other(Other)
+				{ }
+			};
+
+			union {
+				InventoryTypeSize_Struct InventoryTypeSize;
+				int16 InventoryTypeSizeArray[25]; // should reflect EQEmu::invtype::TYPE_COUNT referenced in emu_constants.h
+			};
+
+			uint64 EquipmentBitmask;
+			uint64 GeneralBitmask;
+			uint64 CursorBitmask;
 			uint64 PossessionsBitmask;
 			uint64 CorpseBitmask;
 			int16 BagSlotCount;
@@ -69,22 +126,116 @@ namespace EQEmu
 			bool AllowClickCastFromBag;
 			bool ConcatenateInvTypeLimbo;
 			bool AllowOverLevelEquipment;
+
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				InventoryTypeSize_Struct InventoryTypeSize,
+				uint64 EquipmentBitmask,
+				uint64 GeneralBitmask,
+				uint64 CursorBitmask,
+				uint64 PossessionsBitmask,
+				uint64 CorpseBitmask,
+				int16 BagSlotCount,
+				int16 AugSocketCount,
+				bool AllowEmptyBagInBag,
+				bool AllowClickCastFromBag,
+				bool ConcatenateInvTypeLimbo,
+				bool AllowOverLevelEquipment
+			) :
+				InventoryTypeSize(InventoryTypeSize),
+				EquipmentBitmask(EquipmentBitmask),
+				GeneralBitmask(GeneralBitmask),
+				CursorBitmask(CursorBitmask),
+				PossessionsBitmask(PossessionsBitmask),
+				CorpseBitmask(CorpseBitmask),
+				BagSlotCount(BagSlotCount),
+				AugSocketCount(AugSocketCount),
+				AllowEmptyBagInBag(AllowEmptyBagInBag),
+				AllowClickCastFromBag(AllowClickCastFromBag),
+				ConcatenateInvTypeLimbo(ConcatenateInvTypeLimbo),
+				AllowOverLevelEquipment(AllowOverLevelEquipment)
+			{ }
 		};
 
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::MobVersion mob_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* DynamicGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* StaticLookup(versions::MobVersion mob_version);
 
 	} /*inventory*/
 	
 	namespace behavior {
-		class LookupEntry {
-		public:
+		struct LookupEntry {
 			bool CoinHasWeight;
+
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				bool CoinHasWeight
+			) :
+				CoinHasWeight(CoinHasWeight)
+			{ }
 		};
 
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
+		void InitializeDynamicLookups();
+
+		const LookupEntry* DynamicLookup(versions::MobVersion mob_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* DynamicGMLookup(versions::MobVersion mob_version);
+		const LookupEntry* StaticLookup(versions::MobVersion mob_version);
 
 	} /*behavior*/
 
+	namespace spells {
+		struct LookupEntry {
+			int SpellIdMax;
+			int SpellbookSize;
+			int SpellGemCount;
+
+			int LongBuffs;
+			int ShortBuffs;
+			int DiscBuffs;
+			int TotalBuffs;
+			int NPCBuffs;
+			int PetBuffs;
+			int MercBuffs;
+			
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				int SpellIdMax,
+				int SpellbookSize,
+				int SpellGemCount,
+				int LongBuffs,
+				int ShortBuffs,
+				int DiscBuffs,
+				int TotalBuffs,
+				int NPCBuffs,
+				int PetBuffs,
+				int MercBuffs
+			) :
+				SpellIdMax(SpellIdMax),
+				SpellbookSize(SpellbookSize),
+				SpellGemCount(SpellGemCount),
+				LongBuffs(LongBuffs),
+				ShortBuffs(ShortBuffs),
+				DiscBuffs(DiscBuffs),
+				TotalBuffs(TotalBuffs),
+				NPCBuffs(NPCBuffs),
+				PetBuffs(PetBuffs),
+				MercBuffs(MercBuffs)
+			{ }
+		};
+		
+		void InitializeDynamicLookups();
+		
+		const LookupEntry* DynamicLookup(versions::ClientVersion client_version, bool gm_flag);
+		const LookupEntry* DynamicNonGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* DynamicGMLookup(versions::ClientVersion client_version);
+		const LookupEntry* StaticLookup(versions::ClientVersion client_version);
+
+	} /*spells*/
+
 } /*EQEmu*/
 
 namespace ClientUnknown
@@ -92,6 +243,13 @@ namespace ClientUnknown
 	const int16 IINVALID = -1;
 	const int16 INULL = 0;
 
+	namespace constants {
+		const EQEmu::expansions::Expansion EXPANSION = EQEmu::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQEmu::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQEmu::expansions::maskEverQuest;
+
+	} // namespace constants
+
 } /*ClientUnknown*/
 
 namespace Client62
@@ -99,6 +257,13 @@ namespace Client62
 	const int16 IINVALID = -1;
 	const int16 INULL = 0;
 
+	namespace constants {
+		const EQEmu::expansions::Expansion EXPANSION = EQEmu::expansions::Expansion::EverQuest;
+		const uint32 EXPANSION_BIT = EQEmu::expansions::bitEverQuest;
+		const uint32 EXPANSIONS_MASK = EQEmu::expansions::maskEverQuest;
+
+	} // namespace constants
+
 } /*Client62*/
 
 #endif /*COMMON_EQ_LIMITS_H*/

common/eq_packet_structs.h

@@ -306,7 +306,6 @@ union
 	uint32 DestructibleUnk9;
 	bool targetable_with_hotkey;
 	bool show_name;
-
 };
 
 struct PlayerState_Struct {
@@ -376,7 +375,11 @@ struct NewZone_Struct {
 /*0692*/	uint8	unknown692[8];
 /*0700*/	float	fog_density;
 /*0704*/	uint32	SuspendBuffs;
-/*0704*/
+/*0708*/	uint32	FastRegenHP;
+/*0712*/	uint32	FastRegenMana;
+/*0716*/	uint32	FastRegenEndurance;
+/*0720*/	uint32	NPCAggroMaxDist;
+/*0724*/
 };
 
 /*
@@ -849,10 +852,6 @@ struct SuspendedMinion_Struct
 ** OpCode: 0x006a
  */
 static const uint32 MAX_PP_LANGUAGE = 28;
-static const uint32 MAX_PP_SPELLBOOK = 480;	// Set for all functions
-static const uint32 MAX_PP_MEMSPELL = static_cast<uint32>(EQEmu::CastingSlot::MaxGems); // Set to latest client so functions can work right -- 12
-static const uint32 MAX_PP_REF_SPELLBOOK = 480;	// Set for Player Profile size retain
-static const uint32 MAX_PP_REF_MEMSPELL = 9; // Set for Player Profile size retain
 
 static const uint32 MAX_PP_SKILL		= PACKET_SKILL_ARRAY_SIZE;	// 100 - actual skills buffer size
 static const uint32 MAX_PP_INNATE_SKILL	= 25;
@@ -910,7 +909,7 @@ sed -e 's/_t//g' -e 's/MAX_AA/MAX_PP_AA_ARRAY/g' \
 
 struct PlayerProfile_Struct
 {
-/*0000*/	uint32				checksum;			// Checksum from CRC32::SetEQChecksum
+// /*0000*/	uint32				checksum;			// Checksum from CRC32::SetEQChecksum
 /*0004*/	char				name[64];			// Name of player sizes not right
 /*0068*/	char				last_name[32];		// Last name of player sizes not right
 /*0100*/	uint32				gender;				// Player Gender - 0 Male, 1 Female
@@ -932,7 +931,7 @@ struct PlayerProfile_Struct
 /*0245*/	uint8				guildbanker;
 /*0246*/	uint8				unknown0246[6];		//
 /*0252*/	uint32				intoxication;
-/*0256*/	uint32				spellSlotRefresh[MAX_PP_MEMSPELL];	//in ms
+/*0256*/	uint32				spellSlotRefresh[EQEmu::spells::SPELL_GEM_COUNT];	//in ms
 /*0292*/	uint32				abilitySlotRefresh;
 /*0296*/	uint8				haircolor;			// Player hair color
 /*0297*/	uint8				beardcolor;			// Player beard color
@@ -971,9 +970,9 @@ struct PlayerProfile_Struct
 /*2505*/	uint8				unknown2541[47];	// ?
 /*2552*/	uint8				languages[MAX_PP_LANGUAGE];
 /*2580*/	uint8				unknown2616[4];
-/*2584*/	uint32				spell_book[MAX_PP_REF_SPELLBOOK];
+/*2584*/	uint32				spell_book[EQEmu::spells::SPELLBOOK_SIZE];
 /*4504*/	uint8				unknown4540[128];	// Was [428] all 0xff
-/*4632*/	uint32				mem_spells[MAX_PP_MEMSPELL];
+/*4632*/	uint32				mem_spells[EQEmu::spells::SPELL_GEM_COUNT];
 /*4668*/	uint8				unknown4704[32];	//
 /*4700*/	float				y;					// Player y position
 /*4704*/	float				x;					// Player x position
@@ -1092,6 +1091,18 @@ struct PlayerProfile_Struct
 /*19559*/	uint8				unknown19595[5];	// ***Placeholder (6/29/2005)
 /*19564*/	uint32				RestTimer;
 /*19568*/
+
+	// All player profile packets are translated and this overhead is ignored in out-bound packets
+	PlayerProfile_Struct() : m_player_profile_version(EQEmu::versions::MobVersion::Unknown) { }
+
+	EQEmu::versions::MobVersion PlayerProfileVersion() { return m_player_profile_version; }
+	void SetPlayerProfileVersion(EQEmu::versions::MobVersion mob_version) { m_player_profile_version = EQEmu::versions::ValidateMobVersion(mob_version); }
+	void SetPlayerProfileVersion(EQEmu::versions::ClientVersion client_version) { SetPlayerProfileVersion(EQEmu::versions::ConvertClientVersionToMobVersion(client_version)); }
+
+private:
+	// No need for gm flag since pp already has one
+	// No need for lookup pointer since this struct is not tied to any one system
+	EQEmu::versions::MobVersion m_player_profile_version;
 };
 
 
@@ -1177,19 +1188,33 @@ struct SpecialMesg_Struct
 /*24*/	char	message[1];				// What is being said?
 };
 
+struct SpecialMesgHeader_Struct
+{
+/*00*/	char	SpeakMode;				// 2 shouts, 4 %1 %2, 3 %2, 5 tells group, 0 copy, default says
+/*01*/	char	JournalMode;			// 1 and 2 go to journal
+/*02*/	char	language;
+/*03*/	uint32	msg_type;				// Color of text (see MT_*** below)
+/*07*/	uint32	target_spawn_id;		// Who is it being said to?
+/*11*/ // speaker's name
+/*xx*/ // unknown, location, client doesn't care
+/*xx*/ // unknown
+/*xx*/ // unknown
+/*xx*/ // message
+};
+
 /*
 ** When somebody changes what they're wearing or give a pet a weapon (model changes)
 ** Length: 19 Bytes
 */
-struct WearChange_Struct{
-/*000*/ uint16 spawn_id;
-/*002*/ uint32 material;
-/*006*/ uint32 unknown06;
-/*010*/ uint32 elite_material;	// 1 for Drakkin Elite Material
-/*014*/ uint32 hero_forge_model; // New to VoA
-/*018*/ uint32 unknown18; // New to RoF
+struct WearChange_Struct {
+/*000*/ uint16                       spawn_id;
+/*002*/ uint32                       material;
+/*006*/ uint32                       unknown06;
+/*010*/ uint32                       elite_material;    // 1 for Drakkin Elite Material
+/*014*/ uint32                       hero_forge_model; // New to VoA
+/*018*/ uint32                       unknown18; // New to RoF
 /*022*/ EQEmu::textures::Tint_Struct color;
-/*026*/ uint8 wear_slot_id;
+/*026*/ uint8                        wear_slot_id;
 /*027*/
 };
 
@@ -4370,7 +4395,7 @@ struct AnnoyingZoneUnknown_Struct {
 };
 
 struct LoadSpellSet_Struct {
-	uint32 spell[MAX_PP_MEMSPELL];	// 0xFFFFFFFF if no action, slot number if to unmem starting at 0
+	uint32 spell[EQEmu::spells::SPELL_GEM_COUNT];	// 0xFFFFFFFF if no action, slot number if to unmem starting at 0
 	uint32 unknown;					//there seems to be an extra field in this packet...
 };
 

common/eq_stream_intf.h

@@ -6,6 +6,7 @@
 #include <string>
 #include "emu_versions.h"
 #include "eq_packet.h"
+#include "net/daybreak_connection.h"
 
 typedef enum {
 	ESTABLISHED,
@@ -18,6 +19,47 @@ typedef enum {
 class EQApplicationPacket;
 class OpcodeManager;
 
+struct EQStreamManagerInterfaceOptions
+{
+	EQStreamManagerInterfaceOptions() {
+		opcode_size = 2;
+	}
+
+	EQStreamManagerInterfaceOptions(int port, bool encoded, bool compressed) {
+		opcode_size = 2;
+
+		//World seems to support both compression and xor zone supports one or the others.
+		//Enforce one or the other in the convienence construct
+		//Login I had trouble getting to recognize compression at all 
+		//but that might be because it was still a bit buggy when i was testing that.
+		if (compressed) {
+			daybreak_options.encode_passes[0] = EQ::Net::EncodeCompression;
+		}
+		else if (encoded) {
+			daybreak_options.encode_passes[0] = EQ::Net::EncodeXOR;
+		}
+
+		daybreak_options.port = port;
+	}
+
+	int opcode_size;
+	bool track_opcode_stats;
+	EQ::Net::DaybreakConnectionManagerOptions daybreak_options;
+};
+
+class EQStreamManagerInterface
+{
+public:
+	EQStreamManagerInterface(const EQStreamManagerInterfaceOptions &options) { m_options = options; }
+	virtual ~EQStreamManagerInterface() { };
+
+	EQStreamManagerInterfaceOptions GetOptions() { return m_options; }
+	const EQStreamManagerInterfaceOptions& GetOptions() const { return m_options; }
+	virtual void SetOptions(const EQStreamManagerInterfaceOptions& options) = 0;
+protected:
+	EQStreamManagerInterfaceOptions m_options;
+};
+
 class EQStreamInterface {
 public:
 	virtual ~EQStreamInterface() {}
@@ -29,12 +71,20 @@ public:
 		uint16 first_eq_opcode;
 		uint32 first_length;			//0=dont check length
 	};
+
 	typedef enum {
 		MatchNotReady,
 		MatchSuccessful,
 		MatchFailed
 	} MatchState;
 
+	struct Stats
+	{
+		EQ::Net::DaybreakConnectionStats DaybreakStats;
+		int RecvCount[_maxEmuOpcode];
+		int SentCount[_maxEmuOpcode];
+	};
+
 	virtual void QueuePacket(const EQApplicationPacket *p, bool ack_req=true) = 0;
 	virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true) = 0;
 	virtual EQApplicationPacket *PopPacket() = 0;
@@ -50,12 +100,10 @@ public:
 	virtual MatchState CheckSignature(const Signature *sig) { return MatchFailed; }
 	virtual EQStreamState GetState() = 0;
 	virtual void SetOpcodeManager(OpcodeManager **opm) = 0;
-
-	virtual const uint32 GetBytesSent() const { return 0; }
-	virtual const uint32 GetBytesRecieved() const { return 0; }
-	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
-	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
 	virtual const EQEmu::versions::ClientVersion ClientVersion() const { return EQEmu::versions::ClientVersion::Unknown; }
+	virtual Stats GetStats() const = 0;
+	virtual void ResetStats() = 0;
+	virtual EQStreamManagerInterface* GetManager() const = 0;
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -82,26 +82,6 @@ uint16 EQStreamProxy::GetRemotePort() const {
 	return(m_stream->GetRemotePort());
 }
 
-const uint32 EQStreamProxy::GetBytesSent() const
-{
-	return(m_stream->GetBytesSent());
-}
-
-const uint32 EQStreamProxy::GetBytesRecieved() const
-{
-	return(m_stream->GetBytesRecieved());
-}
-
-const uint32 EQStreamProxy::GetBytesSentPerSecond() const
-{
-	return(m_stream->GetBytesSentPerSecond());
-}
-
-const uint32 EQStreamProxy::GetBytesRecvPerSecond() const
-{
-	return(m_stream->GetBytesRecvPerSecond());
-}
-
 void EQStreamProxy::ReleaseFromUse() {
 	m_stream->ReleaseFromUse();
 }
@@ -110,6 +90,21 @@ void EQStreamProxy::RemoveData() {
 	m_stream->RemoveData();
 }
 
+EQStreamInterface::Stats EQStreamProxy::GetStats() const
+{
+	return m_stream->GetStats();
+}
+
+void EQStreamProxy::ResetStats()
+{
+	m_stream->ResetStats();
+}
+
+EQStreamManagerInterface *EQStreamProxy::GetManager() const
+{
+	return m_stream->GetManager();
+}
+
 bool EQStreamProxy::CheckState(EQStreamState state) {
 	if(m_stream)
 		return(m_stream->CheckState(state));

common/eq_stream_proxy.h

@@ -31,11 +31,9 @@ public:
 	virtual const EQEmu::versions::ClientVersion ClientVersion() const;
 	virtual EQStreamState GetState();
 	virtual void SetOpcodeManager(OpcodeManager **opm);
-
-	virtual const uint32 GetBytesSent() const;
-	virtual const uint32 GetBytesRecieved() const;
-	virtual const uint32 GetBytesSentPerSecond() const;
-	virtual const uint32 GetBytesRecvPerSecond() const;
+	virtual Stats GetStats() const;
+	virtual void ResetStats();
+	virtual EQStreamManagerInterface* GetManager() const;
 
 protected:
 	std::shared_ptr<EQStreamInterface> const m_stream;	//we own this stream object.

common/eqemu_config.cpp

@@ -26,24 +26,26 @@
 std::string EQEmuConfig::ConfigFile = "eqemu_config.json";
 EQEmuConfig *EQEmuConfig::_config = nullptr;
 
-void EQEmuConfig::parse_config() {
-	
-	ShortName = _root["server"]["world"].get("shortname", "").asString();
-	LongName = _root["server"]["world"].get("longname", "").asString();
+void EQEmuConfig::parse_config()
+{
+
+	ShortName    = _root["server"]["world"].get("shortname", "").asString();
+	LongName     = _root["server"]["world"].get("longname", "").asString();
 	WorldAddress = _root["server"]["world"].get("address", "").asString();
 	LocalAddress = _root["server"]["world"].get("localaddress", "").asString();
-	MaxClients = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
-	SharedKey = _root["server"]["world"].get("key", "").asString();
-	LoginCount = 0;
+	MaxClients   = atoi(_root["server"]["world"].get("maxclients", "-1").asString().c_str());
+	SharedKey    = _root["server"]["world"].get("key", "").asString();
+	LoginCount   = 0;
 
 	if (_root["server"]["world"]["loginserver"].isObject()) {
-		LoginHost = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
-		LoginPort = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
+		LoginHost   = _root["server"]["world"]["loginserver"].get("host", "login.eqemulator.net").asString();
+		LoginPort   = atoi(_root["server"]["world"]["loginserver"].get("port", "5998").asString().c_str());
 		LoginLegacy = false;
-		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") LoginLegacy = true;
-		LoginAccount = _root["server"]["world"]["loginserver"].get("account", "").asString();
+		if (_root["server"]["world"]["loginserver"].get("legacy", "0").asString() == "1") { LoginLegacy = true; }
+		LoginAccount  = _root["server"]["world"]["loginserver"].get("account", "").asString();
 		LoginPassword = _root["server"]["world"]["loginserver"].get("password", "").asString();
-	} else {
+	}
+	else {
 		char str[32];
 		loginlist.Clear();
 		do {
@@ -53,76 +55,104 @@ void EQEmuConfig::parse_config() {
 			}
 
 			auto loginconfig = new LoginConfig;
-			loginconfig->LoginHost = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
-			loginconfig->LoginPort = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
-			loginconfig->LoginAccount = _root["server"]["world"][str].get("account", "").asString();
+			loginconfig->LoginHost     = _root["server"]["world"][str].get("host", "login.eqemulator.net").asString();
+			loginconfig->LoginPort     = atoi(_root["server"]["world"][str].get("port", "5998").asString().c_str());
+			loginconfig->LoginAccount  = _root["server"]["world"][str].get("account", "").asString();
 			loginconfig->LoginPassword = _root["server"]["world"][str].get("password", "").asString();
 
 			loginconfig->LoginLegacy = false;
-			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") loginconfig->LoginLegacy = true;
+			if (_root["server"]["world"][str].get("legacy", "0").asString() == "1") { loginconfig->LoginLegacy = true; }
 			loginlist.Insert(loginconfig);
 		} while (LoginCount < 100);
 	}
-	
-	
+
+
 	//<locked> from xml converts to json as locked: "", so i default to "false". 
 	//The only way to enable locked is by switching to true, meaning this value is always false until manually set true
 	Locked = false;
-	if (_root["server"]["world"].get("locked", "false").asString() == "true") Locked = true;
-	WorldIP = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
+	if (_root["server"]["world"].get("locked", "false").asString() == "true") { Locked = true; }
+	WorldIP      = _root["server"]["world"]["tcp"].get("host", "127.0.0.1").asString();
 	WorldTCPPort = atoi(_root["server"]["world"]["tcp"].get("port", "9000").asString().c_str());
-	
-	TelnetIP = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
+
+	TelnetIP      = _root["server"]["world"]["telnet"].get("ip", "127.0.0.1").asString();
 	TelnetTCPPort = atoi(_root["server"]["world"]["telnet"].get("port", "9001").asString().c_str());
 	TelnetEnabled = false;
-	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") TelnetEnabled = true;
+	if (_root["server"]["world"]["telnet"].get("enabled", "false").asString() == "true") { TelnetEnabled = true; }
 
 	WorldHTTPMimeFile = _root["server"]["world"]["http"].get("mimefile", "mime.types").asString();
-	WorldHTTPPort = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
-	WorldHTTPEnabled = false;
-	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") WorldHTTPEnabled = true;
+	WorldHTTPPort     = atoi(_root["server"]["world"]["http"].get("port", "9080").asString().c_str());
+	WorldHTTPEnabled  = false;
 
+	if (_root["server"]["world"]["http"].get("enabled", "false").asString() == "true") {
+		WorldHTTPEnabled = true;
+	}
+
+	/**
+	 * UCS
+	 */
 	ChatHost = _root["server"]["chatserver"].get("host", "eqchat.eqemulator.net").asString();
 	ChatPort = atoi(_root["server"]["chatserver"].get("port", "7778").asString().c_str());
-
 	MailHost = _root["server"]["mailserver"].get("host", "eqmail.eqemulator.net").asString();
 	MailPort = atoi(_root["server"]["mailserver"].get("port", "7778").asString().c_str());
 
+	/**
+	 * Database
+	 */
 	DatabaseUsername = _root["server"]["database"].get("username", "eq").asString();
 	DatabasePassword = _root["server"]["database"].get("password", "eq").asString();
-	DatabaseHost = _root["server"]["database"].get("host", "localhost").asString();
-	DatabasePort = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
-	DatabaseDB = _root["server"]["database"].get("db", "eq").asString();	
+	DatabaseHost     = _root["server"]["database"].get("host", "localhost").asString();
+	DatabasePort     = atoi(_root["server"]["database"].get("port", "3306").asString().c_str());
+	DatabaseDB       = _root["server"]["database"].get("db", "eq").asString();
 
-	QSDatabaseHost = _root["server"]["qsdatabase"].get("host", "localhost").asString();
-	QSDatabasePort = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
+	/**
+	 * QS
+	 */
+	QSDatabaseHost     = _root["server"]["qsdatabase"].get("host", "localhost").asString();
+	QSDatabasePort     = atoi(_root["server"]["qsdatabase"].get("port", "3306").asString().c_str());
 	QSDatabaseUsername = _root["server"]["qsdatabase"].get("username", "eq").asString();
 	QSDatabasePassword = _root["server"]["qsdatabase"].get("password", "eq").asString();
-	QSDatabaseDB = _root["server"]["qsdatabase"].get("db", "eq").asString();
+	QSDatabaseDB       = _root["server"]["qsdatabase"].get("db", "eq").asString();
 
+	/**
+	 * Zones
+	 */
 	DefaultStatus = atoi(_root["server"]["zones"].get("defaultstatus", 0).asString().c_str());
-	ZonePortLow = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
-	ZonePortHigh = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());
+	ZonePortLow   = atoi(_root["server"]["zones"]["ports"].get("low", "7000").asString().c_str());
+	ZonePortHigh  = atoi(_root["server"]["zones"]["ports"].get("high", "7999").asString().c_str());
 
-	SpellsFile = _root["server"]["files"].get("spells", "spells_us.txt").asString();
-	OpCodesFile = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
-	PluginPlFile = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();
+	/**
+	 * Files
+	 */
+	SpellsFile      = _root["server"]["files"].get("spells", "spells_us.txt").asString();
+	OpCodesFile     = _root["server"]["files"].get("opcodes", "opcodes.conf").asString();
+	MailOpCodesFile = _root["server"]["files"].get("mail_opcodes", "mail_opcodes.conf").asString();
+	PluginPlFile    = _root["server"]["files"].get("plugin.pl", "plugin.pl").asString();
 
-	MapDir = _root["server"]["directories"].get("maps", "Maps/").asString();
-	QuestDir = _root["server"]["directories"].get("quests", "quests/").asString();
-	PluginDir = _root["server"]["directories"].get("plugins", "plugins/").asString();
+	/**
+	 * Directories
+	 */
+	MapDir       = _root["server"]["directories"].get("maps", "Maps/").asString();
+	QuestDir     = _root["server"]["directories"].get("quests", "quests/").asString();
+	PluginDir    = _root["server"]["directories"].get("plugins", "plugins/").asString();
 	LuaModuleDir = _root["server"]["directories"].get("lua_modules", "lua_modules/").asString();
-	PatchDir = _root["server"]["directories"].get("patches", "./").asString();
+	PatchDir     = _root["server"]["directories"].get("patches", "./").asString();
 	SharedMemDir = _root["server"]["directories"].get("shared_memory", "shared/").asString();
-	LogDir = _root["server"]["directories"].get("logs", "logs/").asString();
+	LogDir       = _root["server"]["directories"].get("logs", "logs/").asString();
 
+	/**
+	 * Logs
+	 */
 	LogPrefix = _root["server"]["launcher"].get("logprefix", "logs/zone-").asString();
 	LogSuffix = _root["server"]["launcher"].get("logsuffix", ".log").asString();
-	RestartWait = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
-	TerminateWait = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
-	InitialBootWait = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
+
+	/**
+	 * Launcher
+	 */
+	RestartWait      = atoi(_root["server"]["launcher"]["timers"].get("restart", "10000").asString().c_str());
+	TerminateWait    = atoi(_root["server"]["launcher"]["timers"].get("reterminate", "10000").asString().c_str());
+	InitialBootWait  = atoi(_root["server"]["launcher"]["timers"].get("initial", "20000").asString().c_str());
 	ZoneBootInterval = atoi(_root["server"]["launcher"]["timers"].get("interval", "2000").asString().c_str());
-#ifdef WIN32
+#ifdef _WIN32
 	ZoneExe = _root["server"]["launcher"].get("exe", "zone.exe").asString();
 #else
 	ZoneExe = _root["server"]["launcher"].get("exe", "./zone").asString();
@@ -230,6 +260,9 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "OpCodesFile") {
 		return (OpCodesFile);
 	}
+	if (var_name == "MailOpCodesFile") {
+		return (MailOpCodesFile);
+	}
 	if (var_name == "PluginPlFile") {
 		return (PluginPlFile);
 	}
@@ -312,6 +345,7 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
+	std::cout << "MailOpcodesFile = " << MailOpCodesFile << std::endl;
 	std::cout << "PluginPlFile = " << PluginPlFile << std::endl;
 	std::cout << "MapDir = " << MapDir << std::endl;
 	std::cout << "QuestDir = " << QuestDir << std::endl;
@@ -322,6 +356,6 @@ void EQEmuConfig::Dump() const
 	std::cout << "LogDir = " << LogDir << std::endl;
 	std::cout << "ZonePortLow = " << ZonePortLow << std::endl;
 	std::cout << "ZonePortHigh = " << ZonePortHigh << std::endl;
-	std::cout << "DefaultStatus = " << (int)DefaultStatus << std::endl;
+	std::cout << "DefaultStatus = " << (int) DefaultStatus << std::endl;
 //	std::cout << "DynamicCount = " << DynamicCount << std::endl;
 }

common/eqemu_config.h

@@ -84,6 +84,7 @@ class EQEmuConfig
 		// From <files/>
 		std::string SpellsFile;
 		std::string OpCodesFile;
+		std::string MailOpCodesFile;
 		std::string PluginPlFile;
 
 		// From <directories/>

common/eqemu_logsys.cpp

@@ -1,22 +1,23 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2018 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
 */
 
-
 #include "eqemu_logsys.h"
 #include "platform.h"
 #include "string_util.h"
@@ -32,107 +33,145 @@
 
 std::ofstream process_log;
 
-#ifdef _WINDOWS
-	#include <direct.h>
-	#include <conio.h>
-	#include <iostream>
-	#include <dos.h>
-	#include <windows.h>
-	#include <process.h>
+#ifdef _WIN32
+#include <direct.h>
+#include <conio.h>
+#include <iostream>
+#include <dos.h>
+#include <windows.h>
+#include <process.h>
 #else
-	#include <unistd.h>
-	#include <sys/stat.h>
+
+#include <unistd.h>
+#include <sys/stat.h>
+
 #endif
 
-/* Linux ANSI console color defines */
+/**
+ * Linux ANSI console color defines
+ */
 #define LC_RESET   "\033[0m"
-#define LC_BLACK   "\033[30m"      /* Black */
-#define LC_RED     "\033[31m"      /* Red */
-#define LC_GREEN   "\033[32m"      /* Green */
-#define LC_YELLOW  "\033[33m"      /* Yellow */
-#define LC_BLUE    "\033[34m"      /* Blue */
-#define LC_MAGENTA "\033[35m"      /* Magenta */
-#define LC_CYAN    "\033[36m"      /* Cyan */
-#define LC_WHITE   "\033[37m"      /* White */
+#define LC_BLACK   "\033[30m" /* Black */
+#define LC_RED     "\033[31m" /* Red */
+#define LC_GREEN   "\033[32m" /* Green */
+#define LC_YELLOW  "\033[33m" /* Yellow */
+#define LC_BLUE    "\033[34m" /* Blue */
+#define LC_MAGENTA "\033[35m" /* Magenta */
+#define LC_CYAN    "\033[36m" /* Cyan */
+#define LC_WHITE   "\033[37m" /* White */
 
 namespace Console {
 	enum Color {
-		Black = 0,
-		Blue = 1,
-		Green = 2,
-		Cyan = 3,
-		Red = 4,
-		Magenta = 5,
-		Brown = 6,
-		LightGray = 7,
-		DarkGray = 8,
-		LightBlue = 9,
-		LightGreen = 10,
-		LightCyan = 11,
-		LightRed = 12,
+		Black        = 0,
+		Blue         = 1,
+		Green        = 2,
+		Cyan         = 3,
+		Red          = 4,
+		Magenta      = 5,
+		Brown        = 6,
+		LightGray    = 7,
+		DarkGray     = 8,
+		LightBlue    = 9,
+		LightGreen   = 10,
+		LightCyan    = 11,
+		LightRed     = 12,
 		LightMagenta = 13,
-		Yellow = 14,
-		White = 15
+		Yellow       = 14,
+		White        = 15
 	};
 }
 
+/**
+ * EQEmuLogSys Constructor
+ */
 EQEmuLogSys::EQEmuLogSys()
 {
-	on_log_gmsay_hook = [](uint16 log_type, const std::string&) {};
+	on_log_gmsay_hook      = [](uint16 log_type, const std::string &) {};
+	on_log_console_hook    = [](uint16 debug_level, uint16 log_type, const std::string &) {};
 	bool file_logs_enabled = false;
-	int log_platform = 0;
+	int  log_platform      = 0;
 }
 
+/**
+ * EQEmuLogSys Deconstructor
+ */
 EQEmuLogSys::~EQEmuLogSys()
 {
 }
 
 void EQEmuLogSys::LoadLogSettingsDefaults()
 {
-	/* Get Executable platform currently running this code (Zone/World/etc) */
+	/**
+	 * Get Executable platform currently running this code (Zone/World/etc)
+	 */
 	log_platform = GetExecutablePlatformInt();
+	
+	for (int log_category_id = Logs::AA; log_category_id != Logs::MaxCategoryID; log_category_id++) {
+		log_settings[log_category_id].log_to_console      = 0;
+		log_settings[log_category_id].log_to_file         = 0;
+		log_settings[log_category_id].log_to_gmsay        = 0;
+		log_settings[log_category_id].is_category_enabled = 0;
+	}
 
-	/* Zero out Array */
-	memset(log_settings, 0, sizeof(LogSettings) * Logs::LogCategory::MaxCategoryID);
+	file_logs_enabled = false;
 
-	/* Set Defaults */
-	log_settings[Logs::World_Server].log_to_console = Logs::General;
-	log_settings[Logs::Zone_Server].log_to_console = Logs::General;
-	log_settings[Logs::QS_Server].log_to_console = Logs::General;
-	log_settings[Logs::UCS_Server].log_to_console = Logs::General;
-	log_settings[Logs::Crash].log_to_console = Logs::General;
-	log_settings[Logs::MySQLError].log_to_console = Logs::General;
-	log_settings[Logs::Login_Server].log_to_console = Logs::General;
+	/**
+	 * Set Defaults
+	 */
+	log_settings[Logs::World_Server].log_to_console    = Logs::General;
+	log_settings[Logs::Zone_Server].log_to_console     = Logs::General;
+	log_settings[Logs::QS_Server].log_to_console       = Logs::General;
+	log_settings[Logs::UCS_Server].log_to_console      = Logs::General;
+	log_settings[Logs::Crash].log_to_console           = Logs::General;
+	log_settings[Logs::MySQLError].log_to_console      = Logs::General;
+	log_settings[Logs::Login_Server].log_to_console    = Logs::General;
 	log_settings[Logs::Headless_Client].log_to_console = Logs::General;
+	log_settings[Logs::NPCScaling].log_to_gmsay        = Logs::General;
 
-	/* Set Category enabled status on defaults */
-	log_settings[Logs::World_Server].is_category_enabled = 1;
-	log_settings[Logs::Zone_Server].is_category_enabled = 1;
-	log_settings[Logs::QS_Server].is_category_enabled = 1;
-	log_settings[Logs::UCS_Server].is_category_enabled = 1;
-	log_settings[Logs::Crash].is_category_enabled = 1;
-	log_settings[Logs::MySQLError].is_category_enabled = 1;
-	log_settings[Logs::Login_Server].is_category_enabled = 1;
+	/**
+	 * Set Category enabled status on defaults
+	 */
+	for (int log_category_id = Logs::AA; log_category_id != Logs::MaxCategoryID; log_category_id++) {
+		const bool log_to_console      = log_settings[log_category_id].log_to_console > 0;
+		const bool log_to_file         = log_settings[log_category_id].log_to_file > 0;
+		const bool log_to_gmsay        = log_settings[log_category_id].log_to_gmsay > 0;
+		const bool is_category_enabled = log_to_console || log_to_file || log_to_gmsay;
+		if (is_category_enabled) {
+			log_settings[log_category_id].is_category_enabled = 1;
+		}
+	}
 
-	/*	Declare process file names for log writing
-		If there is no process_file_name declared, no log file will be written, simply
-	*/
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld)
+	/**
+	 * Declare process file names for log writing=
+	 */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformWorld) {
 		platform_file_name = "world";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformQueryServ) {
 		platform_file_name = "query_server";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
 		platform_file_name = "zone";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformUCS) {
 		platform_file_name = "ucs";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLogin) {
 		platform_file_name = "login";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch) {
 		platform_file_name = "launcher";
-	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC)
+	}
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC) {
 		platform_file_name = "hc";
+	}
 }
 
+/**
+ * @param log_category
+ * @param in_message
+ * @return
+ */
 std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
 {
 	std::string ret;
@@ -144,17 +183,33 @@ std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::
 	return ret;
 }
 
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
 void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
-	if (log_category == Logs::LogCategory::Netcode)
+	/**
+	 * Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash
+	 */
+	if (log_category == Logs::LogCategory::Netcode) {
 		return;
+	}
 
-	/* Check to see if the process that actually ran this is zone */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
+	/**
+	 * Check to see if the process that actually ran this is zone
+	 */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
 		on_log_gmsay_hook(log_category, message);
+	}
 }
 
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
 void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message)
 {
 	if (log_category == Logs::Crash) {
@@ -162,7 +217,10 @@ void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const
 		EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 		std::ofstream crash_log;
 		EQEmuLogSys::MakeDirectory("logs/crashes");
-		crash_log.open(StringFormat("logs/crashes/crash_%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+		crash_log.open(
+			StringFormat("logs/crashes/crash_%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
 		crash_log << time_stamp << " " << message << "\n";
 		crash_log.close();
 	}
@@ -170,11 +228,17 @@ void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const
 	char time_stamp[80];
 	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);
 
-	if (process_log)
+	if (process_log) {
 		process_log << time_stamp << " " << message << std::endl;
+	}
 }
 
-uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
@@ -197,7 +261,12 @@ uint16 EQEmuLogSys::GetWindowsConsoleColorFromCategory(uint16 log_category) {
 	}
 }
 
-std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
@@ -220,52 +289,70 @@ std::string EQEmuLogSys::GetLinuxConsoleColorFromCategory(uint16 log_category) {
 	}
 }
 
-uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {
+/**
+ * @param log_category
+ * @return
+ */
+uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category)
+{
 	switch (log_category) {
 		case Logs::Status:
 		case Logs::Normal:
-			return 15; /* Yellow */
+			return Chat::Yellow;
 		case Logs::MySQLError:
 		case Logs::Error:
-			return 13; /* Red */
+			return Chat::Red;
 		case Logs::MySQLQuery:
 		case Logs::Debug:
-			return 14; /* Light Green */
+			return Chat::Lime;
 		case Logs::Quests:
-			return 258; /* Light Cyan */
+			return Chat::Group;
 		case Logs::Commands:
 		case Logs::Mercenaries:
-			return 5; /* Light Purple */
+			return Chat::Magenta;
 		case Logs::Crash:
-			return 13; /* Red */
+			return Chat::Red;
 		default:
-			return 15; /* Yellow */
+			return Chat::Yellow;
 	}
 }
 
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
+#ifdef _WIN32
+	HANDLE  console_handle;
+	console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+	CONSOLE_FONT_INFOEX info = { 0 };
+	info.cbSize = sizeof(info);
+	info.dwFontSize.Y = 12; // leave X as zero
+	info.FontWeight = FW_NORMAL;
+	wcscpy(info.FaceName, L"Lucida Console");
+	SetCurrentConsoleFontEx(console_handle, NULL, &info);
+	SetConsoleTextAttribute(console_handle, EQEmuLogSys::GetWindowsConsoleColorFromCategory(log_category));
+	std::cout << message << "\n";
+	SetConsoleTextAttribute(console_handle, Console::Color::White);
+#else
+	std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
+#endif
 
-	#ifdef _WINDOWS
-		HANDLE  console_handle;
-		console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-		CONSOLE_FONT_INFOEX info = { 0 };
-		info.cbSize = sizeof(info);
-		info.dwFontSize.Y = 12; // leave X as zero
-		info.FontWeight = FW_NORMAL;
-		wcscpy(info.FaceName, L"Lucida Console");
-		SetCurrentConsoleFontEx(console_handle, NULL, &info);
-		SetConsoleTextAttribute(console_handle, EQEmuLogSys::GetWindowsConsoleColorFromCategory(log_category));
-		std::cout << message << "\n";
-		SetConsoleTextAttribute(console_handle, Console::Color::White);
-	#else
-		std::cout << EQEmuLogSys::GetLinuxConsoleColorFromCategory(log_category) << message << LC_RESET << std::endl;
-	#endif
+	on_log_console_hook(debug_level, log_category, message);
 }
 
+/**
+ * Core logging function
+ *
+ * @param debug_level
+ * @param log_category
+ * @param message
+ * @param ...
+ */
 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
-
 	bool log_to_console = true;
 	if (log_settings[log_category].log_to_console < debug_level) {
 		log_to_console = false;
@@ -282,8 +369,9 @@ void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::st
 	}
 
 	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
-	if (nothing_to_log)
+	if (nothing_to_log) {
 		return;
+	}
 
 	va_list args;
 	va_start(args, message);
@@ -292,31 +380,44 @@ void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::st
 
 	std::string output_debug_message = EQEmuLogSys::FormatOutMessageString(log_category, output_message);
 
-	if (log_to_console) EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
-	if (log_to_gmsay) EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
-	if (log_to_file) EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
+	if (log_to_console) {
+		EQEmuLogSys::ProcessConsoleMessage(debug_level, log_category, output_debug_message);
+	}
+	if (log_to_gmsay) {
+		EQEmuLogSys::ProcessGMSay(debug_level, log_category, output_debug_message);
+	}
+	if (log_to_file) {
+		EQEmuLogSys::ProcessLogWrite(debug_level, log_category, output_debug_message);
+	}
 }
 
-void EQEmuLogSys::SetCurrentTimeStamp(char* time_stamp)
+/**
+ * @param time_stamp
+ */
+void EQEmuLogSys::SetCurrentTimeStamp(char *time_stamp)
 {
-	time_t raw_time;
-	struct tm * time_info;
+	time_t    raw_time;
+	struct tm *time_info;
 	time(&raw_time);
 	time_info = localtime(&raw_time);
 	strftime(time_stamp, 80, "[%m-%d-%Y :: %H:%M:%S]", time_info);
 }
 
+/**
+ * @param directory_name
+ */
 void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
 {
-#ifdef _WINDOWS
+#ifdef _WIN32
 	struct _stat st;
 	if (_stat(directory_name.c_str(), &st) == 0) // exists
 		return;
 	_mkdir(directory_name.c_str());
 #else
 	struct stat st;
-	if (stat(directory_name.c_str(), &st) == 0) // exists
+	if (stat(directory_name.c_str(), &st) == 0) { // exists
 		return;
+	}
 	mkdir(directory_name.c_str(), 0755);
 #endif
 }
@@ -328,29 +429,75 @@ void EQEmuLogSys::CloseFileLogs()
 	}
 }
 
+/**
+ * @param log_name
+ */
 void EQEmuLogSys::StartFileLogs(const std::string &log_name)
 {
 	EQEmuLogSys::CloseFileLogs();
 
-	/* When loading settings, we must have been given a reason in category based logging to output to a file in order to even create or open one... */
-	if (file_logs_enabled == false)
+	/**
+	 * When loading settings, we must have been given a reason in category based logging to output to a file in order to even create or open one...
+	 */
+	if (!file_logs_enabled) {
 		return;
+	}
 
+	/**
+	 * Zone
+	 */
 	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
-		if (!log_name.empty())
+		if (!log_name.empty()) {
 			platform_file_name = log_name;
+		}
 
-		if (platform_file_name.empty())
+		if (platform_file_name.empty()) {
 			return;
+		}
 
-		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
+		EQEmuLogSys::Out(
+			Logs::General,
+			Logs::Status,
+			"Starting File Log 'logs/%s_%i.log'",
+			platform_file_name.c_str(),
+			getpid());
+
+		/**
+		 * Make directory if not exists
+		 */
 		EQEmuLogSys::MakeDirectory("logs/zone");
-		process_log.open(StringFormat("logs/zone/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
-	} else {
-		if (platform_file_name.empty())
-			return;
 
-		EQEmuLogSys::Out(Logs::General, Logs::Status, "Starting File Log 'logs/%s_%i.log'", platform_file_name.c_str(), getpid());
-		process_log.open(StringFormat("logs/%s_%i.log", platform_file_name.c_str(), getpid()), std::ios_base::app | std::ios_base::out);
+		/**
+		 * Open file pointer
+		 */
+		process_log.open(
+			StringFormat("logs/zone/%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
+	}
+	else {
+
+		/**
+		 * All other processes
+		 */
+
+		if (platform_file_name.empty()) {
+			return;
+		}
+
+		EQEmuLogSys::Out(
+			Logs::General,
+			Logs::Status,
+			"Starting File Log 'logs/%s_%i.log'",
+			platform_file_name.c_str(),
+			getpid());
+
+		/**
+		 * Open file pointer
+		 */
+		process_log.open(
+			StringFormat("logs/%s_%i.log", platform_file_name.c_str(), getpid()),
+			std::ios_base::app | std::ios_base::out
+		);
 	}
 }

common/eqemu_logsys.h

@@ -1,26 +1,26 @@
-
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
-
-	This program is free software; you can redistribute it and/or modify
-	it under the terms of the GNU General Public License as published by
-	the Free Software Foundation; version 2 of the License.
-
-	This program is distributed in the hope that it will be useful,
-	but WITHOUT ANY WARRANTY except by those people which sell it, which
-	are required to give you total support for your newly bought product;
-	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-	You should have received a copy of the GNU General Public License
-	along with this program; if not, write to the Free Software
-	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2018 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
 */
 
 #ifndef EQEMU_LOGSYS_H
 #define EQEMU_LOGSYS_H
 
-#include <fmt/format.h>
 #include <iostream>
 #include <fstream>
 #include <stdio.h>
@@ -34,130 +34,136 @@ namespace Logs {
 		Detail			/* 3 - Use this for extreme detail in logging, usually in extreme debugging in the stack or interprocess communication */
 	};
 
-	/*
-		If you add to this, make sure you update LogCategoryName
-		NOTE: Only add to the bottom of the enum because that is the type ID assignment
-	*/
+	/**
+	 * If you add to this, make sure you update LogCategoryName
+	 *
+	 * NOTE: Only add to the bottom of the enum because that is the type ID assignment
+	 */
+	enum LogCategory {
+		None = 0,
+		AA,
+		AI,
+		Aggro,
+		Attack,
+		Client_Server_Packet,
+		Combat,
+		Commands,
+		Crash,
+		Debug,
+		Doors,
+		Error,
+		Guilds,
+		Inventory,
+		Launcher,
+		Netcode,
+		Normal,
+		Object,
+		Pathing,
+		QS_Server,
+		Quests,
+		Rules,
+		Skills,
+		Spawns,
+		Spells,
+		Status,
+		TCP_Connection,
+		Tasks,
+		Tradeskills,
+		Trading,
+		Tribute,
+		UCS_Server,
+		WebInterface_Server,
+		World_Server,
+		Zone_Server,
+		MySQLError,
+		MySQLQuery,
+		Mercenaries,
+		QuestDebug,
+		Server_Client_Packet,
+		Client_Server_Packet_Unhandled,
+		Server_Client_Packet_With_Dump,
+		Client_Server_Packet_With_Dump,
+		Login_Server,
+		Client_Login,
+		Headless_Client,
+		HP_Update,
+		FixZ,
+		Food,
+		Traps,
+		NPCRoamBox,
+		NPCScaling,
+		MobAppearance,
+		MaxCategoryID /* Don't Remove this */
+	};
 
-enum LogCategory {
-	None = 0,
-	AA,
-	AI,
-	Aggro,
-	Attack,
-	Client_Server_Packet,
-	Combat,
-	Commands,
-	Crash,
-	Debug,
-	Doors,
-	Error,
-	Guilds,
-	Inventory,
-	Launcher,
-	Netcode,
-	Normal,
-	Object,
-	Pathing,
-	QS_Server,
-	Quests,
-	Rules,
-	Skills,
-	Spawns,
-	Spells,
-	Status,
-	TCP_Connection,
-	Tasks,
-	Tradeskills,
-	Trading,
-	Tribute,
-	UCS_Server,
-	WebInterface_Server,
-	World_Server,
-	Zone_Server,
-	MySQLError,
-	MySQLQuery,
-	Mercenaries,
-	QuestDebug,
-	Server_Client_Packet,
-	Client_Server_Packet_Unhandled,
-	Server_Client_Packet_With_Dump,
-	Client_Server_Packet_With_Dump,
-	Login_Server,
-	Client_Login,
-	Headless_Client,
-	HP_Update,
-	FixZ,
-	Food,
-	Traps,
-	NPCRoamBox,
-	MaxCategoryID	/* Don't Remove this*/
-};
-
-/* If you add to this, make sure you update LogCategory */
-static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
-	"",
-	"AA",
-	"AI",
-	"Aggro",
-	"Attack",
-	"Packet :: Client -> Server",
-	"Combat",
-	"Commands",
-	"Crash",
-	"Debug",
-	"Doors",
-	"Error",
-	"Guilds",
-	"Inventory",
-	"Launcher",
-	"Netcode",
-	"Normal",
-	"Object",
-	"Pathing",
-	"QS Server",
-	"Quests",
-	"Rules",
-	"Skills",
-	"Spawns",
-	"Spells",
-	"Status",
-	"TCP Connection",
-	"Tasks",
-	"Tradeskills",
-	"Trading",
-	"Tribute",
-	"UCS Server",
-	"WebInterface Server",
-	"World Server",
-	"Zone Server",
-	"MySQL Error",
-	"MySQL Query",
-	"Mercenaries",
-	"Quest Debug",
-	"Packet :: Server -> Client",
-	"Packet :: Client -> Server Unhandled",
-	"Packet :: Server -> Client (Dump)",
-	"Packet :: Client -> Server (Dump)",
-	"Login Server",
-	"Client Login",
-	"Headless Client",
-	"HP Update",
-	"FixZ",
-	"Food",
-	"Traps",
-	"NPC Roam Box"
-};
+	/**
+	 * If you add to this, make sure you update LogCategory
+	 */
+	static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
+		"",
+		"AA",
+		"AI",
+		"Aggro",
+		"Attack",
+		"Packet :: Client -> Server",
+		"Combat",
+		"Commands",
+		"Crash",
+		"Debug",
+		"Doors",
+		"Error",
+		"Guilds",
+		"Inventory",
+		"Launcher",
+		"Netcode",
+		"Normal",
+		"Object",
+		"Pathing",
+		"QS Server",
+		"Quests",
+		"Rules",
+		"Skills",
+		"Spawns",
+		"Spells",
+		"Status",
+		"TCP Connection",
+		"Tasks",
+		"Tradeskills",
+		"Trading",
+		"Tribute",
+		"UCS Server",
+		"WebInterface Server",
+		"World Server",
+		"Zone Server",
+		"MySQL Error",
+		"MySQL Query",
+		"Mercenaries",
+		"Quest Debug",
+		"Packet :: Server -> Client",
+		"Packet :: Client -> Server Unhandled",
+		"Packet :: Server -> Client (Dump)",
+		"Packet :: Client -> Server (Dump)",
+		"Login Server",
+		"Client Login",
+		"Headless Client",
+		"HP Update",
+		"FixZ",
+		"Food",
+		"Traps",
+		"NPC Roam Box",
+		"NPC Scaling",
+		"Mob Appearance"
+	};
 }
 
 #define Log(debug_level, log_category, message, ...) do {\
-	if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-		LogSys.Out(debug_level, log_category, message, ##__VA_ARGS__);\
+    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
+        LogSys.Out(debug_level, log_category, message, ##__VA_ARGS__);\
 } while (0)
 
 #define LogF(debug_level, log_category, message, ...) do {\
-	if (LogSys.log_settings[log_category].is_category_enabled == 1)\
-		LogSys.OutF(debug_level, log_category, message, ##__VA_ARGS__);\
+    if (LogSys.log_settings[log_category].is_category_enabled == 1)\
+        OutF(LogSys, debug_level, log_category, message, ##__VA_ARGS__);\
 } while (0)
 
 class EQEmuLogSys {
@@ -165,39 +171,41 @@ public:
 	EQEmuLogSys();
 	~EQEmuLogSys();
 
-	void CloseFileLogs(); /* Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else. This should be handled on deconstructor but to be safe we use it anyways. */
-	void LoadLogSettingsDefaults(); /* Initializes log_settings and sets some defaults if DB is not present */
-	void MakeDirectory(const std::string &directory_name); /* Platform independent way of performing a MakeDirectory based on name */
-	/*
-		The one and only Logging function that uses a debug level as a parameter, as well as a log_category
-		log_category - defined in Logs::LogCategory::[]
-		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+	/**
+	 * Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else.
+	 * This should be handled on deconstructor but to be safe we use it anyways.
+	 */
+	void CloseFileLogs();
+	void LoadLogSettingsDefaults();
+	void MakeDirectory(const std::string &directory_name);
 
-		Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
-			- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
-				be checked against to see if that piped output is set to actually process it for the category and debug level
+	/**
+	 *	The one and only Logging function that uses a debug level as a parameter, as well as a log_category
+	 *		log_category - defined in Logs::LogCategory::[]
+	 *		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+	 *
+	 *	Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
+	 *		- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
+	 *			be checked against to see if that piped output is set to actually process it for the category and debug level
 	*/
 	void Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...);
-	void SetCurrentTimeStamp(char* time_stamp); /* Used in file logs to prepend a timestamp entry for logs */ 
-	void StartFileLogs(const std::string &log_name = ""); /* Used to declare the processes file log and to keep it open for later use */
 
-	template <typename... Args>
-	void OutF(Logs::DebugLevel debug_level, uint16 log_category, const char *fmt, const Args&... args)
-	{
-		std::string log_str = fmt::format(fmt, args...);
-		Out(debug_level, log_category, log_str);
-	}
+	/**
+	 * Used in file logs to prepend a timestamp entry for logs
+	 */
+	void SetCurrentTimeStamp(char* time_stamp);
+	void StartFileLogs(const std::string &log_name = "");
 
-	/*
-		LogSettings Struct
-
-		This struct is the master reference for all settings for each category, and for each output
-
-		log_to_file[category_id] = [1-3] - Sets debug level for category to output to file
-		log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
-		log_to_gmsay[category_id] = [1-3] - Sets debug level for category to output to gmsay
+	/**
+     * LogSettings Struct
+     *
+     * This struct is the master reference for all settings for each category, and for each output
+     *
+     * log_to_file[category_id]    = [1-3] - Sets debug level for category to output to file
+     * log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
+     * log_to_gmsay[category_id]   = [1-3] - Sets debug level for category to output to gmsay
+     *
 	*/
-
 	struct LogSettings {
 		uint8 log_to_file;
 		uint8 log_to_console;
@@ -205,32 +213,64 @@ public:
 		uint8 is_category_enabled; /* When any log output in a category > 0, set this to 1 as (Enabled) */
 	};
 
-	/* Internally used memory reference for all log settings per category.
-		These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults.
-		Database loaded via Database::LoadLogSettings(log_settings)
+	/**
+	 * Internally used memory reference for all log settings per category
+	 * These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults
+	 * Database loaded via Database::LoadLogSettings(log_settings)
 	*/
 	LogSettings log_settings[Logs::LogCategory::MaxCategoryID];
 
-	bool file_logs_enabled; /* Set when log settings are loaded to determine if keeping a file open is necessary */
+	bool file_logs_enabled;
 
-	int log_platform; /* Sets Executable platform (Zone/World/UCS) etc. */
+	/**
+	 * Sets Executable platform (Zone/World/UCS) etc.
+	 */
+	int log_platform;
 
-	std::string platform_file_name; /* File name used in writing logs */
+	/**
+	 * File name used in writing logs
+	 */
+	std::string platform_file_name;
 
-	uint16 GetGMSayColorFromCategory(uint16 log_category); /* GMSay Client Message colors mapped by category */
+	/**
+	 * GMSay Client Message colors mapped by category
+	 *
+	 * @param log_category
+	 * @return
+	 */
+	uint16 GetGMSayColorFromCategory(uint16 log_category);
 
-	void OnLogHookCallBackZone(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+	void SetGMSayHandler(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+	void SetConsoleHandler(std::function<void(uint16 debug_level, uint16 log_type, const std::string&)> f) { on_log_console_hook = f; }
 
 private:
-	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook; /* Callback pointer to zone process for hooking logs to zone using GMSay */
-	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message); /* Formats log messages like '[Category] This is a log message' */
-	std::string GetLinuxConsoleColorFromCategory(uint16 log_category); /* Linux console color messages mapped by category */
 
-	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */
+	/**
+	 * Callback pointer to zone process for hooking logs to zone using GMSay
+	 */
+	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook;
+	std::function<void(uint16 debug_level, uint16 log_category, const std::string&)> on_log_console_hook;
 
-	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log */
-	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log */
-	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log */
+	/**
+	 * Formats log messages like '[Category] This is a log message'
+	 */
+	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message);
+
+	/**
+	 * Linux console color messages mapped by category
+	 * @param log_category
+	 * @return
+	 */
+	std::string GetLinuxConsoleColorFromCategory(uint16 log_category);
+
+	/**
+	 * Windows console color messages mapped by category
+	 */
+	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category);
+
+	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message);
+	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message);
+	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message);
 };
 
 extern EQEmuLogSys LogSys;

common/eqemu_logsys_fmt.h

@@ -0,0 +1,30 @@
+/**
+ * EQEmulator: Everquest Server Emulator
+ * Copyright (C) 2001-2019 EQEmulator Development Team (https://github.com/EQEmu/Server)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY except by those people which sell it, which
+ * are required to give you total support for your newly bought product;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+*/
+
+#pragma once
+
+#include <fmt/format.h>
+
+template <typename... Args>
+void OutF(EQEmuLogSys &ls, Logs::DebugLevel debug_level, uint16 log_category, const char *fmt, const Args&... args)
+{
+	std::string log_str = fmt::format(fmt, args...);
+	ls.Out(debug_level, log_category, log_str);
+}

common/event/background_task.h

@@ -1,42 +0,0 @@
-#pragma once
-#include <functional>
-#include "../any.h"
-#include "event_loop.h"
-
-namespace EQ {
-	class BackgroundTask
-	{
-	public:
-		typedef std::function<void(EQEmu::Any&)> BackgroundTaskFunction;
-		struct BackgroundTaskBaton
-		{
-			BackgroundTaskFunction fn;
-			BackgroundTaskFunction on_finish;
-			EQEmu::Any data;
-		};
-
-		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish, EQEmu::Any data) {
-			uv_work_t *m_work = new uv_work_t;
-			memset(m_work, 0, sizeof(uv_work_t));
-			BackgroundTaskBaton *baton = new BackgroundTaskBaton();
-			baton->fn = fn;
-			baton->on_finish = on_finish;
-			baton->data = data;
-		
-			m_work->data = baton;
-			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->fn(baton->data);
-			}, [](uv_work_t* req, int status) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->on_finish(baton->data);
-				delete baton;
-				delete req;
-			});
-		}
-
-		~BackgroundTask() {
-
-		}
-	};
-}

common/event/event_loop.h

@@ -8,30 +8,30 @@ namespace EQ
 	class EventLoop
 	{
 	public:
-		static EventLoop &Get() {
-			static EventLoop inst;
-			return inst;
+		EventLoop() {
+			memset(&m_loop, 0, sizeof(uv_loop_t));
+			uv_loop_init(&m_loop);
 		}
 
 		~EventLoop() {
 			uv_loop_close(&m_loop);
 		}
 
+		EventLoop(const EventLoop&) = delete;
+		EventLoop& operator=(const EventLoop&) = delete;
+		
+		static EventLoop &GetDefault() {
+			static thread_local EventLoop inst;
+			return inst;
+		}
+
 		void Process() {
 			uv_run(&m_loop, UV_RUN_NOWAIT);
 		}
 
 		uv_loop_t* Handle() { return &m_loop; }
 
-	private:
-		EventLoop() {
-			memset(&m_loop, 0, sizeof(uv_loop_t));
-			uv_loop_init(&m_loop);
-		}
-		
-		EventLoop(const EventLoop&);
-		EventLoop& operator=(const EventLoop&);
-	
+	private:	
 		uv_loop_t m_loop;
 	};
 }

common/event/task.h

@@ -0,0 +1,105 @@
+#pragma once
+#include <functional>
+#include <exception>
+#include "event_loop.h"
+#include "../any.h"
+
+namespace EQ {
+	class Task
+	{
+	public:
+		typedef std::function<void(const EQEmu::Any&)> ResolveFn;
+		typedef std::function<void(const std::exception&)> RejectFn;
+		typedef std::function<void()> FinallyFn;
+		typedef std::function<void(ResolveFn, RejectFn)> TaskFn;
+		struct TaskBaton
+		{
+			TaskFn fn;
+			ResolveFn on_then;
+			RejectFn on_catch;
+			FinallyFn on_finally;
+			bool has_result;
+			EQEmu::Any result;
+			bool has_error;
+			std::exception error;
+		};
+
+		Task(EventLoop &loop, TaskFn fn) : _loop(loop) {
+			_fn = fn;
+		}
+
+		Task(TaskFn fn) : _loop(EventLoop::GetDefault()) {
+			_fn = fn;
+		}
+
+		~Task() {
+
+		}
+
+		Task& Then(ResolveFn fn) {
+			_then = fn;
+			return *this;
+		}
+
+		Task& Catch(RejectFn fn) {
+			_catch = fn;
+			return *this;
+		}
+
+		Task& Finally(FinallyFn fn) {
+			_fin = fn;
+			return *this;
+		}
+
+		void Run() {
+			uv_work_t *work = new uv_work_t;
+			memset(work, 0, sizeof(uv_work_t));
+			TaskBaton *baton = new TaskBaton();
+			baton->fn = _fn;
+			baton->on_then = _then;
+			baton->on_catch = _catch;
+			baton->on_finally = _fin;
+			baton->has_result = false;
+			baton->has_error = false;
+
+			work->data = baton;
+
+			uv_queue_work(_loop.Handle(), work, [](uv_work_t* req) {
+				TaskBaton *baton = (TaskBaton*)req->data;
+
+				baton->fn([baton](const EQEmu::Any& result) {
+					baton->has_error = false;
+					baton->has_result = true;
+					baton->result = result;
+				}, [baton](const std::exception &err) {
+					baton->has_error = true;
+					baton->has_result = false;
+					baton->error = err;
+				});
+			}, [](uv_work_t* req, int status) {
+				TaskBaton *baton = (TaskBaton*)req->data;
+
+				if (baton->has_error && baton->on_catch) {
+					baton->on_catch(baton->error);
+				}
+				else if (baton->has_result && baton->on_then) {
+					baton->on_then(baton->result);
+				}
+
+				if (baton->on_finally) {
+					baton->on_finally();
+				}
+
+				delete baton;
+				delete req;
+			});
+		}
+
+	private:
+		TaskFn _fn;
+		ResolveFn _then;
+		RejectFn _catch;
+		FinallyFn _fin;
+		EventLoop &_loop;
+	};
+}

common/event/timer.h

@@ -6,16 +6,29 @@ namespace EQ {
 	class Timer
 	{
 	public:
-		Timer(std::function<void(Timer *)> cb)
+		Timer(EventLoop &loop, std::function<void(Timer *)> cb) : _loop(loop)
 		{
-			m_timer = nullptr;
-			m_cb = cb;
+			_timer = nullptr;
+			_cb = cb;
 		}
 
-		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
+		Timer(EventLoop &loop, uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb) : _loop(loop)
 		{
-			m_timer = nullptr;
-			m_cb = cb;
+			_timer = nullptr;
+			_cb = cb;
+			Start(duration_ms, repeats);
+		}
+
+		Timer(std::function<void(Timer *)> cb) : _loop(EventLoop::GetDefault())
+		{
+			_timer = nullptr;
+			_cb = cb;
+		}
+
+		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb) : _loop(EventLoop::GetDefault())
+		{
+			_timer = nullptr;
+			_cb = cb;
 			Start(duration_ms, repeats);
 		}
 	
@@ -25,21 +38,21 @@ namespace EQ {
 		}
 
 		void Start(uint64_t duration_ms, bool repeats) {
-			auto loop = EventLoop::Get().Handle();
-			if (!m_timer) {
-				m_timer = new uv_timer_t;
-				memset(m_timer, 0, sizeof(uv_timer_t));
-				uv_timer_init(loop, m_timer);
-				m_timer->data = this;
+			auto loop = EventLoop::GetDefault().Handle();
+			if (!_timer) {
+				_timer = new uv_timer_t;
+				memset(_timer, 0, sizeof(uv_timer_t));
+				uv_timer_init(loop, _timer);
+				_timer->data = this;
 
 				if (repeats) {
-					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+					uv_timer_start(_timer, [](uv_timer_t *handle) {
 						Timer *t = (Timer*)handle->data;
 						t->Execute();
 					}, duration_ms, duration_ms);
 				}
 				else {
-					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+					uv_timer_start(_timer, [](uv_timer_t *handle) {
 						Timer *t = (Timer*)handle->data;
 						t->Stop();
 						t->Execute();
@@ -49,19 +62,20 @@ namespace EQ {
 		}
 
 		void Stop() {
-			if (m_timer) {
-				uv_close((uv_handle_t*)m_timer, [](uv_handle_t* handle) {
+			if (_timer) {
+				uv_close((uv_handle_t*)_timer, [](uv_handle_t* handle) {
 					delete handle;
 				});
-				m_timer = nullptr;
+				_timer = nullptr;
 			}
 		}
 	private:
 		void Execute() {
-			m_cb(this);
+			_cb(this);
 		}
 	
-		uv_timer_t *m_timer;
-		std::function<void(Timer*)> m_cb;
+		EventLoop &_loop;
+		uv_timer_t *_timer;
+		std::function<void(Timer*)> _cb;
 	};
 }

common/faction.cpp

@@ -18,6 +18,7 @@
 
 #include "faction.h"
 #include "races.h"
+#include "rulesys.h"
 
 const char *FactionValueToString(FACTION_VALUE fv)
 {
@@ -59,34 +60,31 @@ FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 	if (fm) {
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
 	}
-	if (character_value >= 1101) {
+	if (character_value >= RuleI(Faction, AllyFactionMinimum)) {
 		return FACTION_ALLY;
 	}
-	if (character_value >= 701 && character_value <= 1100) {
+	if (character_value >= RuleI(Faction, WarmlyFactionMinimum)) {
 		return FACTION_WARMLY;
 	}
-	if (character_value >= 401 && character_value <= 700) {
+	if (character_value >= RuleI(Faction, KindlyFactionMinimum)) {
 		return FACTION_KINDLY;
 	}
-	if (character_value >= 101 && character_value <= 400) {
+	if (character_value >= RuleI(Faction, AmiablyFactionMinimum)) {
 		return FACTION_AMIABLE;
 	}
-	if (character_value >= 0 && character_value <= 100) {
+	if (character_value >= RuleI(Faction, IndifferentlyFactionMinimum)) {
 		return FACTION_INDIFFERENT;
 	}
-	if (character_value >= -100 && character_value <= -1) {
+	if (character_value >= RuleI(Faction, ApprehensivelyFactionMinimum)) {
 		return FACTION_APPREHENSIVE;
 	}
-	if (character_value >= -700 && character_value <= -101) {
+	if (character_value >= RuleI(Faction, DubiouslyFactionMinimum)) {
 		return FACTION_DUBIOUS;
 	}
-	if (character_value >= -999 && character_value <= -701) {
+	if (character_value >= RuleI(Faction, ThreateninglyFactionMinimum)) {
 		return FACTION_THREATENLY;
 	}
-	if (character_value <= -1000) {
-		return FACTION_SCOWLS;
-	}
-	return FACTION_INDIFFERENT;
+	return FACTION_SCOWLS;
 }
 
 // this function should check if some races have more than one race define

common/faction.h

@@ -50,6 +50,8 @@ struct NPCFactionList {
 struct FactionMods
 {
 	int32 base;
+	int16	min; 	// The lowest your personal earned faction can go - before race/class/diety adjustments.
+	int16	max; 	// The highest your personal earned faction can go - before race/class/diety adjustments.
 	int32 class_mod;
 	int32 race_mod;
 	int32 deity_mod;
@@ -59,6 +61,8 @@ struct Faction {
 	int32	id;
 	std::map<std::string, int16> mods;
 	int16	base;
+	int16	min; // The lowest your personal earned faction can go - before race/class/diety adjustments.
+	int16	max; // The highest your personal earned faction can go - before race/class/diety adjustments.
 	char	name[50];
 };
 

common/features.h

@@ -150,7 +150,7 @@ enum {	//reuse times
 
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
-	AIthink_duration = 150,
+	AIthink_duration = 50,
 	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
@@ -268,13 +268,10 @@ enum {
 	commandBanPlayers = 100,		//can set bans on players
 	commandChangeDatarate = 201,	//edit client's data rate
 	commandZoneToCoords = 0,		//can #zone with coords
-	commandInterrogateInv = 100		//below this == only log on error state and self-only target dump
+	commandInterrogateInv = 100,	//below this == only log on error state and self-only target dump
+	commandInvSnapshot = 150		//ability to clear/restore snapshots
 };
 
-//default states for logging flag on NPCs and clients (having NPCs on by default is prolly a bad idea)
-#define CLIENT_DEFAULT_LOGGING_ENABLED true
-#define NPC_DEFAULT_LOGGING_ENABLED false
-
 
 // This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
 #define SAYLINK_ITEM_ID 0xFFFFF

common/glm/copying.txt

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

common/glm/glm/CMakeLists.txt

@@ -1,67 +0,0 @@
-file(GLOB ROOT_SOURCE *.cpp)
-file(GLOB ROOT_INLINE *.inl)
-file(GLOB ROOT_HEADER *.hpp)
-file(GLOB ROOT_TEXT ../*.txt)
-file(GLOB ROOT_MD ../*.md)
-file(GLOB ROOT_NAT ../util/glm.natvis)
-
-file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
-file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
-file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
-
-file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
-file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
-file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
-
-file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
-file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
-file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
-
-file(GLOB_RECURSE SIMD_SOURCE ./simd/*.cpp)
-file(GLOB_RECURSE SIMD_INLINE ./simd/*.inl)
-file(GLOB_RECURSE SIMD_HEADER ./simd/*.h)
-
-source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD})
-source_group("Core Files" FILES ${CORE_SOURCE})
-source_group("Core Files" FILES ${CORE_INLINE})
-source_group("Core Files" FILES ${CORE_HEADER})
-source_group("GTC Files" FILES ${GTC_SOURCE})
-source_group("GTC Files" FILES ${GTC_INLINE})
-source_group("GTC Files" FILES ${GTC_HEADER})
-source_group("GTX Files" FILES ${GTX_SOURCE})
-source_group("GTX Files" FILES ${GTX_INLINE})
-source_group("GTX Files" FILES ${GTX_HEADER})
-source_group("SIMD Files" FILES ${SIMD_SOURCE})
-source_group("SIMD Files" FILES ${SIMD_INLINE})
-source_group("SIMD Files" FILES ${SIMD_HEADER})
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-if(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	if(GLM_STATIC_LIBRARY_ENABLE)
-		add_library(glm_static STATIC ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_STATIC_LIBRARY_ENABLE)
-
-	if(GLM_DYNAMIC_LIBRARY_ENABLE)
-		add_library(glm_shared SHARED ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_DYNAMIC_LIBRARY_ENABLE)
-
-else(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	add_executable(glm_dummy ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-		${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-
-endif(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)

common/glm/glm/common.hpp

@@ -1,6 +0,0 @@
-/// @ref core
-/// @file glm/common.hpp
-
-#pragma once
-
-#include "detail/func_common.hpp"

common/glm/glm/detail/_features.hpp

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

common/glm/glm/detail/_fixes.hpp

@@ -1,30 +0,0 @@
-/// @ref core
-/// @file glm/detail/_fixes.hpp
-
-#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
-

common/glm/glm/detail/_noise.hpp

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

common/glm/glm/detail/_swizzle.hpp

@@ -1,797 +0,0 @@
-/// @ref core
-/// @file glm/detail/_swizzle.hpp
-
-#pragma once
-
-namespace glm{
-namespace detail
-{
-	// Internal class for implementing swizzle operators
-	template <typename T, int N>
-	struct _swizzle_base0
-	{
-	protected:
-		GLM_FUNC_QUALIFIER T& elem(size_t i){ return (reinterpret_cast<T*>(_buffer))[i]; }
-		GLM_FUNC_QUALIFIER T const& elem(size_t i) const{ return (reinterpret_cast<const T*>(_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 <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, bool Aligned>
-	struct _swizzle_base1 : public _swizzle_base0<T, N>
-	{
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, bool Aligned>
-	struct _swizzle_base1<2, T, P, vecType, E0,E1,-1,-2, Aligned> : public _swizzle_base0<T, 2>
-	{
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(this->elem(E0), this->elem(E1)); }
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, bool Aligned>
-	struct _swizzle_base1<3, T, P, vecType, E0,E1,E2,-1, Aligned> : public _swizzle_base0<T, 3>
-	{
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(this->elem(E0), this->elem(E1), this->elem(E2)); }
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, bool Aligned>
-	struct _swizzle_base1<4, T, P, vecType, E0,E1,E2,E3, Aligned> : public _swizzle_base0<T, 4>
-	{ 
-		GLM_FUNC_QUALIFIER vecType<T, P> operator ()()  const { return vecType<T, P>(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 <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, int DUPLICATE_ELEMENTS>
-	struct _swizzle_base2 : public _swizzle_base1<N, T, P, vecType, E0,E1,E2,E3, detail::is_aligned<P>::value>
-	{
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (const T& t)
-		{
-			for (int i = 0; i < N; ++i)
-				(*this)[i] = t;
-			return *this;
-		}
-
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (vecType<T, P> const& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e = t; } 
-			};
-			_apply_op(that, op());
-			return *this;
-		}
-
-		GLM_FUNC_QUALIFIER void operator -= (vecType<T, P> const& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e -= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator += (vecType<T, P> const& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e += t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator *= (vecType<T, P> const& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e *= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER void operator /= (vecType<T, P> const& that)
-		{
-			struct op { 
-				GLM_FUNC_QUALIFIER void operator() (T& e, T& t) { e /= t; } 
-			};
-			_apply_op(that, op());
-		}
-
-		GLM_FUNC_QUALIFIER T& operator[](size_t i)
-		{
-			const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-		GLM_FUNC_QUALIFIER T operator[](size_t i) const
-		{
-			const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-
-	protected:
-		template <typename U>
-		GLM_FUNC_QUALIFIER void _apply_op(vecType<T, P> const& that, U 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.
-			T 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 <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-	struct _swizzle_base2<N, T, P, vecType, E0,E1,E2,E3, 1> : public _swizzle_base1<N, T, P, vecType, E0,E1,E2,E3, detail::is_aligned<P>::value>
-	{
-		struct Stub {};
-
-		GLM_FUNC_QUALIFIER _swizzle_base2& operator= (Stub const &) { return *this; }
-
-		GLM_FUNC_QUALIFIER T operator[]  (size_t i) const
-		{
-			const int offset_dst[4] = { E0, E1, E2, E3 };
-			return this->elem(offset_dst[i]);
-		}
-	};
-
-	template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-	struct _swizzle : public _swizzle_base2<N, T, P, vecType, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)>
-	{
-		typedef _swizzle_base2<N, T, P, vecType, E0, E1, E2, E3, (E0 == E1 || E0 == E2 || E0 == E3 || E1 == E2 || E1 == E3 || E2 == E3)> base_type;
-
-		using base_type::operator=;
-
-		GLM_FUNC_QUALIFIER operator vecType<T, P> () const { return (*this)(); }
-	};
-
-//
-// To prevent the C++ syntax from getting entirely overwhelming, define some alias macros
-//
-#define _GLM_SWIZZLE_TEMPLATE1   template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3>
-#define _GLM_SWIZZLE_TEMPLATE2   template <int N, typename T, precision P, template <typename, precision> class vecType, int E0, int E1, int E2, int E3, int F0, int F1, int F2, int F3>
-#define _GLM_SWIZZLE_TYPE1       _swizzle<N, T, P, vecType, E0, E1, E2, E3>
-#define _GLM_SWIZZLE_TYPE2       _swizzle<N, T, P, vecType, F0, F1, F2, F3>
-
-//
-// Wrapper for a binary operator (e.g. u.yy + v.zy)
-//
-#define _GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
-	_GLM_SWIZZLE_TEMPLATE2                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b)  \
-	{                                                                               \
-		return a() OPERAND b();                                                     \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const vecType<T, P>& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const vecType<T, P>& a, const _GLM_SWIZZLE_TYPE1& b)                   \
-	{                                                                               \
-		return a OPERAND b();                                                       \
-	}
-
-//
-// Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz)
-//
-#define _GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND)                 \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const _GLM_SWIZZLE_TYPE1& a, const T& b)                   \
-	{                                                                               \
-		return a() OPERAND b;                                                       \
-	}                                                                               \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER vecType<T, P> operator OPERAND ( const T& a, const _GLM_SWIZZLE_TYPE1& b)                   \
-	{                                                                               \
-		return a OPERAND b();                                                       \
-	}
-
-//
-// Macro for wrapping a function taking one argument (e.g. abs())
-//
-#define _GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION)                          \
-	_GLM_SWIZZLE_TEMPLATE1                                                          \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a)  \
-	{                                                                               \
-		return FUNCTION(a());                                                       \
-	}
-
-//
-// Macro for wrapping a function taking two vector arguments (e.g. dot()).
-//
-#define _GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION)                                                      \
-	_GLM_SWIZZLE_TEMPLATE2                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b) \
-	{                                                                                                           \
-		return FUNCTION(a(), b());                                                                              \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename V& b)         \
-	{                                                                                                           \
-		return FUNCTION(a(), b);                                                                                \
-	}                                                                                                           \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                      \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const _GLM_SWIZZLE_TYPE1& b)                  \
-	{                                                                                                           \
-		return FUNCTION(a, b());                                                                                \
-	} 
-
-//
-// Macro for wrapping a function take 2 vec arguments followed by a scalar (e.g. mix()).
-//
-#define _GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(RETURN_TYPE,FUNCTION)                                                             \
-	_GLM_SWIZZLE_TEMPLATE2                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE2& b, const T& c)   \
-	{                                                                                                                         \
-		return FUNCTION(a(), b(), c);                                                                                         \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)   \
-	{                                                                                                                         \
-		return FUNCTION(a(), b(), c);                                                                                         \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const _GLM_SWIZZLE_TYPE1& a, const typename S0::vec_type& b, const T& c)\
-	{                                                                                                                         \
-		return FUNCTION(a(), b, c);                                                                                           \
-	}                                                                                                                         \
-	_GLM_SWIZZLE_TEMPLATE1                                                                                                    \
-	GLM_FUNC_QUALIFIER typename _GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const typename V& a, const _GLM_SWIZZLE_TYPE1& b, const T& c)           \
-	{                                                                                                                         \
-		return FUNCTION(a, b(), c);                                                                                           \
-	} 
- 
-}//namespace detail 
-}//namespace glm
-
-namespace glm
-{
-	namespace detail
-	{
-		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(-)
-		_GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(*)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(+)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(-)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(*)
-		_GLM_SWIZZLE_VECTOR_BINARY_OPERATOR_IMPLEMENTATION(/)
-	}
-
-	//
-	// Swizzles are distinct types from the unswizzled type.  The below macros will
-	// provide template specializations for the swizzle types for the given functions
-	// so that the compiler does not have any ambiguity to choosing how to handle
-	// the function.
-	//
-	// The alternative is to use the operator()() when calling the function in order
-	// to explicitly convert the swizzled type to the unswizzled type.
-	//
-
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    abs);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acos);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    acosh);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    all);
-	//_GLM_SWIZZLE_FUNCTION_1_ARGS(vec_type,    any);
-
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(value_type,  dot);
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    cross);
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS(vec_type,    step);    
-	//_GLM_SWIZZLE_FUNCTION_2_ARGS_SCALAR(vec_type, mix);
-}
-
-#define _GLM_SWIZZLE2_2_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<2, T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2, T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2, T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2, T, P, V, 1,1,-1,-2> E1 ## E1; }; 
-
-#define _GLM_SWIZZLE2_3_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<3,T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3,T, P, V, 1,1,1,-1> E1 ## E1 ## E1; };  
-
-#define _GLM_SWIZZLE2_4_MEMBERS(T, P, V, E0,E1) \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; };
-
-#define _GLM_SWIZZLE3_2_MEMBERS(T, P, V, E0,E1,E2) \
-	struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; };
-
-#define _GLM_SWIZZLE3_3_MEMBERS(T, P, V ,E0,E1,E2) \
-	struct { detail::_swizzle<3, T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,2,-1> E2 ## E2 ## E2; };
-
-#define _GLM_SWIZZLE3_4_MEMBERS(T, P, V, E0,E1,E2) \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4,T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; 
-
-#define _GLM_SWIZZLE4_2_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<2,T, P, V, 0,0,-1,-2> E0 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,1,-1,-2> E0 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,2,-1,-2> E0 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 0,3,-1,-2> E0 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,0,-1,-2> E1 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,1,-1,-2> E1 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,2,-1,-2> E1 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 1,3,-1,-2> E1 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,0,-1,-2> E2 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,1,-1,-2> E2 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,2,-1,-2> E2 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 2,3,-1,-2> E2 ## E3; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,0,-1,-2> E3 ## E0; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,1,-1,-2> E3 ## E1; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,2,-1,-2> E3 ## E2; }; \
-	struct { detail::_swizzle<2,T, P, V, 3,3,-1,-2> E3 ## E3; }; 
-
-#define _GLM_SWIZZLE4_3_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<3, T, P, V, 0,0,0,-1> E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,1,-1> E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,2,-1> E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,0,3,-1> E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,0,-1> E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,1,-1> E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,2,-1> E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,1,3,-1> E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,0,-1> E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,1,-1> E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,2,-1> E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,2,3,-1> E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,0,-1> E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,1,-1> E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,2,-1> E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 0,3,3,-1> E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,0,-1> E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,1,-1> E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,2,-1> E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,0,3,-1> E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,0,-1> E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,1,-1> E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,2,-1> E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,1,3,-1> E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,0,-1> E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,1,-1> E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,2,-1> E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,2,3,-1> E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,0,-1> E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,1,-1> E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,2,-1> E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 1,3,3,-1> E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,0,-1> E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,1,-1> E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,2,-1> E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,0,3,-1> E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,0,-1> E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,1,-1> E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,2,-1> E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,1,3,-1> E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,0,-1> E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,1,-1> E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,2,-1> E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,2,3,-1> E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,0,-1> E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,1,-1> E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,2,-1> E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 2,3,3,-1> E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,0,-1> E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,1,-1> E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,2,-1> E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,0,3,-1> E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,0,-1> E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,1,-1> E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,2,-1> E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,1,3,-1> E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,0,-1> E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,1,-1> E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,2,-1> E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,2,3,-1> E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,0,-1> E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,1,-1> E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,2,-1> E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<3, T, P, V, 3,3,3,-1> E3 ## E3 ## E3; };  
-
-#define _GLM_SWIZZLE4_4_MEMBERS(T, P, V, E0,E1,E2,E3) \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,0> E0 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,1> E0 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,2> E0 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,0,3> E0 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,0> E0 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,1> E0 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,2> E0 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,1,3> E0 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,0> E0 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,1> E0 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,2> E0 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,2,3> E0 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,0> E0 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,1> E0 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,2> E0 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,0,3,3> E0 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,0> E0 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,1> E0 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,2> E0 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,0,3> E0 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,0> E0 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,1> E0 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,2> E0 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,1,3> E0 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,0> E0 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,1> E0 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,2> E0 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,2,3> E0 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,0> E0 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,1> E0 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,2> E0 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,1,3,3> E0 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,0> E0 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,1> E0 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,2> E0 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,0,3> E0 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,0> E0 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,1> E0 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,2> E0 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,1,3> E0 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,0> E0 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,1> E0 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,2> E0 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,2,3> E0 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,0> E0 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,1> E0 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,2> E0 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,2,3,3> E0 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,0> E0 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,1> E0 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,2> E0 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,0,3> E0 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,0> E0 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,1> E0 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,2> E0 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,1,3> E0 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,0> E0 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,1> E0 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,2> E0 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,2,3> E0 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,0> E0 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,1> E0 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,2> E0 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 0,3,3,3> E0 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,0> E1 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,1> E1 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,2> E1 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,0,3> E1 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,0> E1 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,1> E1 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,2> E1 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,1,3> E1 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,0> E1 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,1> E1 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,2> E1 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,2,3> E1 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,0> E1 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,1> E1 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,2> E1 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,0,3,3> E1 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,0> E1 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,1> E1 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,2> E1 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,0,3> E1 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,0> E1 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,1> E1 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,2> E1 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,1,3> E1 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,0> E1 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,1> E1 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,2> E1 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,2,3> E1 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,0> E1 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,1> E1 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,2> E1 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,1,3,3> E1 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,0> E1 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,1> E1 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,2> E1 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,0,3> E1 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,0> E1 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,1> E1 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,2> E1 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,1,3> E1 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,0> E1 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,1> E1 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,2> E1 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,2,3> E1 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,0> E1 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,1> E1 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,2> E1 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,2,3,3> E1 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,0> E1 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,1> E1 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,2> E1 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,0,3> E1 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,0> E1 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,1> E1 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,2> E1 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,1,3> E1 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,0> E1 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,1> E1 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,2> E1 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,2,3> E1 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,0> E1 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,1> E1 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,2> E1 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 1,3,3,3> E1 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,0> E2 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,1> E2 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,2> E2 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,0,3> E2 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,0> E2 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,1> E2 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,2> E2 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,1,3> E2 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,0> E2 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,1> E2 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,2> E2 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,2,3> E2 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,0> E2 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,1> E2 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,2> E2 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,0,3,3> E2 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,0> E2 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,1> E2 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,2> E2 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,0,3> E2 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,0> E2 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,1> E2 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,2> E2 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,1,3> E2 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,0> E2 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,1> E2 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,2> E2 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,2,3> E2 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,0> E2 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,1> E2 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,2> E2 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,1,3,3> E2 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,0> E2 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,1> E2 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,2> E2 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,0,3> E2 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,0> E2 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,1> E2 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,2> E2 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,1,3> E2 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,0> E2 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,1> E2 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,2> E2 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,2,3> E2 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,0> E2 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,1> E2 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,2> E2 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,2,3,3> E2 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,0> E2 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,1> E2 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,2> E2 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,0,3> E2 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,0> E2 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,1> E2 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,2> E2 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,1,3> E2 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,0> E2 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,1> E2 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,2> E2 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,2,3> E2 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,0> E2 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,1> E2 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,2> E2 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 2,3,3,3> E2 ## E3 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,0> E3 ## E0 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,1> E3 ## E0 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,2> E3 ## E0 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,0,3> E3 ## E0 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,0> E3 ## E0 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,1> E3 ## E0 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,2> E3 ## E0 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,1,3> E3 ## E0 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,0> E3 ## E0 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,1> E3 ## E0 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,2> E3 ## E0 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,2,3> E3 ## E0 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,0> E3 ## E0 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,1> E3 ## E0 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,2> E3 ## E0 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,0,3,3> E3 ## E0 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,0> E3 ## E1 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,1> E3 ## E1 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,2> E3 ## E1 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,0,3> E3 ## E1 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,0> E3 ## E1 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,1> E3 ## E1 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,2> E3 ## E1 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,1,3> E3 ## E1 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,0> E3 ## E1 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,1> E3 ## E1 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,2> E3 ## E1 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,2,3> E3 ## E1 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,0> E3 ## E1 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,1> E3 ## E1 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,2> E3 ## E1 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,1,3,3> E3 ## E1 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,0> E3 ## E2 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,1> E3 ## E2 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,2> E3 ## E2 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,0,3> E3 ## E2 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,0> E3 ## E2 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,1> E3 ## E2 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,2> E3 ## E2 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,1,3> E3 ## E2 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,0> E3 ## E2 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,1> E3 ## E2 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,2> E3 ## E2 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,2,3> E3 ## E2 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,0> E3 ## E2 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,1> E3 ## E2 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,2> E3 ## E2 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,2,3,3> E3 ## E2 ## E3 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,0> E3 ## E3 ## E0 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,1> E3 ## E3 ## E0 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,2> E3 ## E3 ## E0 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,0,3> E3 ## E3 ## E0 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,0> E3 ## E3 ## E1 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,1> E3 ## E3 ## E1 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,2> E3 ## E3 ## E1 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,1,3> E3 ## E3 ## E1 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,0> E3 ## E3 ## E2 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,1> E3 ## E3 ## E2 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,2> E3 ## E3 ## E2 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,2,3> E3 ## E3 ## E2 ## E3; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,0> E3 ## E3 ## E3 ## E0; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,1> E3 ## E3 ## E3 ## E1; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,2> E3 ## E3 ## E3 ## E2; }; \
-	struct { detail::_swizzle<4, T, P, V, 3,3,3,3> E3 ## E3 ## E3 ## E3; };

common/glm/glm/detail/_swizzle_func.hpp

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

common/glm/glm/detail/_vectorize.hpp

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

common/glm/glm/detail/dummy.cpp

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

common/glm/glm/detail/func_common.hpp

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

common/glm/glm/detail/func_common.inl

@@ -1,849 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_common.inl
-
-#include "func_vector_relational.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-#include "_vectorize.hpp"
-#include <limits>
-
-namespace glm
-{
-	// min
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point or integer inputs");
-		return x < y ? x : y;
-	}
-
-	// max
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point or integer inputs");
-
-		return x > y ? x : y;
-	}
-
-	// abs
-	template <>
-	GLM_FUNC_QUALIFIER int32 abs(int32 x)
-	{
-		int32 const y = x >> 31;
-		return (x ^ y) - y;
-	}
-
-	// round
-#	if GLM_HAS_CXX11_STL
-		using ::std::round;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType round(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'round' only accept floating-point inputs");
-
-			return x < static_cast<genType>(0) ? static_cast<genType>(int(x - static_cast<genType>(0.5))) : static_cast<genType>(int(x + static_cast<genType>(0.5)));
-		}
-#	endif
-
-	// trunc
-#	if GLM_HAS_CXX11_STL
-		using ::std::trunc;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType trunc(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
-
-			return x < static_cast<genType>(0) ? -std::floor(-x) : std::floor(x);
-		}
-#	endif
-
-}//namespace glm
-
-namespace glm{
-namespace detail
-{
-	template <typename genFIType, bool /*signed*/>
-	struct compute_abs
-	{};
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, true>
-	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed || GLM_UNRESTRICTED_GENTYPE,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
-
-			return x >= genFIType(0) ? x : -x;
-			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
-		}
-	};
-
-	#if GLM_COMPILER & GLM_COMPILER_CUDA
-	template <>
-	struct compute_abs<float, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(float x)
-		{
-			return fabsf(x);
-		}
-	};
-	#endif
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, false>
-	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				(!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer) || GLM_UNRESTRICTED_GENTYPE,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
-			return x;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_abs_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(abs, x);
-		}
-	};
-
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_vector<T, bool, P, vecType, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
-		{
-			vecType<T, P> Result(uninitialize);
-			for(length_t i = 0; i < x.length(); ++i)
-				Result[i] = a[i] ? y[i] : x[i];
-			return Result;
-		}
-	};
-
-	template <typename T, typename U, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_scalar
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mix_scalar<T, bool, P, vecType, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, typename U>
-	struct compute_mix
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
-		}
-	};
-
-	template <typename T>
-	struct compute_mix<T, bool>
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool isFloat, bool Aligned>
-	struct compute_sign
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
-		}
-	};
-
-#	if GLM_ARCH == GLM_ARCH_X86
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_sign<T, P, vecType, false, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
-			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
-
-			return (x >> Shift) | y;
-		}
-	};
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_floor
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::floor, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_ceil
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::ceil, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_fract
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return x - floor(x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_trunc
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(trunc, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_round
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(round, x);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_mod
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, vecType<T, P> const & b)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
-			return a - b * floor(a / b);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_min_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
-		{
-			return detail::functor2<T, P, vecType>::call(min, x, y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_max_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y)
-		{
-			return detail::functor2<T, P, vecType>::call(max, x, y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_clamp_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
-		{
-			return min(max(x, minVal), maxVal);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_step_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge, vecType<T, P> const & x)
-		{
-			return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_smoothstep_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'step' only accept floating-point inputs");
-			vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
-			return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
-		}
-	};
-}//namespace detail
-
-	template <typename genFIType>
-	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
-	{
-		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
-	{
-		return detail::compute_abs_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// sign
-	// fast and works for any type
-	template <typename genFIType> 
-	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
-			"'sign' only accept signed inputs");
-		
-		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559, highp>::call(tvec1<genFIType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
-			"'sign' only accept signed inputs");
-
-		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// floor
-	using ::std::floor;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'floor' only accept floating-point inputs.");
-		return detail::compute_floor<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'trunc' only accept floating-point inputs");
-		return detail::compute_trunc<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> round(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'round' only accept floating-point inputs");
-		return detail::compute_round<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-/*
-	// roundEven
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
-
-		return genType(int(x + genType(int(x) % 2)));
-	}
-*/
-
-	// roundEven
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType roundEven(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'roundEven' only accept floating-point inputs");
-		
-		int Integer = static_cast<int>(x);
-		genType IntegerPart = static_cast<genType>(Integer);
-		genType FractionalPart = fract(x);
-
-		if(FractionalPart > static_cast<genType>(0.5) || FractionalPart < static_cast<genType>(0.5))
-		{
-			return round(x);
-		}
-		else if((Integer % 2) == 0)
-		{
-			return IntegerPart;
-		}
-		else if(x <= static_cast<genType>(0)) // Work around... 
-		{
-			return IntegerPart - static_cast<genType>(1);
-		}
-		else
-		{
-			return IntegerPart + static_cast<genType>(1);
-		}
-		//else // Bug on MinGW 4.5.2
-		//{
-		//	return mix(IntegerPart + genType(-1), IntegerPart + genType(1), x <= genType(0));
-		//}
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> roundEven(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'roundEven' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(roundEven, x);
-	}
-
-	// ceil
-	using ::std::ceil;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> ceil(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ceil' only accept floating-point inputs");
-		return detail::compute_ceil<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// fract
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fract(genType x)
-	{
-		return fract(tvec1<genType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> fract(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'fract' only accept floating-point inputs");
-		return detail::compute_fract<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// mod
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType mod(genType x, genType y)
-	{
-#		if GLM_COMPILER & GLM_COMPILER_CUDA
-			// Another Cuda compiler bug https://github.com/g-truc/glm/issues/530
-			tvec1<genType, defaultp> Result(mod(tvec1<genType, defaultp>(x), y));
-			return Result.x;
-#		else
-			return mod(tvec1<genType, defaultp>(x), y).x;
-#		endif
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, T y)
-	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(y));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, y);
-	}
-
-	// modf
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType modf(genType x, genType & i)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'modf' only accept floating-point inputs");
-		return std::modf(x, &i);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> modf(tvec1<T, P> const & x, tvec1<T, P> & i)
-	{
-		return tvec1<T, P>(
-			modf(x.x, i.x));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> modf(tvec2<T, P> const & x, tvec2<T, P> & i)
-	{
-		return tvec2<T, P>(
-			modf(x.x, i.x),
-			modf(x.y, i.y));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> modf(tvec3<T, P> const & x, tvec3<T, P> & i)
-	{
-		return tvec3<T, P>(
-			modf(x.x, i.x),
-			modf(x.y, i.y),
-			modf(x.z, i.z));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> modf(tvec4<T, P> const & x, tvec4<T, P> & i)
-	{
-		return tvec4<T, P>(
-			modf(x.x, i.x),
-			modf(x.y, i.y),
-			modf(x.z, i.z),
-			modf(x.w, i.w));
-	}
-
-	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
-	//// min(x,y)
-	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
-	//CHAR_BIT - 1)));
-	//// max(x,y)
-	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
-	//CHAR_BIT - 1)));
-
-	// min
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, T b)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'min' only accept floating-point inputs for the interpolator a");
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, vecType<T, P> const & b)
-	{
-		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
-	}
-
-	// max
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, T b)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'max' only accept floating-point inputs for the interpolator a");
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, vecType<T, P>(b));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, vecType<T, P> const & b)
-	{
-		return detail::compute_max_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
-	}
-
-	// clamp
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType clamp(genType x, genType minVal, genType maxVal)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return min(max(x, minVal), maxVal);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, vecType<T, P>(minVal), vecType<T, P>(maxVal));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer || GLM_UNRESTRICTED_GENTYPE, "'clamp' only accept floating-point or integer inputs");
-		return detail::compute_clamp_vector<T, P, vecType, detail::is_aligned<P>::value>::call(x, minVal, maxVal);
-	}
-
-	template <typename genTypeT, typename genTypeU>
-	GLM_FUNC_QUALIFIER genTypeT mix(genTypeT x, genTypeT y, genTypeU a)
-	{
-		return detail::compute_mix<genTypeT, genTypeU>::call(x, y, a);
-	}
-
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a)
-	{
-		return detail::compute_mix_scalar<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
-	}
-	
-	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
-	{
-		return detail::compute_mix_vector<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
-	}
-
-	// step
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType step(genType edge, genType x)
-	{
-		return mix(static_cast<genType>(1), static_cast<genType>(0), glm::lessThan(x, edge));
-	}
-
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> step(T edge, vecType<T, P> const & x)
-	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge), x);
-	}
-
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_QUALIFIER vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x)
-	{
-		return detail::compute_step_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge, x);
-	}
-
-	// smoothstep
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType smoothstep(genType edge0, genType edge1, genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'smoothstep' only accept floating-point inputs");
-
-		genType const tmp(clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1)));
-		return tmp * tmp * (genType(3) - genType(2) * tmp);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x)
-	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(vecType<T, P>(edge0), vecType<T, P>(edge1), x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x)
-	{
-		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge0, edge1, x);
-	}
-
-#	if GLM_HAS_CXX11_STL
-		using std::isnan;
-#	else
-		template <typename genType> 
-		GLM_FUNC_QUALIFIER bool isnan(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isnan' only accept floating-point inputs");
-
-#			if GLM_HAS_CXX11_STL
-				return std::isnan(x);
-#			elif GLM_COMPILER & GLM_COMPILER_VC
-				return _isnan(x) != 0;
-#			elif GLM_COMPILER & GLM_COMPILER_INTEL
-#				if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
-					return _isnan(x) != 0;
-#				else
-					return ::isnan(x) != 0;
-#				endif
-#			elif (GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)) && (GLM_PLATFORM & GLM_PLATFORM_ANDROID) && __cplusplus < 201103L
-				return _isnan(x) != 0;
-#			elif GLM_COMPILER & GLM_COMPILER_CUDA
-				return isnan(x) != 0;
-#			else
-				return std::isnan(x);
-#			endif
-		}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isnan(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
-
-		return detail::functor1<bool, T, P, vecType>::call(isnan, x);
-	}
-
-#	if GLM_HAS_CXX11_STL
-		using std::isinf;
-#	else
-		template <typename genType> 
-		GLM_FUNC_QUALIFIER bool isinf(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'isinf' only accept floating-point inputs");
-
-#			if GLM_HAS_CXX11_STL
-				return std::isinf(x);
-#			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
-#				if(GLM_PLATFORM & GLM_PLATFORM_WINDOWS)
-					return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-#				else
-					return ::isinf(x);
-#				endif
-#			elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
-#				if(GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L)
-					return _isinf(x) != 0;
-#				else
-					return std::isinf(x);
-#				endif
-#			elif GLM_COMPILER & GLM_COMPILER_CUDA
-				// http://developer.download.nvidia.com/compute/cuda/4_2/rel/toolkit/docs/online/group__CUDA__MATH__DOUBLE_g13431dd2b40b51f9139cbb7f50c18fab.html#g13431dd2b40b51f9139cbb7f50c18fab
-				return isinf(double(x)) != 0;
-#			else
-				return std::isinf(x);
-#			endif
-	}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> isinf(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'isnan' only accept floating-point inputs");
-
-		return detail::functor1<bool, T, P, vecType>::call(isinf, x);
-	}
-
-	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & v)
-	{
-		return reinterpret_cast<int&>(const_cast<float&>(v));
-	}
-
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<int, P> floatBitsToInt(vecType<float, P> const & v)
-	{
-		return reinterpret_cast<vecType<int, P>&>(const_cast<vecType<float, P>&>(v));
-	}
-
-	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & v)
-	{
-		return reinterpret_cast<uint&>(const_cast<float&>(v));
-	}
-
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<uint, P> floatBitsToUint(vecType<float, P> const & v)
-	{
-		return reinterpret_cast<vecType<uint, P>&>(const_cast<vecType<float, P>&>(v));
-	}
-
-	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & v)
-	{
-		return reinterpret_cast<float&>(const_cast<int&>(v));
-	}
-
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<float, P> intBitsToFloat(vecType<int, P> const & v)
-	{
-		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<int, P>&>(v));
-	}
-
-	GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & v)
-	{
-		return reinterpret_cast<float&>(const_cast<uint&>(v));
-	}
-
-	template <template <typename, precision> class vecType, precision P>
-	GLM_FUNC_QUALIFIER vecType<float, P> uintBitsToFloat(vecType<uint, P> const & v)
-	{
-		return reinterpret_cast<vecType<float, P>&>(const_cast<vecType<uint, P>&>(v));
-	}
-	
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType fma(genType const & a, genType const & b, genType const & c)
-	{
-		return a * b + c;
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType frexp(genType x, int & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
-
-		return std::frexp(x, &exp);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> frexp(tvec1<T, P> const & x, tvec1<int, P> & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
-
-		return tvec1<T, P>(std::frexp(x.x, &exp.x));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> frexp(tvec2<T, P> const & x, tvec2<int, P> & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
-
-		return tvec2<T, P>(
-			frexp(x.x, exp.x),
-			frexp(x.y, exp.y));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> frexp(tvec3<T, P> const & x, tvec3<int, P> & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
-
-		return tvec3<T, P>(
-			frexp(x.x, exp.x),
-			frexp(x.y, exp.y),
-			frexp(x.z, exp.z));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> frexp(tvec4<T, P> const & x, tvec4<int, P> & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");
-
-		return tvec4<T, P>(
-			frexp(x.x, exp.x),
-			frexp(x.y, exp.y),
-			frexp(x.z, exp.z),
-			frexp(x.w, exp.w));
-	}
-
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType ldexp(genType const & x, int const & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
-
-		return std::ldexp(x, exp);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp(tvec1<T, P> const & x, tvec1<int, P> const & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
-
-		return tvec1<T, P>(
-			ldexp(x.x, exp.x));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp(tvec2<T, P> const & x, tvec2<int, P> const & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
-
-		return tvec2<T, P>(
-			ldexp(x.x, exp.x),
-			ldexp(x.y, exp.y));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp(tvec3<T, P> const & x, tvec3<int, P> const & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
-
-		return tvec3<T, P>(
-			ldexp(x.x, exp.x),
-			ldexp(x.y, exp.y),
-			ldexp(x.z, exp.z));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp(tvec4<T, P> const & x, tvec4<int, P> const & exp)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");
-
-		return tvec4<T, P>(
-			ldexp(x.x, exp.x),
-			ldexp(x.y, exp.y),
-			ldexp(x.z, exp.z),
-			ldexp(x.w, exp.w));
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_common_simd.inl"
-#endif

common/glm/glm/detail/func_common_simd.inl

@@ -1,231 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_common_simd.inl
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-#include "../simd/common.h"
-
-#include <immintrin.h>
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_abs_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_abs_vector<int, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int, P> call(tvec4<int, P> const & v)
-		{
-			tvec4<int, P> result(uninitialize);
-			result.data = glm_ivec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_floor<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_floor(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_ceil<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_ceil(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_fract<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_fract(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_round<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_round(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_mod<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_mod(x.data, y.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_min_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_min_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_min_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_min_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v1, tvec4<float, P> const & v2)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_max_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & v1, tvec4<int32, P> const & v2)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_max_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_max_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v1, tvec4<uint32, P> const & v2)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_max_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & minVal, tvec4<float, P> const & maxVal)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<int32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<int32, P> call(tvec4<int32, P> const & x, tvec4<int32, P> const & minVal, tvec4<int32, P> const & maxVal)
-		{
-			tvec4<int32, P> result(uninitialize);
-			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_clamp_vector<uint32, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & x, tvec4<uint32, P> const & minVal, tvec4<uint32, P> const & maxVal)
-		{
-			tvec4<uint32, P> result(uninitialize);
-			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_mix_vector<float, bool, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & x, tvec4<float, P> const & y, tvec4<bool, P> const & a)
-		{
-			__m128i const Load = _mm_set_epi32(-(int)a.w, -(int)a.z, -(int)a.y, -(int)a.x);
-			__m128 const Mask = _mm_castsi128_ps(Load);
-
-			tvec4<float, P> Result(uninitialize);
-#			if 0 && GLM_ARCH & GLM_ARCH_AVX
-				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
-#			else
-				Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
-#			endif
-			return Result;
-		}
-	};
-/* FIXME
-	template <precision P>
-	struct compute_step_vector<float, P, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge, tvec4<float, P> const& x)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_step(edge.data, x.data);
-			return result;
-		}
-	};
-*/
-	template <precision P>
-	struct compute_smoothstep_vector<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& edge0, tvec4<float, P> const& edge1, tvec4<float, P> const& x)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_exponential.hpp

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

common/glm/glm/detail/func_exponential.inl

@@ -1,146 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_exponential.inl
-
-#include "func_vector_relational.hpp"
-#include "_vectorize.hpp"
-#include <limits>
-#include <cmath>
-#include <cassert>
-
-namespace glm{
-namespace detail
-{
-#	if GLM_HAS_CXX11_STL
-		using std::log2;
-#	else
-		template <typename genType>
-		genType log2(genType Value)
-		{
-			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
-		}
-#	endif
-
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat, bool Aligned>
-	struct compute_log2
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
-		{
-			return detail::functor1<T, T, P, vecType>::call(log2, vec);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_sqrt
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return detail::functor1<T, T, P, vecType>::call(std::sqrt, x);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_inversesqrt
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return static_cast<T>(1) / sqrt(x);
-		}
-	};
-		
-	template <template <class, precision> class vecType, bool Aligned>
-	struct compute_inversesqrt<vecType, float, lowp, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vecType<float, lowp> call(vecType<float, lowp> const & x)
-		{
-			vecType<float, lowp> tmp(x);
-			vecType<float, lowp> xhalf(tmp * 0.5f);
-			vecType<uint, lowp>* p = reinterpret_cast<vecType<uint, lowp>*>(const_cast<vecType<float, lowp>*>(&x));
-			vecType<uint, lowp> i = vecType<uint, lowp>(0x5f375a86) - (*p >> vecType<uint, lowp>(1));
-			vecType<float, lowp>* ptmp = reinterpret_cast<vecType<float, lowp>*>(&i);
-			tmp = *ptmp;
-			tmp = tmp * (1.5f - xhalf * tmp * tmp);
-			return tmp;
-		}
-	};
-}//namespace detail
-
-	// pow
-	using std::pow;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
-	{
-		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
-	}
-
-	// exp
-	using std::exp;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(exp, x);
-	}
-
-	// log
-	using std::log;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(log, x);
-	}
-
-	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
-
-		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(exp2, x);
-	}
-
-	// log2, ln2 = 0.69314718055994530941723212145818f
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType log2(genType x)
-	{
-		return log2(tvec1<genType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
-	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// sqrt
-	using std::sqrt;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// inversesqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
-	{
-		return static_cast<genType>(1) / sqrt(x);
-	}
-	
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_exponential_simd.inl"
-#endif
-

common/glm/glm/detail/func_exponential_simd.inl

@@ -1,35 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_exponential_simd.inl
-
-#include "../simd/exponential.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_sqrt<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = _mm_sqrt_ps(v.data);
-			return result;
-		}
-	};
-
-	template <>
-	struct compute_sqrt<tvec4, float, aligned_lowp, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, aligned_lowp> call(tvec4<float, aligned_lowp> const & v)
-		{
-			tvec4<float, aligned_lowp> result(uninitialize);
-			result.data = glm_vec4_sqrt_lowp(v.data);
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_geometric.hpp

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

common/glm/glm/detail/func_geometric.inl

@@ -1,247 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_geometric.inl
-
-#include "func_exponential.hpp"
-#include "func_common.hpp"
-#include "type_vec2.hpp"
-#include "type_vec4.hpp"
-#include "type_float.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_length
-	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & v)
-		{
-			return sqrt(dot(v, v));
-		}
-	};
-
-	template <template <typename, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_distance
-	{
-		GLM_FUNC_QUALIFIER static T call(vecType<T, P> const & p0, vecType<T, P> const & p1)
-		{
-			return length(p1 - p0);
-		}
-	};
-
-	template <template <class, precision> class vecType, typename T, precision P, bool Aligned>
-	struct compute_dot{};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec1, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
-		{
-			return a.x * b.x;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
-		{
-			tvec2<T, P> tmp(x * y);
-			return tmp.x + tmp.y;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
-		{
-			tvec3<T, P> tmp(x * y);
-			return tmp.x + tmp.y + tmp.z;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_dot<tvec4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
-		{
-			tvec4<T, P> tmp(x * y);
-			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_cross
-	{
-		GLM_FUNC_QUALIFIER static tvec3<T, P> call(tvec3<T, P> const & x, tvec3<T, P> const & y)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
-
-			return tvec3<T, P>(
-				x.y * y.z - y.y * x.z,
-				x.z * y.x - y.z * x.x,
-				x.x * y.y - y.x * x.y);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_normalize
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return v * inversesqrt(dot(v, v));
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_faceforward
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return dot(Nref, I) < static_cast<T>(0) ? N : -N;
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_reflect
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N)
-		{
-			return I - N * dot(N, I) * static_cast<T>(2);
-		}
-	};
-
-	template <typename T, precision P, template <typename, precision> class vecType, bool Aligned>
-	struct compute_refract
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
-		{
-			T const dotValue(dot(N, I));
-			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-			return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
-		}
-	};
-}//namespace detail
-
-	// length
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
-
-		return abs(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
-
-		return detail::compute_length<vecType, T, P, detail::is_aligned<P>::value>::call(v);
-	}
-
-	// distance
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
-	{
-		return detail::compute_distance<vecType, T, P, detail::is_aligned<P>::value>::call(p0, p1);
-	}
-
-	// dot
-	template <typename T>
-	GLM_FUNC_QUALIFIER T dot(T x, T y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return x * y;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return detail::compute_dot<vecType, T, P, detail::is_aligned<P>::value>::call(x, y);
-	}
-
-	// cross
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
-	{
-		return detail::compute_cross<T, P, detail::is_aligned<P>::value>::call(x, y);
-	}
-
-	// normalize
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-		return x < genType(0) ? genType(-1) : genType(1);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-		return detail::compute_normalize<T, P, vecType, detail::is_aligned<P>::value>::call(x);
-	}
-
-	// faceforward
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
-	{
-		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> faceforward(vecType<T, P> const & N, vecType<T, P> const & I, vecType<T, P> const & Nref)
-	{
-		return detail::compute_faceforward<T, P, vecType, detail::is_aligned<P>::value>::call(N, I, Nref);
-	}
-
-	// reflect
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
-	{
-		return I - N * dot(N, I) * genType(2);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> reflect(vecType<T, P> const & I, vecType<T, P> const & N)
-	{
-		return detail::compute_reflect<T, P, vecType, detail::is_aligned<P>::value>::call(I, N);
-	}
-
-	// refract
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
-		genType const dotValue(dot(N, I));
-		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
-		return detail::compute_refract<T, P, vecType, detail::is_aligned<P>::value>::call(I, N, eta);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_geometric_simd.inl"
-#endif

common/glm/glm/detail/func_geometric_simd.inl

@@ -1,99 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_geometric_simd.inl
-
-#include "../simd/geometric.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_length<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & v)
-		{
-			return _mm_cvtss_f32(glm_vec4_length(v.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_distance<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const & p0, tvec4<float, P> const & p1)
-		{
-			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_dot<tvec4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tvec4<float, P> const& x, tvec4<float, P> const& y)
-		{
-			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
-		}
-	};
-
-	template <precision P>
-	struct compute_cross<float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec3<float, P> call(tvec3<float, P> const & a, tvec3<float, P> const & b)
-		{
-			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
-			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
-			__m128 const xpd0 = glm_vec4_cross(set0, set1);
-
-			tvec4<float, P> result(uninitialize);
-			result.data = xpd0;
-			return tvec3<float, P>(result);
-		}
-	};
-
-	template <precision P>
-	struct compute_normalize<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const & v)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_normalize(v.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_faceforward<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& N, tvec4<float, P> const& I, tvec4<float, P> const& Nref)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_reflect<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_reflect(I.data, N.data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_refract<float, P, tvec4, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<float, P> call(tvec4<float, P> const& I, tvec4<float, P> const& N, float eta)
-		{
-			tvec4<float, P> result(uninitialize);
-			result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
-			return result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_integer.hpp

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

common/glm/glm/detail/func_integer.inl

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

common/glm/glm/detail/func_integer_simd.inl

@@ -1,68 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_integer_simd.inl
-
-#include "../simd/integer.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template <glm::precision P>
-	struct compute_bitfieldReverseStep<uint32, P, tvec4, true, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v, uint32 Mask, uint32 Shift)
-		{
-			__m128i const set0 = v.data;
-
-			__m128i const set1 = _mm_set1_epi32(Mask);
-			__m128i const and1 = _mm_and_si128(set0, set1);
-			__m128i const sft1 = _mm_slli_epi32(and1, Shift);
-
-			__m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1));
-			__m128i const and2 = _mm_and_si128(set0, set2);
-			__m128i const sft2 = _mm_srai_epi32(and2, Shift);
-		
-			__m128i const or0 = _mm_or_si128(sft1, sft2);
-		
-			return or0;
-		}
-	};
-
-	template <glm::precision P>
-	struct compute_bitfieldBitCountStep<uint32, P, tvec4, true, true>
-	{
-		GLM_FUNC_QUALIFIER static tvec4<uint32, P> call(tvec4<uint32, P> const & v, uint32 Mask, uint32 Shift)
-		{
-			__m128i const set0 = v.data;
-
-			__m128i const set1 = _mm_set1_epi32(Mask);
-			__m128i const and0 = _mm_and_si128(set0, set1);
-			__m128i const sft0 = _mm_slli_epi32(set0, Shift);
-			__m128i const and1 = _mm_and_si128(sft0, set1);
-			__m128i const add0 = _mm_add_epi32(and0, and1);
-		
-			return add0;
-		}
-	};
-}//namespace detail
-
-#	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template <>
-	GLM_FUNC_QUALIFIER int bitCount(uint32 x)
-	{
-		return _mm_popcnt_u32(x);
-	}
-
-#	if(GLM_MODEL == GLM_MODEL_64)
-	template <>
-	GLM_FUNC_QUALIFIER int bitCount(uint64 x)
-	{
-		return static_cast<int>(_mm_popcnt_u64(x));
-	}
-#	endif//GLM_MODEL
-#	endif//GLM_ARCH
-
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

common/glm/glm/detail/func_matrix.hpp

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

common/glm/glm/detail/func_matrix.inl

@@ -1,401 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_matrix.inl
-
-#include "../geometric.hpp"
-#include <limits>
-
-namespace glm{
-namespace detail
-{
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
-	struct compute_matrixCompMult
-	{
-		GLM_FUNC_QUALIFIER static matType<T, P> call(matType<T, P> const& x, matType<T, P> const& y)
-		{
-			matType<T, P> result(uninitialize);
-			for(length_t i = 0; i < result.length(); ++i)
-				result[i] = x[i] * y[i];
-			return result;
-		}
-	};
-
-	template <template <class, precision> class matType, typename T, precision P, bool Aligned>
-	struct compute_transpose{};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
-		{
-			tmat2x2<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
-		{
-			tmat3x2<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat2x4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
-		{
-			tmat4x2<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			result[3][0] = m[0][3];
-			result[3][1] = m[1][3];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
-		{
-			tmat2x3<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
-		{
-			tmat3x3<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			result[2][2] = m[2][2];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat3x4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
-		{
-			tmat4x3<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			result[2][2] = m[2][2];
-			result[3][0] = m[0][3];
-			result[3][1] = m[1][3];
-			result[3][2] = m[2][3];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
-		{
-			tmat2x4<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-			result[0][3] = m[3][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-			result[1][3] = m[3][1];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
-		{
-			tmat3x4<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-			result[0][3] = m[3][0];
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-			result[1][3] = m[3][1];
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			result[2][2] = m[2][2];
-			result[2][3] = m[3][2];
-			return result;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_transpose<tmat4x4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
-		{
-			tmat4x4<T, P> result(uninitialize);
-			result[0][0] = m[0][0];
-			result[0][1] = m[1][0];
-			result[0][2] = m[2][0];
-			result[0][3] = m[3][0];
-
-			result[1][0] = m[0][1];
-			result[1][1] = m[1][1];
-			result[1][2] = m[2][1];
-			result[1][3] = m[3][1];
-
-			result[2][0] = m[0][2];
-			result[2][1] = m[1][2];
-			result[2][2] = m[2][2];
-			result[2][3] = m[3][2];
-
-			result[3][0] = m[0][3];
-			result[3][1] = m[1][3];
-			result[3][2] = m[2][3];
-			result[3][3] = m[3][3];
-			return result;
-		}
-	};
-
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
-	struct compute_determinant{};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat2x2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
-		{
-			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat3x3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
-		{
-			return
-				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
-				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
-				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_determinant<tmat4x4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
-		{
-			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-			T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-			T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-
-			tvec4<T, P> DetCof(
-				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
-				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
-				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
-				- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
-
-			return
-				m[0][0] * DetCof[0] + m[0][1] * DetCof[1] +
-				m[0][2] * DetCof[2] + m[0][3] * DetCof[3];
-		}
-	};
-
-	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
-	struct compute_inverse{};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat2x2, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const& m)
-		{
-			T OneOverDeterminant = static_cast<T>(1) / (
-				+ m[0][0] * m[1][1]
-				- m[1][0] * m[0][1]);
-
-			tmat2x2<T, P> Inverse(
-				+ m[1][1] * OneOverDeterminant,
-				- m[0][1] * OneOverDeterminant,
-				- m[1][0] * OneOverDeterminant,
-				+ m[0][0] * OneOverDeterminant);
-
-			return Inverse;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat3x3, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const& m)
-		{
-			T OneOverDeterminant = static_cast<T>(1) / (
-				+ 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]));
-
-			tmat3x3<T, P> Inverse(uninitialize);
-			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
-			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
-			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
-			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
-			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
-			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
-			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
-			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
-			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
-
-			return Inverse;
-		}
-	};
-
-	template <typename T, precision P, bool Aligned>
-	struct compute_inverse<tmat4x4, T, P, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const& m)
-		{
-			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];
-
-			tvec4<T, P> Fac0(Coef00, Coef00, Coef02, Coef03);
-			tvec4<T, P> Fac1(Coef04, Coef04, Coef06, Coef07);
-			tvec4<T, P> Fac2(Coef08, Coef08, Coef10, Coef11);
-			tvec4<T, P> Fac3(Coef12, Coef12, Coef14, Coef15);
-			tvec4<T, P> Fac4(Coef16, Coef16, Coef18, Coef19);
-			tvec4<T, P> Fac5(Coef20, Coef20, Coef22, Coef23);
-
-			tvec4<T, P> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
-			tvec4<T, P> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
-			tvec4<T, P> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
-			tvec4<T, P> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
-
-			tvec4<T, P> Inv0(Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
-			tvec4<T, P> Inv1(Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
-			tvec4<T, P> Inv2(Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
-			tvec4<T, P> Inv3(Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
-
-			tvec4<T, P> SignA(+1, -1, +1, -1);
-			tvec4<T, P> SignB(-1, +1, -1, +1);
-			tmat4x4<T, P> Inverse(Inv0 * SignA, Inv1 * SignB, Inv2 * SignA, Inv3 * SignB);
-
-			tvec4<T, P> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
-
-			tvec4<T, P> Dot0(m[0] * Row0);
-			T Dot1 = (Dot0.x + Dot0.y) + (Dot0.z + Dot0.w);
-
-			T OneOverDeterminant = static_cast<T>(1) / Dot1;
-
-			return Inverse * OneOverDeterminant;
-		}
-	};
-}//namespace detail
-
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<T, P> matrixCompMult(matType<T, P> const & x, matType<T, P> const & y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'matrixCompMult' only accept floating-point inputs");
-		return detail::compute_matrixCompMult<matType, T, P, detail::is_aligned<P>::value>::call(x, y);
-	}
-
-	template<typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
-	GLM_FUNC_QUALIFIER typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'outerProduct' only accept floating-point inputs");
-
-		typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type m(uninitialize);
-		for(length_t i = 0; i < m.length(); ++i)
-			m[i] = c * r[i];
-		return m;
-	}
-
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'transpose' only accept floating-point inputs");
-		return detail::compute_transpose<matType, T, P, detail::is_aligned<P>::value>::call(m);
-	}
-
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER T determinant(matType<T, P> const & m)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'determinant' only accept floating-point inputs");
-		return detail::compute_determinant<matType, T, P, detail::is_aligned<P>::value>::call(m);
-	}
-
-	template <typename T, precision P, template <typename, precision> class matType>
-	GLM_FUNC_QUALIFIER matType<T, P> inverse(matType<T, P> const & m)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'inverse' only accept floating-point inputs");
-		return detail::compute_inverse<matType, T, P, detail::is_aligned<P>::value>::call(m);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_matrix_simd.inl"
-#endif
-

common/glm/glm/detail/func_matrix_simd.inl

@@ -1,88 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_matrix_simd.inl
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-#include "type_mat4x4.hpp"
-#include "func_geometric.hpp"
-#include "../simd/matrix.h"
-
-namespace glm{
-namespace detail
-{
-	template <precision P>
-	struct compute_matrixCompMult<tmat4x4, float, P, true>
-	{
-		GLM_STATIC_ASSERT(detail::is_aligned<P>::value, "Specialization requires aligned");
-
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const & x, tmat4x4<float, P> const & y)
-		{
-			tmat4x4<float, P> result(uninitialize);
-			glm_mat4_matrixCompMult(
-				*(glm_vec4 const (*)[4])&x[0].data,
-				*(glm_vec4 const (*)[4])&y[0].data,
-				*(glm_vec4(*)[4])&result[0].data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_transpose<tmat4x4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const & m)
-		{
-			tmat4x4<float, P> result(uninitialize);
-			glm_mat4_transpose(
-				*(glm_vec4 const (*)[4])&m[0].data,
-				*(glm_vec4(*)[4])&result[0].data);
-			return result;
-		}
-	};
-
-	template <precision P>
-	struct compute_determinant<tmat4x4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(tmat4x4<float, P> const& m)
-		{
-			return _mm_cvtss_f32(glm_mat4_determinant(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data)));
-		}
-	};
-
-	template <precision P>
-	struct compute_inverse<tmat4x4, float, P, true>
-	{
-		GLM_FUNC_QUALIFIER static tmat4x4<float, P> call(tmat4x4<float, P> const& m)
-		{
-			tmat4x4<float, P> Result(uninitialize);
-			glm_mat4_inverse(*reinterpret_cast<__m128 const(*)[4]>(&m[0].data), *reinterpret_cast<__m128(*)[4]>(&Result[0].data));
-			return Result;
-		}
-	};
-}//namespace detail
-
-	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_lowp> outerProduct<float, aligned_lowp, tvec4, tvec4>(tvec4<float, aligned_lowp> const & c, tvec4<float, aligned_lowp> const & r)
-	{
-		tmat4x4<float, aligned_lowp> m(uninitialize);
-		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
-		return m;
-	}
-
-	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_mediump> outerProduct<float, aligned_mediump, tvec4, tvec4>(tvec4<float, aligned_mediump> const & c, tvec4<float, aligned_mediump> const & r)
-	{
-		tmat4x4<float, aligned_mediump> m(uninitialize);
-		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
-		return m;
-	}
-
-	template<>
-	GLM_FUNC_QUALIFIER tmat4x4<float, aligned_highp> outerProduct<float, aligned_highp, tvec4, tvec4>(tvec4<float, aligned_highp> const & c, tvec4<float, aligned_highp> const & r)
-	{
-		tmat4x4<float, aligned_highp> m(uninitialize);
-		glm_mat4_outerProduct(c.data, r.data, *reinterpret_cast<__m128(*)[4]>(&m[0].data));
-		return m;
-	}
-}//namespace glm
-
-#endif

common/glm/glm/detail/func_packing.hpp

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

common/glm/glm/detail/func_packing.inl

@@ -1,190 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_packing.inl
-
-#include "func_common.hpp"
-#include "type_half.hpp"
-#include "../fwd.hpp"
-
-namespace glm
-{
-	GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const & v)
-	{
-		union
-		{
-			u16  in[2];
-			uint out;
-		} u;
-
-		u16vec2 result(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
-
-		u.in[0] = result[0];
-		u.in[1] = result[1];
-
-		return u.out;
-	}
-
-	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
-	{
-		union
-		{
-			uint in;
-			u16  out[2];
-		} u;
-
-		u.in = p;
-
-		return vec2(u.out[0], u.out[1]) * 1.5259021896696421759365224689097e-5f;
-	}
-
-	GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const & v)
-	{
-		union
-		{
-			i16  in[2];
-			uint out;
-		} u;
-
-		i16vec2 result(round(clamp(v, -1.0f, 1.0f) * 32767.0f));
-
-		u.in[0] = result[0];
-		u.in[1] = result[1];
-
-		return u.out;
-	}
-
-	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
-	{
-		union
-		{
-			uint in;
-			i16  out[2];
-		} u;
-
-		u.in = p;
-
-		return clamp(vec2(u.out[0], u.out[1]) * 3.0518509475997192297128208258309e-5f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER uint packUnorm4x8(vec4 const & v)
-	{
-		union
-		{
-			u8   in[4];
-			uint out;
-		} u;
-
-		u8vec4 result(round(clamp(v, 0.0f, 1.0f) * 255.0f));
-
-		u.in[0] = result[0];
-		u.in[1] = result[1];
-		u.in[2] = result[2];
-		u.in[3] = result[3];
-
-		return u.out;
-	}
-
-	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
-	{
-		union
-		{
-			uint in;
-			u8   out[4];
-		} u;
-
-		u.in = p;
-
-		return vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0039215686274509803921568627451f;
-	}
-	
-	GLM_FUNC_QUALIFIER uint packSnorm4x8(vec4 const & v)
-	{
-		union
-		{
-			i8   in[4];
-			uint out;
-		} u;
-
-		i8vec4 result(round(clamp(v, -1.0f, 1.0f) * 127.0f));
-
-		u.in[0] = result[0];
-		u.in[1] = result[1];
-		u.in[2] = result[2];
-		u.in[3] = result[3];
-
-		return u.out;
-	}
-	
-	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
-	{
-		union
-		{
-			uint in;
-			i8   out[4];
-		} u;
-
-		u.in = p;
-
-		return clamp(vec4(u.out[0], u.out[1], u.out[2], u.out[3]) * 0.0078740157480315f, -1.0f, 1.0f);
-	}
-
-	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const & v)
-	{
-		union
-		{
-			uint   in[2];
-			double out;
-		} u;
-
-		u.in[0] = v[0];
-		u.in[1] = v[1];
-
-		return u.out;
-	}
-
-	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
-	{
-		union
-		{
-			double in;
-			uint   out[2];
-		} u;
-
-		u.in = v;
-
-		return uvec2(u.out[0], u.out[1]);
-	}
-
-	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
-	{
-		union
-		{
-			i16  in[2];
-			uint out;
-		} u;
-
-		u.in[0] = detail::toFloat16(v.x);
-		u.in[1] = detail::toFloat16(v.y);
-
-		return u.out;
-	}
-
-	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
-	{
-		union
-		{
-			uint in;
-			i16  out[2];
-		} u;
-
-		u.in = v;
-
-		return vec2(
-			detail::toFloat32(u.out[0]),
-			detail::toFloat32(u.out[1]));
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_packing_simd.inl"
-#endif
-

common/glm/glm/detail/func_packing_simd.inl

@@ -1,9 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_packing_simd.inl
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm

common/glm/glm/detail/func_trigonometric.hpp

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

common/glm/glm/detail/func_trigonometric.inl

@@ -1,200 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_trigonometric.inl
-
-#include "_vectorize.hpp"
-#include <cmath>
-#include <limits>
-
-namespace glm
-{
-	// radians
-	template <typename genType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");
-
-		return degrees * static_cast<genType>(0.01745329251994329576923690768489);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> radians(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(radians, v);
-	}
-	
-	// degrees
-	template <typename genType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");
-
-		return radians * static_cast<genType>(57.295779513082320876798154814105);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> degrees(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(degrees, v);
-	}
-
-	// sin
-	using ::std::sin;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sin(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(sin, v);
-	}
-
-	// cos
-	using std::cos;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cos(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(cos, v);
-	}
-
-	// tan
-	using std::tan;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tan(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(tan, v);
-	}
-
-	// asin
-	using std::asin;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asin(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(asin, v);
-	}
-
-	// acos
-	using std::acos;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acos(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(acos, v);
-	}
-
-	// atan
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");
-
-		return ::std::atan2(y, x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & a, vecType<T, P> const & b)
-	{
-		return detail::functor2<T, P, vecType>::call(::std::atan2, a, b);
-	}
-
-	using std::atan;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(atan, v);
-	}
-
-	// sinh
-	using std::sinh;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sinh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(sinh, v);
-	}
-
-	// cosh
-	using std::cosh;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> cosh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(cosh, v);
-	}
-
-	// tanh
-	using std::tanh;
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> tanh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(tanh, v);
-	}
-
-	// asinh
-#	if GLM_HAS_CXX11_STL
-		using std::asinh;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType asinh(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'asinh' only accept floating-point input");
-
-			return (x < static_cast<genType>(0) ? static_cast<genType>(-1) : (x > static_cast<genType>(0) ? static_cast<genType>(1) : static_cast<genType>(0))) * log(std::abs(x) + sqrt(static_cast<genType>(1) + x * x));
-		}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> asinh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(asinh, v);
-	}
-
-	// acosh
-#	if GLM_HAS_CXX11_STL
-		using std::acosh;
-#	else
-		template <typename genType> 
-		GLM_FUNC_QUALIFIER genType acosh(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");
-
-			if(x < static_cast<genType>(1))
-				return static_cast<genType>(0);
-			return log(x + sqrt(x * x - static_cast<genType>(1)));
-		}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> acosh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(acosh, v);
-	}
-
-	// atanh
-#	if GLM_HAS_CXX11_STL
-		using std::atanh;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType atanh(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
-		
-			if(std::abs(x) >= static_cast<genType>(1))
-				return 0;
-			return static_cast<genType>(0.5) * log((static_cast<genType>(1) + x) / (static_cast<genType>(1) - x));
-		}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> atanh(vecType<T, P> const & v)
-	{
-		return detail::functor1<T, T, P, vecType>::call(atanh, v);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_trigonometric_simd.inl"
-#endif
-

common/glm/glm/detail/func_vector_relational.hpp

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

common/glm/glm/detail/func_vector_relational.inl

@@ -1,105 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_vector_relational.inl
-
-#include <limits>
-
-namespace glm
-{
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] < y[i];
-
-		return Result;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] <= y[i];
-		return Result;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] > y[i];
-		return Result;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] >= y[i];
-		return Result;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] == y[i];
-		return Result;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	{
-		assert(x.length() == y.length());
-
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < x.length(); ++i)
-			Result[i] = x[i] != y[i];
-		return Result;
-	}
-
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
-	{
-		bool Result = false;
-		for(length_t i = 0; i < v.length(); ++i)
-			Result = Result || v[i];
-		return Result;
-	}
-
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
-	{
-		bool Result = true;
-		for(length_t i = 0; i < v.length(); ++i)
-			Result = Result && v[i];
-		return Result;
-	}
-
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
-	{
-		vecType<bool, P> Result(uninitialize);
-		for(length_t i = 0; i < v.length(); ++i)
-			Result[i] = !v[i];
-		return Result;
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_vector_relational_simd.inl"
-#endif

common/glm/glm/detail/func_vector_relational_simd.inl

@@ -1,9 +0,0 @@
-/// @ref core
-/// @file glm/detail/func_vector_relational_simd.inl
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm

common/glm/glm/detail/glm.cpp

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

common/glm/glm/detail/precision.hpp

@@ -1,63 +0,0 @@
-/// @ref core
-/// @file glm/detail/precision.hpp
-
-#pragma once
-
-#include "setup.hpp"
-
-namespace glm
-{
-	enum precision
-	{
-		packed_highp,
-		packed_mediump,
-		packed_lowp,
-
-#		if GLM_HAS_ALIGNED_TYPE
-			aligned_highp,
-			aligned_mediump,
-			aligned_lowp,
-			aligned = aligned_highp,
-#		endif
-
-		highp = packed_highp,
-		mediump = packed_mediump,
-		lowp = packed_lowp,
-		packed = packed_highp,
-
-#		if GLM_HAS_ALIGNED_TYPE && defined(GLM_FORCE_ALIGNED)
-			defaultp = aligned_highp
-#		else
-			defaultp = highp
-#		endif
-	};
-	
-namespace detail
-{
-	template <glm::precision P>
-	struct is_aligned
-	{
-		static const bool value = false;
-	};
-
-#	if GLM_HAS_ALIGNED_TYPE
-		template<>
-		struct is_aligned<glm::aligned_lowp>
-		{
-			static const bool value = true;
-		};
-
-		template<>
-		struct is_aligned<glm::aligned_mediump>
-		{
-			static const bool value = true;
-		};
-
-		template<>
-		struct is_aligned<glm::aligned_highp>
-		{
-			static const bool value = true;
-		};
-#	endif
-}//namespace detail
-}//namespace glm

common/glm/glm/detail/setup.hpp

@@ -1,828 +0,0 @@
-/// @ref core
-/// @file glm/detail/setup.hpp
-
-#pragma once
-
-#if (defined(GLM_FORCE_SWIZZLE) || defined(GLM_SWIZZLE)) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
-#	error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time"
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////
-// Messages
-
-#ifdef GLM_MESSAGES
-#	pragma message("GLM: GLM_MESSAGES is deprecated, use GLM_FORCE_MESSAGES instead")
-#endif
-
-#define GLM_MESSAGES_ENABLED 1
-#define GLM_MESSAGES_DISABLE 0
-
-#if defined(GLM_FORCE_MESSAGES) || defined(GLM_MESSAGES)
-#	undef GLM_MESSAGES
-#	define GLM_MESSAGES GLM_MESSAGES_ENABLED
-#else
-#	undef GLM_MESSAGES
-#	define GLM_MESSAGES GLM_MESSAGES_DISABLE
-#endif
-
-#include <cassert>
-#include <cstddef>
-#include "../simd/platform.h"
-
-///////////////////////////////////////////////////////////////////////////////////
-// Version
-
-#define GLM_VERSION					98
-#define GLM_VERSION_MAJOR			0
-#define GLM_VERSION_MINOR			9
-#define GLM_VERSION_PATCH			8
-#define GLM_VERSION_REVISION		4
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_VERSION_DISPLAYED)
-#	define GLM_MESSAGE_VERSION_DISPLAYED
-#	pragma message ("GLM: version 0.9.8.4")
-#endif//GLM_MESSAGES
-
-// Report compiler detection
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !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_INTEL
-#		pragma message("GLM: Intel Compiler detected")
-#	elif GLM_COMPILER & GLM_COMPILER_GCC
-#		pragma message("GLM: GCC compiler detected")
-#	else
-#		pragma message("GLM: Compiler not detected")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Build model
-
-#if defined(__arch64__) || defined(__LP64__) || defined(_M_X64) || defined(__ppc64__) || defined(__x86_64__)
-#	define GLM_MODEL	GLM_MODEL_64
-#elif defined(__i386__) || defined(__ppc__)
-#	define GLM_MODEL	GLM_MODEL_32
-#else
-#	define GLM_MODEL	GLM_MODEL_32
-#endif//
-
-#if !defined(GLM_MODEL) && GLM_COMPILER != 0
-#	error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
-#endif//GLM_MODEL
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !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_MESSAGES
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
-#	define GLM_MESSAGE_ARCH_DISPLAYED
-#	if(GLM_ARCH == GLM_ARCH_PURE)
-#		pragma message("GLM: Platform independent code")
-#	elif(GLM_ARCH == GLM_ARCH_AVX2)
-#		pragma message("GLM: AVX2 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_AVX)
-#		pragma message("GLM: AVX instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE42)
-#		pragma message("GLM: SSE4.2 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE41)
-#		pragma message("GLM: SSE4.1 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSSE3)
-#		pragma message("GLM: SSSE3 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE3)
-#		pragma message("GLM: SSE3 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_SSE2)
-#		pragma message("GLM: SSE2 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_X86)
-#		pragma message("GLM: x86 instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_NEON)
-#		pragma message("GLM: NEON instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_ARM)
-#		pragma message("GLM: ARM instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_MIPS)
-#		pragma message("GLM: MIPS instruction set")
-#	elif(GLM_ARCH == GLM_ARCH_PPC)
-#		pragma message("GLM: PowerPC architechture")
-#	endif//GLM_ARCH
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// C++ Version
-
-// User defines: GLM_FORCE_CXX98, GLM_FORCE_CXX03, GLM_FORCE_CXX11, GLM_FORCE_CXX14
-
-#define GLM_LANG_CXX98_FLAG			(1 << 1)
-#define GLM_LANG_CXX03_FLAG			(1 << 2)
-#define GLM_LANG_CXX0X_FLAG			(1 << 3)
-#define GLM_LANG_CXX11_FLAG			(1 << 4)
-#define GLM_LANG_CXX1Y_FLAG			(1 << 5)
-#define GLM_LANG_CXX14_FLAG			(1 << 6)
-#define GLM_LANG_CXX1Z_FLAG			(1 << 7)
-#define GLM_LANG_CXXMS_FLAG			(1 << 8)
-#define GLM_LANG_CXXGNU_FLAG		(1 << 9)
-
-#define GLM_LANG_CXX98			GLM_LANG_CXX98_FLAG
-#define GLM_LANG_CXX03			(GLM_LANG_CXX98 | GLM_LANG_CXX03_FLAG)
-#define GLM_LANG_CXX0X			(GLM_LANG_CXX03 | GLM_LANG_CXX0X_FLAG)
-#define GLM_LANG_CXX11			(GLM_LANG_CXX0X | GLM_LANG_CXX11_FLAG)
-#define GLM_LANG_CXX1Y			(GLM_LANG_CXX11 | GLM_LANG_CXX1Y_FLAG)
-#define GLM_LANG_CXX14			(GLM_LANG_CXX1Y | GLM_LANG_CXX14_FLAG)
-#define GLM_LANG_CXX1Z			(GLM_LANG_CXX14 | GLM_LANG_CXX1Z_FLAG)
-#define GLM_LANG_CXXMS			GLM_LANG_CXXMS_FLAG
-#define GLM_LANG_CXXGNU			GLM_LANG_CXXGNU_FLAG
-
-#if defined(GLM_FORCE_CXX14)
-#	if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC50)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG34))
-#			pragma message("GLM: Using GLM_FORCE_CXX14 with a compiler that doesn't fully support C++14")
-#	elif GLM_COMPILER & GLM_COMPILER_VC
-#			pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of Visual C++ compiler that fully supports C++14")
-#	elif GLM_COMPILER & GLM_COMPILER_INTEL
-#			pragma message("GLM: Using GLM_FORCE_CXX14 but there is no known version of ICC compiler that fully supports C++14")
-#	endif
-#	define GLM_LANG GLM_LANG_CXX14
-#	define GLM_LANG_STL11_FORCED
-#elif defined(GLM_FORCE_CXX11)
-#	if((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER <= GLM_COMPILER_GCC48)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER <= GLM_COMPILER_CLANG33))
-#			pragma message("GLM: Using GLM_FORCE_CXX11 with a compiler that doesn't fully support C++11")
-#	elif GLM_COMPILER & GLM_COMPILER_VC
-#			pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of Visual C++ compiler that fully supports C++11")
-#	elif GLM_COMPILER & GLM_COMPILER_INTEL
-#			pragma message("GLM: Using GLM_FORCE_CXX11 but there is no known version of ICC compiler that fully supports C++11")
-#	endif
-#	define GLM_LANG GLM_LANG_CXX11
-#	define GLM_LANG_STL11_FORCED
-#elif defined(GLM_FORCE_CXX03)
-#	define GLM_LANG GLM_LANG_CXX03
-#elif defined(GLM_FORCE_CXX98)
-#	define GLM_LANG GLM_LANG_CXX98
-#else
-#	if GLM_COMPILER & GLM_COMPILER_CLANG
-#		if __cplusplus >= 201402L // GLM_COMPILER_CLANG34 + -std=c++14
-#			define GLM_LANG GLM_LANG_CXX14
-#		elif __has_feature(cxx_decltype_auto) && __has_feature(cxx_aggregate_nsdmi) // GLM_COMPILER_CLANG33 + -std=c++1y
-#			define GLM_LANG GLM_LANG_CXX1Y
-#		elif __cplusplus >= 201103L // GLM_COMPILER_CLANG33 + -std=c++11
-#			define GLM_LANG GLM_LANG_CXX11
-#		elif __has_feature(cxx_static_assert) // GLM_COMPILER_CLANG29 + -std=c++11
-#			define GLM_LANG GLM_LANG_CXX0X
-#		elif __cplusplus >= 199711L
-#			define GLM_LANG GLM_LANG_CXX98
-#		else
-#			define GLM_LANG GLM_LANG_CXX
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_GCC
-#		if __cplusplus >= 201402L
-#			define GLM_LANG GLM_LANG_CXX14
-#		elif __cplusplus >= 201103L
-#			define GLM_LANG GLM_LANG_CXX11
-#		elif defined(__GXX_EXPERIMENTAL_CXX0X__)
-#			define GLM_LANG GLM_LANG_CXX0X
-#		else
-#			define GLM_LANG GLM_LANG_CXX98
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_VC
-#		ifdef _MSC_EXTENSIONS
-#			if __cplusplus >= 201402L
-#				define GLM_LANG (GLM_LANG_CXX14 | GLM_LANG_CXXMS_FLAG)
-//#			elif GLM_COMPILER >= GLM_COMPILER_VC14
-//#				define GLM_LANG (GLM_LANG_CXX1Y | GLM_LANG_CXXMS_FLAG)
-#			elif __cplusplus >= 201103L
-#				define GLM_LANG (GLM_LANG_CXX11 | GLM_LANG_CXXMS_FLAG)
-#			elif GLM_COMPILER >= GLM_COMPILER_VC10
-#				define GLM_LANG (GLM_LANG_CXX0X | GLM_LANG_CXXMS_FLAG)
-#			elif __cplusplus >= 199711L
-#				define GLM_LANG (GLM_LANG_CXX98 | GLM_LANG_CXXMS_FLAG)
-#			else
-#				define GLM_LANG (GLM_LANG_CXX | GLM_LANG_CXXMS_FLAG)
-#			endif
-#		else
-#			if __cplusplus >= 201402L
-#				define GLM_LANG GLM_LANG_CXX14
-#			elif __cplusplus >= 201103L
-#				define GLM_LANG GLM_LANG_CXX11
-#			elif GLM_COMPILER >= GLM_COMPILER_VC10
-#				define GLM_LANG GLM_LANG_CXX0X
-#			elif __cplusplus >= 199711L
-#				define GLM_LANG GLM_LANG_CXX98
-#			else
-#				define GLM_LANG GLM_LANG_CXX
-#			endif
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_INTEL
-#		ifdef _MSC_EXTENSIONS
-#			define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG
-#		else
-#			define GLM_MSC_EXT 0
-#		endif
-#		if __cplusplus >= 201402L
-#			define GLM_LANG (GLM_LANG_CXX14 | GLM_MSC_EXT)
-#		elif __cplusplus >= 201103L
-#			define GLM_LANG (GLM_LANG_CXX11 | GLM_MSC_EXT)
-#		elif __INTEL_CXX11_MODE__
-#			define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT)
-#		elif __cplusplus >= 199711L
-#			define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT)
-#		else
-#			define GLM_LANG (GLM_LANG_CXX | GLM_MSC_EXT)
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_CUDA
-#		ifdef _MSC_EXTENSIONS
-#			define GLM_MSC_EXT GLM_LANG_CXXMS_FLAG
-#		else
-#			define GLM_MSC_EXT 0
-#		endif
-#		if GLM_COMPILER >= GLM_COMPILER_CUDA75
-#			define GLM_LANG (GLM_LANG_CXX0X | GLM_MSC_EXT)
-#		else
-#			define GLM_LANG (GLM_LANG_CXX98 | GLM_MSC_EXT)
-#		endif
-#	else // Unknown compiler
-#		if __cplusplus >= 201402L
-#			define GLM_LANG GLM_LANG_CXX14
-#		elif __cplusplus >= 201103L
-#			define GLM_LANG GLM_LANG_CXX11
-#		elif __cplusplus >= 199711L
-#			define GLM_LANG GLM_LANG_CXX98
-#		else
-#			define GLM_LANG GLM_LANG_CXX // Good luck with that!
-#		endif
-#		ifndef GLM_FORCE_PURE
-#			define GLM_FORCE_PURE
-#		endif
-#	endif
-#endif
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_LANG_DISPLAYED)
-#	define GLM_MESSAGE_LANG_DISPLAYED
-
-#	if GLM_LANG & GLM_LANG_CXX1Z_FLAG
-#		pragma message("GLM: C++1z")
-#	elif GLM_LANG & GLM_LANG_CXX14_FLAG
-#		pragma message("GLM: C++14")
-#	elif GLM_LANG & GLM_LANG_CXX1Y_FLAG
-#		pragma message("GLM: C++1y")
-#	elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#		pragma message("GLM: C++11")
-#	elif GLM_LANG & GLM_LANG_CXX0X_FLAG
-#		pragma message("GLM: C++0x")
-#	elif GLM_LANG & GLM_LANG_CXX03_FLAG
-#		pragma message("GLM: C++03")
-#	elif GLM_LANG & GLM_LANG_CXX98_FLAG
-#		pragma message("GLM: C++98")
-#	else
-#		pragma message("GLM: C++ language undetected")
-#	endif//GLM_LANG
-
-#	if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG)
-#		pragma message("GLM: Language extensions enabled")
-#	endif//GLM_LANG
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Has of C++ features
-
-// http://clang.llvm.org/cxx_status.html
-// http://gcc.gnu.org/projects/cxx0x.html
-// http://msdn.microsoft.com/en-us/library/vstudio/hh567368(v=vs.120).aspx
-
-// Android has multiple STLs but C++11 STL detection doesn't always work #284 #564
-#if GLM_PLATFORM == GLM_PLATFORM_ANDROID && !defined(GLM_LANG_STL11_FORCED)
-#	define GLM_HAS_CXX11_STL 0
-#elif GLM_COMPILER & GLM_COMPILER_CLANG
-#	if (defined(_LIBCPP_VERSION) && GLM_LANG & GLM_LANG_CXX11_FLAG) || defined(GLM_LANG_STL11_FORCED)
-#		define GLM_HAS_CXX11_STL 1
-#	else
-#		define GLM_HAS_CXX11_STL 0
-#	endif
-#else
-#	define GLM_HAS_CXX11_STL ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_PLATFORM != GLM_PLATFORM_WINDOWS) && (GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15))))
-#endif
-
-// N1720
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_STATIC_ASSERT __has_feature(cxx_static_assert)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_STATIC_ASSERT 1
-#else
-#	define GLM_HAS_STATIC_ASSERT ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC))))
-#endif
-
-// N1988
-#if GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_EXTENDED_INTEGER_TYPE 1
-#else
-#	define GLM_HAS_EXTENDED_INTEGER_TYPE (\
-		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
-		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CUDA)) || \
-		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_GCC)) || \
-		((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (GLM_COMPILER & GLM_COMPILER_CLANG)))
-#endif
-
-// N2235
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_CONSTEXPR __has_feature(cxx_constexpr)
-#	define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_CONSTEXPR 1
-#	define GLM_HAS_CONSTEXPR_PARTIAL GLM_HAS_CONSTEXPR
-#else
-#	define GLM_HAS_CONSTEXPR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)))) // GCC 4.6 support constexpr but there is a compiler bug causing a crash
-#	define GLM_HAS_CONSTEXPR_PARTIAL (GLM_HAS_CONSTEXPR || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)))
-#endif
-
-// N2672
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_INITIALIZER_LISTS __has_feature(cxx_generalized_initializers)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_INITIALIZER_LISTS 1
-#else
-#	define GLM_HAS_INITIALIZER_LISTS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75))))
-#endif
-
-// N2544 Unrestricted unions http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_UNRESTRICTED_UNIONS __has_feature(cxx_unrestricted_unions)
-#elif GLM_LANG & (GLM_LANG_CXX11_FLAG | GLM_LANG_CXXMS_FLAG)
-#	define GLM_HAS_UNRESTRICTED_UNIONS 1
-#else
-#	define GLM_HAS_UNRESTRICTED_UNIONS (GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA75)) || \
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)))
-#endif
-
-// N2346
-#if defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
-#	define GLM_HAS_DEFAULTED_FUNCTIONS 0
-#elif GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_DEFAULTED_FUNCTIONS __has_feature(cxx_defaulted_functions)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_DEFAULTED_FUNCTIONS 1
-#else
-#	define GLM_HAS_DEFAULTED_FUNCTIONS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12)) || \
-		(GLM_COMPILER & GLM_COMPILER_CUDA)))
-#endif
-
-// N2118
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_RVALUE_REFERENCES __has_feature(cxx_rvalue_references)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_RVALUE_REFERENCES 1
-#else
-#	define GLM_HAS_RVALUE_REFERENCES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
-#endif
-
-// N2437 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS __has_feature(cxx_explicit_conversions)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS 1
-#else
-#	define GLM_HAS_EXPLICIT_CONVERSION_OPERATORS ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC45)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL14)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
-#endif
-
-// N2258 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_TEMPLATE_ALIASES __has_feature(cxx_alias_templates)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_TEMPLATE_ALIASES 1
-#else
-#	define GLM_HAS_TEMPLATE_ALIASES ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL12_1)) || \
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC47)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
-#endif
-
-// N2930 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_RANGE_FOR __has_feature(cxx_range_for)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_RANGE_FOR 1
-#else
-#	define GLM_HAS_RANGE_FOR ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC46)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL13)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
-#endif
-
-// N2341 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf
-#if GLM_COMPILER & GLM_COMPILER_CLANG
-#	define GLM_HAS_ALIGNOF __has_feature(c_alignof)
-#elif GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_ALIGNOF 1
-#else
-#	define GLM_HAS_ALIGNOF ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC48)) || \
-		((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_COMPILER >= GLM_COMPILER_INTEL15)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA70))))
-#endif
-
-#define GLM_HAS_ONLY_XYZW ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER < GLM_COMPILER_GCC46))
-#if GLM_HAS_ONLY_XYZW
-#	pragma message("GLM: GCC older than 4.6 has a bug presenting the use of rgba and stpq components")
-#endif
-
-//
-#if GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_ASSIGNABLE 1
-#else
-#	define GLM_HAS_ASSIGNABLE ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || \
-		((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49))))
-#endif
-
-//
-#define GLM_HAS_TRIVIAL_QUERIES 0
-
-//
-#if GLM_LANG & GLM_LANG_CXX11_FLAG
-#	define GLM_HAS_MAKE_SIGNED 1
-#else
-#	define GLM_HAS_MAKE_SIGNED ((GLM_LANG & GLM_LANG_CXX0X_FLAG) && (\
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC12)) || \
-		((GLM_COMPILER & GLM_COMPILER_CUDA) && (GLM_COMPILER >= GLM_COMPILER_CUDA50))))
-#endif
-
-#if GLM_ARCH == GLM_ARCH_PURE
-#	define GLM_HAS_BITSCAN_WINDOWS 0
-#else
-#	define GLM_HAS_BITSCAN_WINDOWS ((GLM_PLATFORM & GLM_PLATFORM_WINDOWS) && (\
-		((GLM_COMPILER & GLM_COMPILER_INTEL)) || \
-		((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT))))
-#endif
-
-// OpenMP
-#ifdef _OPENMP
-#	if GLM_COMPILER & GLM_COMPILER_GCC
-#		if GLM_COMPILER >= GLM_COMPILER_GCC61
-#			define GLM_HAS_OPENMP 45
-#		elif GLM_COMPILER >= GLM_COMPILER_GCC49
-#			define GLM_HAS_OPENMP 40
-#		elif GLM_COMPILER >= GLM_COMPILER_GCC47
-#			define GLM_HAS_OPENMP 31
-#		elif GLM_COMPILER >= GLM_COMPILER_GCC44
-#			define GLM_HAS_OPENMP 30
-#		elif GLM_COMPILER >= GLM_COMPILER_GCC42
-#			define GLM_HAS_OPENMP 25
-#		else
-#			define GLM_HAS_OPENMP 0
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_CLANG
-#		if GLM_COMPILER >= GLM_COMPILER_CLANG38
-#			define GLM_HAS_OPENMP 31
-#		else
-#			define GLM_HAS_OPENMP 0
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_VC
-#		if GLM_COMPILER >= GLM_COMPILER_VC10
-#			define GLM_HAS_OPENMP 20
-#		else
-#			define GLM_HAS_OPENMP 0
-#		endif
-#	elif GLM_COMPILER & GLM_COMPILER_INTEL
-#		if GLM_COMPILER >= GLM_COMPILER_INTEL16
-#			define GLM_HAS_OPENMP 40
-#		elif GLM_COMPILER >= GLM_COMPILER_INTEL12
-#			define GLM_HAS_OPENMP 31
-#		else
-#			define GLM_HAS_OPENMP 0
-#		endif
-#	else
-#		define GLM_HAS_OPENMP 0
-#	endif// GLM_COMPILER & GLM_COMPILER_VC
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////
-// Static assert
-
-#if GLM_HAS_STATIC_ASSERT
-#	define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
-#elif defined(BOOST_STATIC_ASSERT)
-#	define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
-#elif GLM_COMPILER & GLM_COMPILER_VC
-#	define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
-#else
-#	define GLM_STATIC_ASSERT(x, message)
-#	define GLM_STATIC_ASSERT_NULL
-#endif//GLM_LANG
-
-///////////////////////////////////////////////////////////////////////////////////
-// Qualifiers
-
-#if GLM_COMPILER & GLM_COMPILER_CUDA
-#	define GLM_CUDA_FUNC_DEF __device__ __host__
-#	define GLM_CUDA_FUNC_DECL __device__ __host__
-#else
-#	define GLM_CUDA_FUNC_DEF
-#	define GLM_CUDA_FUNC_DECL
-#endif
-
-#if GLM_COMPILER & GLM_COMPILER_GCC
-#	define GLM_VAR_USED __attribute__ ((unused))
-#else
-#	define GLM_VAR_USED
-#endif
-
-#if defined(GLM_FORCE_INLINE)
-#	if GLM_COMPILER & GLM_COMPILER_VC
-#		define GLM_INLINE __forceinline
-#		define GLM_NEVER_INLINE __declspec((noinline))
-#	elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG)
-#		define GLM_INLINE inline __attribute__((__always_inline__))
-#		define GLM_NEVER_INLINE __attribute__((__noinline__))
-#	elif GLM_COMPILER & GLM_COMPILER_CUDA
-#		define GLM_INLINE __forceinline__
-#		define GLM_NEVER_INLINE __noinline__
-#	else
-#		define GLM_INLINE inline
-#		define GLM_NEVER_INLINE
-#	endif//GLM_COMPILER
-#else
-#	define GLM_INLINE inline
-#	define GLM_NEVER_INLINE
-#endif//defined(GLM_FORCE_INLINE)
-
-#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
-#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
-
-///////////////////////////////////////////////////////////////////////////////////
-// Swizzle operators
-
-// User defines: GLM_FORCE_SWIZZLE
-
-#ifdef GLM_SWIZZLE
-#	pragma message("GLM: GLM_SWIZZLE is deprecated, use GLM_FORCE_SWIZZLE instead")
-#endif
-
-#define GLM_SWIZZLE_ENABLED 1
-#define GLM_SWIZZLE_DISABLE 0
-
-#if defined(GLM_FORCE_SWIZZLE) || defined(GLM_SWIZZLE)
-#	undef GLM_SWIZZLE
-#	define GLM_SWIZZLE GLM_SWIZZLE_ENABLED
-#else
-#	undef GLM_SWIZZLE
-#	define GLM_SWIZZLE GLM_SWIZZLE_DISABLE
-#endif
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
-#	define GLM_MESSAGE_SWIZZLE_DISPLAYED
-#	if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
-#		pragma message("GLM: Swizzling operators enabled")
-#	else
-#		pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Allows using not basic types as genType
-
-// #define GLM_FORCE_UNRESTRICTED_GENTYPE
-
-#ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
-#	define GLM_UNRESTRICTED_GENTYPE 1
-#else
-#	define GLM_UNRESTRICTED_GENTYPE 0
-#endif
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED)
-#	define GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED
-#	ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
-#		pragma message("GLM: Use unrestricted genType")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Clip control
-
-#ifdef GLM_DEPTH_ZERO_TO_ONE // Legacy 0.9.8 development
-#	error Define GLM_FORCE_DEPTH_ZERO_TO_ONE instead of GLM_DEPTH_ZERO_TO_ONE to use 0 to 1 clip space.
-#endif
-
-#define GLM_DEPTH_ZERO_TO_ONE				0x00000001
-#define GLM_DEPTH_NEGATIVE_ONE_TO_ONE		0x00000002
-
-#ifdef GLM_FORCE_DEPTH_ZERO_TO_ONE
-#	define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_ZERO_TO_ONE
-#else
-#	define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE
-#endif
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_DEPTH_DISPLAYED)
-#	define GLM_MESSAGE_DEPTH_DISPLAYED
-#	if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-#		pragma message("GLM: Depth clip space: Zero to one")
-#	else
-#		pragma message("GLM: Depth clip space: negative one to one")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
-// to use left handed coordinate system by default.
-
-#ifdef GLM_LEFT_HANDED // Legacy 0.9.8 development
-#	error Define GLM_FORCE_LEFT_HANDED instead of GLM_LEFT_HANDED left handed coordinate system by default.
-#endif
-
-#define GLM_LEFT_HANDED				0x00000001	// For DirectX, Metal, Vulkan
-#define GLM_RIGHT_HANDED			0x00000002	// For OpenGL, default in GLM
-
-#ifdef GLM_FORCE_LEFT_HANDED
-#	define GLM_COORDINATE_SYSTEM GLM_LEFT_HANDED
-#else
-#	define GLM_COORDINATE_SYSTEM GLM_RIGHT_HANDED
-#endif
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_HANDED_DISPLAYED)
-#	define GLM_MESSAGE_HANDED_DISPLAYED
-#	if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
-#		pragma message("GLM: Coordinate system: left handed")
-#	else
-#		pragma message("GLM: Coordinate system: right handed")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// Qualifiers
-
-#if (GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS))
-#	define GLM_DEPRECATED __declspec(deprecated)
-#	define GLM_ALIGN(x) __declspec(align(x))
-#	define GLM_ALIGNED_STRUCT(x) struct __declspec(align(x))
-#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef __declspec(align(alignment)) type name
-#	define GLM_RESTRICT_FUNC __declspec(restrict)
-#	define GLM_RESTRICT __restrict
-#	if GLM_COMPILER >= GLM_COMPILER_VC12
-#		define GLM_VECTOR_CALL __vectorcall
-#	else
-#		define GLM_VECTOR_CALL
-#	endif
-#elif GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_CLANG | GLM_COMPILER_INTEL)
-#	define GLM_DEPRECATED __attribute__((__deprecated__))
-#	define GLM_ALIGN(x) __attribute__((aligned(x)))
-#	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
-#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __attribute__((aligned(alignment)))
-#	define GLM_RESTRICT_FUNC __restrict__
-#	define GLM_RESTRICT __restrict__
-#	if GLM_COMPILER & GLM_COMPILER_CLANG
-#		if GLM_COMPILER >= GLM_COMPILER_CLANG37
-#			define GLM_VECTOR_CALL __vectorcall
-#		else
-#			define GLM_VECTOR_CALL
-#		endif
-#	else
-#		define GLM_VECTOR_CALL
-#	endif
-#elif GLM_COMPILER & GLM_COMPILER_CUDA
-#	define GLM_DEPRECATED
-#	define GLM_ALIGN(x) __align__(x)
-#	define GLM_ALIGNED_STRUCT(x) struct __align__(x)
-#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name __align__(x)
-#	define GLM_RESTRICT_FUNC __restrict__
-#	define GLM_RESTRICT __restrict__
-#	define GLM_VECTOR_CALL
-#else
-#	define GLM_DEPRECATED
-#	define GLM_ALIGN
-#	define GLM_ALIGNED_STRUCT(x) struct
-#	define GLM_ALIGNED_TYPEDEF(type, name, alignment) typedef type name
-#	define GLM_RESTRICT_FUNC
-#	define GLM_RESTRICT
-#	define GLM_VECTOR_CALL
-#endif//GLM_COMPILER
-
-#if GLM_HAS_DEFAULTED_FUNCTIONS
-#	define GLM_DEFAULT = default
-#	ifdef GLM_FORCE_NO_CTOR_INIT
-#		define GLM_DEFAULT_CTOR = default
-#	else
-#		define GLM_DEFAULT_CTOR
-#	endif
-#else
-#	define GLM_DEFAULT
-#	define GLM_DEFAULT_CTOR
-#endif
-
-#if GLM_HAS_CONSTEXPR || GLM_HAS_CONSTEXPR_PARTIAL
-#	define GLM_CONSTEXPR constexpr
-#	if GLM_COMPILER & GLM_COMPILER_VC // Visual C++ has a bug #594 https://github.com/g-truc/glm/issues/594
-#		define GLM_CONSTEXPR_CTOR
-#	else
-#		define GLM_CONSTEXPR_CTOR constexpr
-#	endif
-#else
-#	define GLM_CONSTEXPR
-#	define GLM_CONSTEXPR_CTOR
-#endif
-
-#if GLM_HAS_CONSTEXPR
-#	define GLM_RELAXED_CONSTEXPR constexpr
-#else
-#	define GLM_RELAXED_CONSTEXPR const
-#endif
-
-#if GLM_ARCH == GLM_ARCH_PURE
-#	define GLM_CONSTEXPR_SIMD GLM_CONSTEXPR_CTOR
-#else
-#	define GLM_CONSTEXPR_SIMD
-#endif
-
-#ifdef GLM_FORCE_EXPLICIT_CTOR
-#	define GLM_EXPLICIT explicit
-#else
-#	define GLM_EXPLICIT
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////
-
-#define GLM_HAS_ALIGNED_TYPE GLM_HAS_UNRESTRICTED_UNIONS
-
-///////////////////////////////////////////////////////////////////////////////////
-// Length type
-
-// User defines: GLM_FORCE_SIZE_T_LENGTH GLM_FORCE_SIZE_FUNC
-
-namespace glm
-{
-	using std::size_t;
-#	if defined(GLM_FORCE_SIZE_T_LENGTH)
-		typedef size_t length_t;
-#	else
-		typedef int length_t;
-#	endif
-}//namespace glm
-
-#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
-#	define GLM_MESSAGE_FORCE_SIZE_T_LENGTH
-#	if defined GLM_FORCE_SIZE_T_LENGTH
-#		pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t")
-#	else
-#		pragma message("GLM: .length() returns glm::length_t, a typedef of int following the GLSL specification")
-#	endif
-#endif//GLM_MESSAGES
-
-///////////////////////////////////////////////////////////////////////////////////
-// countof
-
-#ifndef __has_feature
-#	define __has_feature(x) 0 // Compatibility with non-clang compilers.
-#endif
-
-#if GLM_HAS_CONSTEXPR_PARTIAL
-	namespace glm
-	{
-		template <typename T, std::size_t N>
-		constexpr std::size_t countof(T const (&)[N])
-		{
-			return N;
-		}
-	}//namespace glm
-#	define GLM_COUNTOF(arr) glm::countof(arr)
-#elif defined(_MSC_VER)
-#	define GLM_COUNTOF(arr) _countof(arr)
-#else
-#	define GLM_COUNTOF(arr) sizeof(arr) / sizeof(arr[0])
-#endif
-
-///////////////////////////////////////////////////////////////////////////////////
-// Uninitialize constructors
-
-namespace glm
-{
-	enum ctor{uninitialize};
-}//namespace glm

common/glm/glm/detail/type_float.hpp

@@ -1,67 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_float.hpp
-
-#pragma once
-
-#include "setup.hpp"
-
-namespace glm{
-namespace detail
-{
-	typedef float				float32;
-	typedef double				float64;
-}//namespace detail
-	
-	typedef float				lowp_float_t;
-	typedef float				mediump_float_t;
-	typedef double				highp_float_t;
-
-	/// @addtogroup core_precision
-	/// @{
-
-	/// Low precision floating-point numbers. 
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef lowp_float_t		lowp_float;
-
-	/// Medium precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef mediump_float_t		mediump_float;
-
-	/// High precision floating-point numbers.
-	/// There is no guarantee on the actual precision.
-	/// 
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.1.4 Floats</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 4.7.2 Precision Qualifier</a>
-	typedef highp_float_t		highp_float;
-
-#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef mediump_float		float_t;
-#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef highp_float			float_t;
-#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef mediump_float		float_t;
-#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
-	typedef lowp_float			float_t;
-#else
-#	error "GLM error: multiple default precision requested for floating-point types"
-#endif
-
-	typedef float				float32;
-	typedef double				float64;
-
-////////////////////
-// check type sizes
-#ifndef GLM_STATIC_ASSERT_NULL
-	GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
-	GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
-#endif//GLM_STATIC_ASSERT_NULL
-
-	/// @}
-
-}//namespace glm

common/glm/glm/detail/type_gentype.hpp

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

common/glm/glm/detail/type_gentype.inl

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

common/glm/glm/detail/type_half.hpp

@@ -1,19 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_half.hpp
-
-#pragma once
-
-#include "setup.hpp"
-
-namespace glm{
-namespace detail
-{
-	typedef short hdata;
-
-	GLM_FUNC_DECL float toFloat32(hdata value);
-	GLM_FUNC_DECL hdata toFloat16(float const & value);
-
-}//namespace detail
-}//namespace glm
-
-#include "type_half.inl"

common/glm/glm/detail/type_half.inl

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

common/glm/glm/detail/type_int.hpp

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

common/glm/glm/detail/type_mat.hpp

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

common/glm/glm/detail/type_mat.inl

@@ -1,3 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat.inl
-

common/glm/glm/detail/type_mat2x2.hpp

@@ -1,183 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x2.hpp
-
-#pragma once
-
-#include "../fwd.hpp"
-#include "type_vec2.hpp"
-#include "type_mat.hpp"
-#include <limits>
-#include <cstddef>
-
-namespace glm
-{
-	template <typename T, precision P = defaultp>
-	struct tmat2x2
-	{
-		typedef tvec2<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x2<T, P> type;
-		typedef tmat2x2<T, P> transpose_type;
-		typedef T value_type;
-
-	private:
-		col_type value[2];
-
-	public:
-		// -- Constructors --
-
-		GLM_FUNC_DECL tmat2x2() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x2(tmat2x2<T, Q> const & m);
-
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x2(ctor);
-		GLM_FUNC_DECL explicit tmat2x2(T scalar);
-		GLM_FUNC_DECL tmat2x2(
-			T const & x1, T const & y1,
-			T const & x2, T const & y2);
-		GLM_FUNC_DECL tmat2x2(
-			col_type const & v1,
-			col_type const & v2);
-
-		// -- Conversions --
-
-		template <typename U, typename V, typename M, typename N>
-		GLM_FUNC_DECL tmat2x2(
-			U const & x1, V const & y1,
-			M const & x2, N const & y2);
-
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x2(
-			tvec2<U, P> const & v1,
-			tvec2<V, P> const & v2);
-
-		// -- Matrix conversions --
-
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x2<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x2(tmat4x3<T, P> const & x);
-
-		// -- Accesses --
-
-		typedef length_t length_type;
-		GLM_FUNC_DECL static length_type length(){return 2;}
-
-		GLM_FUNC_DECL col_type & operator[](length_type i);
-		GLM_FUNC_DECL col_type const & operator[](length_type i) const;
-
-		// -- Unary arithmetic operators --
-
-		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<T, P> const & v) GLM_DEFAULT;
-
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator+=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator*=(tmat2x2<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x2<T, P> & operator/=(tmat2x2<U, P> const & m);
-
-		// -- Increment and decrement operators --
-
-		GLM_FUNC_DECL tmat2x2<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x2<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x2<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x2<T, P> operator--(int);
-	};
-
-	// -- Unary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m);
-
-	// -- Binary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(T scalar, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(T scalar, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(T scalar, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator*(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator*(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(T scalar, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2);
-} //namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x2.inl"
-#endif

common/glm/glm/detail/type_mat2x2.inl

@@ -1,484 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x2.inl
-
-#include "func_matrix.hpp"
-
-namespace glm
-{
-	// -- Constructors --
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2()
-		{
-#			ifndef GLM_FORCE_NO_CTOR_INIT 
-				this->value[0] = col_type(1, 0);
-				this->value[1] = col_type(0, 1);
-#			endif
-		}
-#	endif
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, P> const & m)
-		{
-			this->value[0] = m.value[0];
-			this->value[1] = m.value[1];
-		}
-#	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
-
-	template <typename T, precision P>
-	template <precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<T, Q> const & m)
-	{
-		this->value[0] = m.value[0];
-		this->value[1] = m.value[1];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CTOR tmat2x2<T, P>::tmat2x2(ctor)
-	{}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(T scalar)
-	{
-		this->value[0] = col_type(scalar, 0);
-		this->value[1] = col_type(0, scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
-	(
-		T const & x0, T const & y0,
-		T const & x1, T const & y1
-	)
-	{
-		this->value[0] = col_type(x0, y0);
-		this->value[1] = col_type(x1, y1);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(col_type const & v0, col_type const & v1)
-	{
-		this->value[0] = v0;
-		this->value[1] = v1;
-	}
-
-	// -- Conversion constructors --
-
-	template <typename T, precision P>
-	template <typename X1, typename Y1, typename X2, typename Y2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
-	(
-		X1 const & x1, Y1 const & y1,
-		X2 const & x2, Y2 const & y2
-	)
-	{
-		this->value[0] = col_type(static_cast<T>(x1), value_type(y1));
-		this->value[1] = col_type(static_cast<T>(x2), value_type(y2));
-	}
-	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tvec2<V1, P> const & v1, tvec2<V2, P> const & v2)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	// -- mat2x2 matrix conversions --
-
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x2<U, Q> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x4<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x2<T, P> const & m)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat2x4<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x2<T, P> const & m)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat3x4<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2(tmat4x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0]);
-		this->value[1] = col_type(m[1]);
-	}
-
-	// -- Accesses --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type const & tmat2x2<T, P>::operator[](typename tmat2x2<T, P>::length_type i) const
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	// -- Unary updatable operators --
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<T, P> const & m)
-		{
-			this->value[0] = m[0];
-			this->value[1] = m[1];
-			return *this;
-		}
-#	endif//!GLM_HAS_DEFAULTED_FUNCTIONS
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=(tmat2x2<U, P> const & m)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(U scalar)
-	{
-		this->value[0] += scalar;
-		this->value[1] += scalar;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=(tmat2x2<U, P> const & m)
-	{
-		this->value[0] += m[0];
-		this->value[1] += m[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(U scalar)
-	{
-		this->value[0] -= scalar;
-		this->value[1] -= scalar;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=(tmat2x2<U, P> const & m)
-	{
-		this->value[0] -= m[0];
-		this->value[1] -= m[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(U scalar)
-	{
-		this->value[0] *= scalar;
-		this->value[1] *= scalar;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=(tmat2x2<U, P> const & m)
-	{
-		return (*this = *this * m);
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(U scalar)
-	{
-		this->value[0] /= scalar;
-		this->value[1] /= scalar;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=(tmat2x2<U, P> const & m)
-	{
-		return *this *= inverse(m);
-	}
-
-	// -- Increment and decrement operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator++()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator--()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator++(int)
-	{
-		tmat2x2<T, P> Result(*this);
-		++*this;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> tmat2x2<T, P>::operator--(int)
-	{
-		tmat2x2<T, P> Result(*this);
-		--*this;
-		return Result;
-	}
-
-	// -- Unary arithmetic operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m)
-	{
-		return m;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			-m[0], 
-			-m[1]);
-	}
-
-	// -- Binary arithmetic operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m, T scalar)
-	{
-		return tmat2x2<T, P>(
-			m[0] + scalar,
-			m[1] + scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(T scalar, tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			m[0] + scalar,
-			m[1] + scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return tmat2x2<T, P>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m, T scalar)
-	{
-		return tmat2x2<T, P>(
-			m[0] - scalar,
-			m[1] - scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(T scalar, tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			scalar - m[0],
-			scalar - m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return tmat2x2<T, P>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m, T scalar)
-	{
-		return tmat2x2<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(T scalar, tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator*
-	(
-		tmat2x2<T, P> const & m,
-		typename tmat2x2<T, P>::row_type const & v
-	)
-	{
-		return tvec2<T, P>(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator*
-	(
-		typename tmat2x2<T, P>::col_type const & v,
-		tmat2x2<T, P> const & m
-	)
-	{
-		return tvec2<T, P>(
-			v.x * m[0][0] + v.y * m[0][1],
-			v.x * m[1][0] + v.y * m[1][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return tmat2x2<T, P>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat3x2<T, P> const & m2)
-	{
-		return tmat3x2<T, P>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x2<T, P> operator*(tmat2x2<T, P> const & m1, tmat4x2<T, P> const & m2)
-	{
-		return tmat4x2<T, P>(
-			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
-			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m, T scalar)
-	{
-		return tmat2x2<T, P>(
-			m[0] / scalar,
-			m[1] / scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(T scalar, tmat2x2<T, P> const & m)
-	{
-		return tmat2x2<T, P>(
-			scalar / m[0],
-			scalar / m[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator/(tmat2x2<T, P> const & m, typename tmat2x2<T, P>::row_type const & v)
-	{
-		return inverse(m) * v;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator/(typename tmat2x2<T, P>::col_type const & v, tmat2x2<T, P> const & m)
-	{
-		return v *  inverse(m);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator/(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{	
-		tmat2x2<T, P> m1_copy(m1);
-		return m1_copy /= m2;
-	}
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x2<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-} //namespace glm