Merge branch 'multithreaded-net' of github.com:EQEmu/Server into multithreaded-net

New min/max personal faction per faction.  Use of actual client mods for race/class/deity

.editorconfig

@@ -0,0 +1,23 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# Matches multiple files with brace expansion notation
+# Set default charset
+[*.{js,py}]
+charset = utf-8
+
+[*.cpp]
+indent_style = tab
+[*.h]
+indent_style = tab
+
+# Tab indentation (no size specified)
+[Makefile]
+indent_style = tab

.gitignore

@@ -37,3 +37,7 @@ x64/
 x86/
 log/
 logs/
+vcpkg/
+
+.idea/*
+*cbp

.gitmodules

@@ -0,0 +1,21 @@
+[submodule "submodules/websocketpp"]
+	path = submodules/websocketpp
+	url = https://github.com/zaphoyd/websocketpp.git
+[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/recastnavigation"]
+	path = submodules/recastnavigation
+	url = https://github.com/recastnavigation/recastnavigation.git
+[submodule "submodules/concurrentqueue"]
+	path = submodules/concurrentqueue
+	url = https://github.com/cameron314/concurrentqueue.git

.travis.yml

@@ -1,32 +1,27 @@
 language: cpp
 compiler: gcc
-sudo: false
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    packages:
-    - gcc-4.8
-    - g++-4.8
-    - libmysqlclient-dev
-    - libperl-dev
-    - libboost-dev
-    - liblua5.1-0-dev
-    - zlib1g-dev
-    - uuid-dev
-    - libssl-dev
+dist: trusty
+
+before_install:
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
+  - sudo apt-get update -qq
+  - mkdir $HOME/usr
+  - export PATH="$HOME/usr/bin:$PATH"
+  - wget https://cmake.org/files/v3.11/cmake-3.11.2-Linux-x86_64.sh
+  - chmod +x cmake-3.11.2-Linux-x86_64.sh
+  - ./cmake-3.11.2-Linux-x86_64.sh --prefix=$HOME/usr --exclude-subdir --skip-license
+
 install:
-  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
+  - sudo apt-get install -qq g++-7
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-7 90
+  - sudo apt-get install libmysqlclient-dev
+  - sudo apt-get install libperl-dev
+  - sudo apt-get install libboost-dev
+  - sudo apt-get install liblua5.1-0-dev
+  - sudo apt-get install zlib1g-dev
+  - sudo apt-get install uuid-dev
+  - sudo apt-get install libssl-dev  
 script:
   - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON
   - make -j2
   - ./bin/tests
-branches:
-  only:
-    - master
-    - stable
-notifications:
-  email: false
-  irc:
-    channels: "irc.eqemulator.net#eqemucoders"
-os: linux

CMakeLists.txt

@@ -27,9 +27,10 @@
 #EQEMU_USE_MAP_MMFS
 #EQEMU_MAP_DIR
 
-#We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones
-#Can change this if you really want but you should upgrade!
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+IF(POLICY CMP0074)
+	cmake_policy(SET CMP0074 NEW)
+ENDIF()
 
 #FindMySQL is located here so lets make it so CMake can find it
 SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH})
@@ -42,6 +43,8 @@ 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)
@@ -53,7 +56,6 @@ IF(MSVC OR MINGW)
 ENDIF(MSVC OR MINGW)
 
 IF(MSVC)
-	#Set our default locations for zlib/mysql based on x86/x64
 	IF(CMAKE_CL_64)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
@@ -100,23 +102,6 @@ IF(MSVC)
 		ADD_DEFINITIONS(-DCRASH_LOGGING)
 	ENDIF(EQEMU_ENABLE_CRASH_LOGGING)
 
-	#Disable safe SEH or not?
-	OPTION(EQEMU_DISABLE_SAFESEH "Disable Safe SEH (Needed for Strawberry Perl)" OFF)
-	IF(EQEMU_DISABLE_SAFESEH)
-		SET(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL "${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
-		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
-	ENDIF(EQEMU_DISABLE_SAFESEH)
-
 	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
 	IF(EQEMU_BUILD_MSVC_MP)
 		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
@@ -281,10 +266,11 @@ 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)
+#Disabled until reevaluation performed
+#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.")
 
@@ -300,6 +286,8 @@ 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)
+ADD_DEFINITIONS(-DGLM_FORCE_CTOR_INIT)
+ADD_DEFINITIONS(-DGLM_ENABLE_EXPERIMENTAL)
 
 #Find everything we need
 FIND_PACKAGE(ZLIB REQUIRED)
@@ -309,7 +297,7 @@ IF(EQEMU_BUILD_PERL)
 	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)
+SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} uv_a fmt RecastNavigation::Detour)
 
 FIND_PACKAGE(Sodium REQUIRED)
 IF(SODIUM_FOUND)
@@ -342,7 +330,7 @@ IF(EQEMU_BUILD_LUA)
 
 	FIND_PACKAGE(Boost REQUIRED)
 	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
-	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/luabind")
+	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)
@@ -352,15 +340,27 @@ 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}/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/concurrentqueue")
 
 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)
+	
+	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)
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)

LICENSE

@@ -1,165 +1,674 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
+                    GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
+                            Preamble
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
 
-  0. Additional Definitions.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
 
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
 
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
 
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
 
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
 
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
 
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
 
-  1. Exception to Section 3 of the GNU GPL.
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
 
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
+  The precise terms and conditions for copying, distribution and
+modification follow.
 
-  2. Conveying Modified Versions.
+                       TERMS AND CONDITIONS
 
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
+  0. Definitions.
 
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
+  "This License" refers to version 3 of the GNU General Public License.
 
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
 
-  3. Object Code Incorporating Material from Library Header Files.
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
 
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
 
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
 
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
 
-  4. Combined Works.
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
 
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
 
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
+  1. Source Code.
 
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
 
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
 
-   d) Do one of the following:
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
 
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
 
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
 
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
+  The Corresponding Source for a work in source code form is that
+same work.
 
-  5. Combined Libraries.
+  2. Basic Permissions.
 
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
 
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
 
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
 
-  6. Revised Versions of the GNU Lesser General Public License.
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
 
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
 
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; 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, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,7 +1,7 @@
 # EQEmulator Core Server
-|Travis CI (Linux)|Appveyor (Windows)   |
-|:---:|:---:| 
-|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Windows CI](https://ci.appveyor.com/api/projects/status/d0cvokm7u732v8vl/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server/branch/master)   |
+|Travis CI (Linux)|Appveyor w/ Bots (Windows)   |Appveyor w/o Bots (Windows)   |
+|:---:|:---:|:---:| 
+|[![Linux CI](https://travis-ci.org/EQEmu/Server.svg?branch=master)](https://travis-ci.org/EQEmu/Server)   |[![Build status](https://ci.appveyor.com/api/projects/status/scr25kmntx36c1ub/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-87crp/branch/master)   |[![Build status](https://ci.appveyor.com/api/projects/status/mdwbr4o9l6mxqofj/branch/master?svg=true)](https://ci.appveyor.com/project/KimLS/server-w0pq2/branch/master)   |
 
 ***
 

appveyor-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=ON -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-bots.zip

appveyor-no-bots.yml

@@ -0,0 +1,21 @@
+version: 1.0.{build}
+branches:
+  only:
+  - master
+image: Visual Studio 2017
+configuration: RelWithDebInfo
+clone_folder: c:\projects\eqemu
+init:
+- ps: git config --global core.autocrlf input
+cache: c:\tools\vcpkg\installed\
+before_build:
+- ps: "$wc = New-Object System.Net.WebClient\n$wc.DownloadFile(\"http://strawberryperl.com/download/5.26.2.1/strawberry-perl-5.26.2.1-64bit-portable.zip\", \"c:\\projects\\eqemu\\strawberry-perl-5.26.2.1-64bit-portable.zip\")\ncd c:\\projects\\eqemu\n7z x c:/projects/eqemu/strawberry-perl-5.26.2.1-64bit-portable.zip -oc:/projects/eqemu/strawberry-perl-portable -y\n(Get-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h).replace('#define PERL_STATIC_INLINE static __inline__', '#define PERL_STATIC_INLINE static __inline') | Set-Content C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/config.h\nvcpkg install boost-geometry:x64-windows boost-dynamic-bitset:x64-windows luajit:x64-windows libsodium:x64-windows libmysql:x64-windows openssl:x64-windows zlib:x64-windows \nmkdir build\ncd build\ncmake -G \"Visual Studio 15 2017 Win64\" -DEQEMU_BUILD_TESTS=ON -DEQEMU_BUILD_LOGIN=ON -EQEMU_ENABLE_BOTS=OFF -DPERL_EXECUTABLE=\"C:/projects/eqemu/strawberry-perl-portable/perl/bin/perl.exe\" -DPERL_INCLUDE_PATH=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE\" -DPERL_LIBRARY=\"C:/projects/eqemu/strawberry-perl-portable/perl/lib/CORE/libperl526.a\" -DCMAKE_TOOLCHAIN_FILE=\"c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake\" .."
+build:
+  project: C:\projects\eqemu\build\EQEmu.sln
+  parallel: true
+  verbosity: minimal
+after_build:
+- cmd: >-
+    7z a build_x64-no-bots.zip C:\projects\eqemu\build\bin\RelWithDebInfo\*.exe C:\projects\eqemu\build\bin\RelWithDebInfo\*.dll C:\projects\eqemu\build\bin\RelWithDebInfo\*.pdb
+
+    appveyor PushArtifact build_x64-no-bots.zip

changelog.txt

@@ -1,5 +1,423 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+
+== 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');
+        - Acceptable inputs:
+            - 15s = 15 seconds
+            - s15 = 15 seconds
+            - 60m = 60 minutes
+            - 7d  = 7 days
+            - 1y  = 1 year
+            - 600 = 600 seconds
+
+== 07/09/2018 ==
+mackal: Rework of Task System, Shared Tasks still unsupported
+	- The tables now have better named columns, which hopefully won't need to be explained
+	- Text1 is now target_name, Text2 is now item_list, Text3 is now description_override
+	- Tasks can now reward faction hits, this is just normal NPC Faction ID entries because I was lazy
+	- The "Task" type tasks are now supported, a player can only be doing one of these at a time
+	- Activity IDs for use spell on and use skill on have been identified but not implemented
+	- Identified "duration code" for unlimited duration tasks (None = 0, Short = 1, Medium = 2, Long = 3)
+	- Activities can now have multiple zones separated by ';'
+	- tasks.startzone removed since it actually just uses first activity
+	- skill_list and spell_list are both IDs that can be separated by ';' (still unimplemented though)
+
+== 07/07/2018 ==
+Akkadius: Implemented a much better replacement for qglobals called 'DataBuckets'
+    - A much more detailed example can be found at: https://github.com/EQEmu/Server/wiki/Data-Buckets
+
+== 07/05/2018 ==
+Uleat: Reintegration of inventory-based EQDictionary references
+	- Standardized 'CONSTANT_DECLARATION' and 'enumerationValue' tokens for most of the affected references
+	- Added 'BEGIN' and 'END' constants to many inventory-based ranges to help eliminate '< SIZE'-type comparisons
+	- Eliminated multiple, duplicated reference points of the same value context (bye, bye namespace legacy!)
+	- Most server values are now linked to the implementation client directly through a 'using ##' directive
+
+== 05/28/2018 ==
+Akkadius: Fixed an issue where size 0 NPC's hop in and out of the ground at idle
+Akkadius: NPC's now open doors within proximity given the door doesn't have locked requirements
+Akkadius: #reloadallrules will now display zones that have had their rules reloaded to GM's
+Akkadius: Zones should now respect "shutdowndelay" in the zones table at all times
+Akkadius: Fixed an issue where boats would snap to the bed of the body of water
+Akkadius: Added rule Aggro:NPCAggroMaxDistanceEnabled - defaults to true
+Akkadius: Changed map directory load structure
+    - maps/base/*.map
+    - maps/nav/*.nav
+    - maps/water/*.wtr
+    - maps/path/*.path
+
+KLS: Implemented navigation mesh
+    - All up to date maps and navs can be found https://github.com/Akkadius/EQEmuMaps
+    - To update maps either check out the maps found in the above repository or use the maintenance command:
+        perl eqemu_server.pl maps
+
+== 03/28/2018 ==
+Kayen: SE_CastOnFadeEffect, SE_CastOnFadeEffectNPC, SE_CastOnFadeEffectAlway triggered spell will now hit
+the correct targets.
+
 == 03/07/2018 ==
 Uleat: Added command '#ucs' to force a reconnect to UCS server.
 	- Works in place of client auto-reconnect packet in zones where feature is unsupported

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);

common/CMakeLists.txt

@@ -3,6 +3,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 SET(common_sources
 	base_packet.cpp
 	classes.cpp
+	compression.cpp
 	condition.cpp
 	crash.cpp
 	crc16.cpp
@@ -13,7 +14,6 @@ SET(common_sources
 	dbcore.cpp
 	deity.cpp
 	emu_constants.cpp
-	emu_legacy.cpp
 	emu_limits.cpp
 	emu_opcodes.cpp
 	emu_versions.cpp
@@ -55,11 +55,13 @@ SET(common_sources
 	perl_eqdb.cpp
 	perl_eqdb_res.cpp
 	proc_launcher.cpp
+	profanity_manager.cpp
 	ptimer.cpp
 	races.cpp
 	rdtsc.cpp
 	rulesys.cpp
 	say_link.cpp
+	serialize_buffer.cpp
 	serverinfo.cpp
 	shareddb.cpp
 	skills.cpp
@@ -71,13 +73,13 @@ 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
 	net/crc32.cpp
 	net/daybreak_connection.cpp
 	net/eqstream.cpp
+	net/eqstream_concurrent.cpp
 	net/packet.cpp
 	net/servertalk_client_connection.cpp
 	net/servertalk_legacy_client_connection.cpp
@@ -113,6 +115,7 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
+	compression.h
 	condition.h
 	crash.h
 	crc16.h
@@ -122,7 +125,6 @@ SET(common_headers
 	dbcore.h
 	deity.h
 	emu_constants.h
-	emu_legacy.h
 	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
@@ -135,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
@@ -180,6 +183,7 @@ SET(common_headers
 	packet_functions.h
 	platform.h
 	proc_launcher.h
+	profanity_manager.h
 	profiler.h
 	ptimer.h
 	queue.h
@@ -190,6 +194,7 @@ SET(common_headers
 	ruletypes.h
 	say_link.h
 	seperator.h
+	serialize_buffer.h
 	serverinfo.h
 	servertalk.h
 	shareddb.h
@@ -205,8 +210,8 @@ SET(common_headers
 	version.h
 	xml_parser.h
 	zone_numbers.h
-	event/background_task.h
 	event/event_loop.h
+	event/task.h
 	event/timer.h
 	json/json.h
 	json/json-forwards.h
@@ -218,6 +223,8 @@ SET(common_headers
 	net/dns.h
 	net/endian.h
 	net/eqstream.h
+	net/eqstream_concurrent.h
+	net/eqstream_concurrent_message.h
 	net/packet.h
 	net/servertalk_client_connection.h
 	net/servertalk_legacy_client_connection.h
@@ -263,10 +270,9 @@ SET(common_headers
 )
 
 SOURCE_GROUP(Event FILES
-	event/background_task.h
-	event/event_loop.cpp
 	event/event_loop.h
 	event/timer.h
+	event/task.h
 )
 
 SOURCE_GROUP(Json FILES
@@ -291,6 +297,9 @@ SOURCE_GROUP(Net FILES
 	net/eqmq.h
 	net/eqstream.cpp
 	net/eqstream.h
+	net/eqstream_concurrent.cpp
+	net/eqstream_concurrent.h
+	net/eqstream_concurrent_message.h
 	net/packet.cpp
 	net/packet.h
 	net/servertalk_client_connection.cpp

common/base_packet.cpp

@@ -39,6 +39,18 @@ BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 	}
 }
 
+BasePacket::BasePacket(SerializeBuffer &buf)
+{
+	pBuffer = buf.m_buffer;
+	buf.m_buffer = nullptr;
+	size = buf.m_pos;
+	buf.m_pos = 0;
+	buf.m_capacity = 0;
+	_wpos = 0;
+	_rpos = 0;
+	timestamp.tv_sec = 0;
+}
+
 BasePacket::~BasePacket()
 {
 	if (pBuffer)

common/base_packet.h

@@ -19,6 +19,7 @@
 #define BASEPACKET_H_
 
 #include "types.h"
+#include "serialize_buffer.h"
 #include <stdio.h>
 #include <string.h>
 
@@ -63,6 +64,8 @@ public:
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }
 	void WriteDouble(double value) { *(double *)(pBuffer + _wpos) = value; _wpos += sizeof(double); }
 	void WriteString(const char * str) { uint32 len = static_cast<uint32>(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; }
+	// this is used in task system a lot, it is NOT null-termed
+	void WriteLengthString(uint32 len, const char *str) { *(uint32 *)(pBuffer + _wpos) = len; _wpos += sizeof(uint32); memcpy(pBuffer + _wpos, str, len); _wpos += len; }
 	void WriteData(const void *ptr, size_t n) { memcpy(pBuffer + _wpos, ptr, n); _wpos += n; }
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
@@ -83,6 +86,7 @@ protected:
 	virtual ~BasePacket();
 	BasePacket() { pBuffer=nullptr; size=0; _wpos = 0; _rpos = 0; }
 	BasePacket(const unsigned char *buf, const uint32 len);
+	BasePacket(SerializeBuffer &buf);
 };
 
 extern void DumpPacketHex(const BasePacket* app);

common/compression.cpp

@@ -0,0 +1,82 @@
+#include "global_define.h"
+#include "types.h"
+#include <string.h>
+#include <zlib.h>
+
+namespace EQEmu
+{
+	uint32 EstimateDeflateBuffer(uint32 len) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		if (deflateInit(&zstream, Z_FINISH) != Z_OK)
+			return 0;
+
+		return deflateBound(&zstream, len);
+	}
+
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		memset(&zstream, 0, sizeof(zstream));
+		int zerror;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+		deflateInit(&zstream, Z_FINISH);
+
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);
+		zstream.avail_out = out_len_max;
+		zerror = deflate(&zstream, Z_FINISH);
+
+		if (zerror == Z_STREAM_END)
+		{
+			deflateEnd(&zstream);
+			return (uint32)zstream.total_out;
+		}
+		else
+		{
+			zerror = deflateEnd(&zstream);
+			return 0;
+		}
+	}
+
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max) {
+		z_stream zstream;
+		int zerror = 0;
+		int i;
+
+		zstream.next_in = const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer));
+		zstream.avail_in = len;
+		zstream.next_out = reinterpret_cast<unsigned char*>(out_buffer);;
+		zstream.avail_out = out_len_max;
+		zstream.zalloc = Z_NULL;
+		zstream.zfree = Z_NULL;
+		zstream.opaque = Z_NULL;
+
+		i = inflateInit2(&zstream, 15);
+		if (i != Z_OK) {
+			return 0;
+		}
+
+		zerror = inflate(&zstream, Z_FINISH);
+		if (zerror == Z_STREAM_END) {
+			inflateEnd(&zstream);
+			return zstream.total_out;
+		}
+		else {
+			if (zerror == -4 && zstream.msg == 0)
+			{
+				return 0;
+			}
+
+			zerror = inflateEnd(&zstream);
+			return 0;
+		}
+	}
+}

common/compression.h

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace EQEmu
+{
+	uint32 EstimateDeflateBuffer(uint32 len);
+	uint32 DeflateData(const char *buffer, uint32 len, char *out_buffer, uint32 out_len_max);
+	uint32 InflateData(const char* buffer, uint32 len, char* out_buffer, uint32 out_len_max);
+}

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

@@ -708,7 +708,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 
 	/* Insert starting inventory... */
 	std::string invquery;
-	for (int16 i = EQEmu::legacy::EQUIPMENT_BEGIN; i <= EQEmu::legacy::BANK_BAGS_END;) {
+	for (int16 i = EQEmu::invslot::EQUIPMENT_BEGIN; i <= EQEmu::invbag::BANK_BAGS_END;) {
 		const EQEmu::ItemInstance* newinv = inv->GetItem(i);
 		if (newinv) {
 			invquery = StringFormat("INSERT INTO `inventory` (charid, slotid, itemid, charges, color) VALUES (%u, %i, %u, %i, %u)",
@@ -717,16 +717,16 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 			auto results = QueryDatabase(invquery); 
 		}
 
-		if (i == EQEmu::inventory::slotCursor) {
-			i = EQEmu::legacy::GENERAL_BAGS_BEGIN; 
+		if (i == EQEmu::invslot::slotCursor) {
+			i = EQEmu::invbag::GENERAL_BAGS_BEGIN; 
 			continue;
 		}
-		else if (i == EQEmu::legacy::CURSOR_BAG_END) { 
-			i = EQEmu::legacy::BANK_BEGIN; 
+		else if (i == EQEmu::invbag::CURSOR_BAG_END) { 
+			i = EQEmu::invslot::BANK_BEGIN; 
 			continue; 
 		}
-		else if (i == EQEmu::legacy::BANK_END) { 
-			i = EQEmu::legacy::BANK_BAGS_BEGIN; 
+		else if (i == EQEmu::invslot::BANK_END) { 
+			i = EQEmu::invbag::BANK_BAGS_BEGIN; 
 			continue; 
 		} 
 		i++;
@@ -1408,25 +1408,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;
 }
@@ -1752,6 +1766,15 @@ void Database::ClearRaidDetails(uint32 rid) {
 		std::cout << "Unable to clear raid details: " << results.ErrorMessage() << std::endl;
 }
 
+void Database::PurgeAllDeletedDataBuckets() {
+	std::string query = StringFormat(
+			"DELETE FROM `data_buckets` WHERE (`expires` < %lld AND `expires` > 0)",
+			(long long) std::time(nullptr)
+	);
+
+	QueryDatabase(query);
+}
+
 // returns 0 on error or no raid for that character, or
 // the raid id that the character is a member of.
 uint32 Database::GetRaidID(const char* name)
@@ -2054,58 +2077,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

@@ -221,6 +221,8 @@ public:
 	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
 	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
 
+	void    PurgeAllDeletedDataBuckets();
+
 	/* Database Conversions 'database_conversions.cpp' */
 
 	bool	CheckDatabaseConversions();
@@ -262,7 +264,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

@@ -41,6 +41,9 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 
 #pragma pack(1)
 
+// all const/macro reference values should really be converted to a magic number for this
+// process to ensure that the struct sizes and offsets match up to the corresponding blob
+
 /* Conversion Structs */
 
 namespace Convert {
@@ -214,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
@@ -253,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
@@ -330,7 +333,7 @@ namespace Convert {
 		/*7212*/	uint32							tribute_points;
 		/*7216*/	uint32							unknown7252;
 		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EQEmu::legacy::TRIBUTE_SIZE];
+		/*7224*/	Convert::Tribute_Struct			tributes[5];
 		/*7264*/	Convert::Disciplines_Struct		disciplines;
 		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 		/*7744*/	char							unknown7780[160];
@@ -1357,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]);
@@ -1369,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]);
@@ -1405,7 +1408,7 @@ bool Database::CheckDatabaseConvertPPDeblob(){
 				if (rquery != ""){ results = QueryDatabase(rquery); }
 				/* Run Tribute Convert */
 				first_entry = 0; rquery = "";
-				for (i = 0; i < EQEmu::legacy::TRIBUTE_SIZE; i++){
+				for (i = 0; i < 5; i++){
 					if (pp->tributes[i].tribute > 0 && pp->tributes[i].tribute != 4294967295){
 						if (first_entry != 1){
 							rquery = StringFormat("REPLACE INTO `character_tribute` (id, tier, tribute) VALUES (%u, %u, %u)", character_id, pp->tributes[i].tier, pp->tributes[i].tribute);

common/database_instances.cpp

@@ -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/emu_constants.cpp

@@ -20,6 +20,41 @@
 #include "emu_constants.h"
 
 
+int16 EQEmu::invtype::GetInvTypeSize(int16 inv_type) {
+	static const int16 local_array[] = {
+		POSSESSIONS_SIZE,
+		BANK_SIZE,
+		SHARED_BANK_SIZE,
+		TRADE_SIZE,
+		WORLD_SIZE,
+		LIMBO_SIZE,
+		TRIBUTE_SIZE,
+		TROPHY_TRIBUTE_SIZE,
+		GUILD_TRIBUTE_SIZE,
+		MERCHANT_SIZE,
+		DELETED_SIZE,
+		CORPSE_SIZE,
+		BAZAAR_SIZE,
+		INSPECT_SIZE,
+		REAL_ESTATE_SIZE,
+		VIEW_MOD_PC_SIZE,
+		VIEW_MOD_BANK_SIZE,
+		VIEW_MOD_SHARED_BANK_SIZE,
+		VIEW_MOD_LIMBO_SIZE,
+		ALT_STORAGE_SIZE,
+		ARCHIVED_SIZE,
+		MAIL_SIZE,
+		GUILD_TROPHY_TRIBUTE_SIZE,
+		KRONO_SIZE,
+		OTHER_SIZE,
+	};
+
+	if (inv_type < TYPE_BEGIN || inv_type > TYPE_END)
+		return INULL;
+
+	return local_array[inv_type];
+}
+
 const char* EQEmu::bug::CategoryIDToCategoryName(CategoryID category_id) {
 	switch (category_id) {
 	case catVideo:
@@ -83,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

@@ -21,115 +21,261 @@
 #define COMMON_EMU_CONSTANTS_H
 
 #include "eq_limits.h"
-#include "emu_legacy.h"
 #include "emu_versions.h"
 
 #include <string.h>
 
 
+// local definitions are the result of using hybrid-client or server-only values and methods
 namespace EQEmu
 {
+	using RoF2::IINVALID;
+	using RoF2::INULL;
+	
 	namespace inventory {
-		//using namespace RoF2::invtype;
-		//using namespace RoF2::invslot;
-		//using namespace RoF2::invbag;
-		//using namespace RoF2::invaug;
-
-		enum : int16 { typeInvalid = -1, slotInvalid = -1, containerInvalid = -1, socketInvalid = -1 }; // temporary
-		enum : int16 { typeBegin = 0, slotBegin = 0, containerBegin = 0, socketBegin = 0 }; // temporary
-
-		enum PossessionsSlots : int16 { // temporary
-			slotCharm = 0,
-			slotEar1,
-			slotHead,
-			slotFace,
-			slotEar2,
-			slotNeck, // 5
-			slotShoulders,
-			slotArms,
-			slotBack,
-			slotWrist1,
-			slotWrist2, // 10
-			slotRange,
-			slotHands,
-			slotPrimary,
-			slotSecondary,
-			slotFinger1, // 15
-			slotFinger2,
-			slotChest,
-			slotLegs,
-			slotFeet,
-			slotWaist, // 20
-			slotPowerSource = 9999,
-			slotAmmo = 21,
-			slotGeneral1,
-			slotGeneral2,
-			slotGeneral3,
-			slotGeneral4, // 25
-			slotGeneral5,
-			slotGeneral6,
-			slotGeneral7,
-			slotGeneral8,
-			slotCursor, // 30
-			slotCount
-		};
-
-		enum InventoryTypes : int16 { // temporary
-			typePossessions = 0,
-			typeBank,
-			typeSharedBank,
-			typeTrade,
-			typeWorld,
-			typeLimbo, // 5
-			typeTribute,
-			typeTrophyTribute,
-			typeGuildTribute,
-			typeMerchant,
-			typeDeleted, // 10
-			typeCorpse,
-			typeBazaar,
-			typeInspect,
-			typeRealEstate,
-			typeViewMODPC, // 15
-			typeViewMODBank,
-			typeViewMODSharedBank,
-			typeViewMODLimbo,
-			typeAltStorage,
-			typeArchived, // 20
-			typeMail,
-			typeGuildTrophyTribute,
-			typeKrono,
-			typeOther,
-			typeCount
-		};
-
-		static int16 SlotCount(int16 type_index) { return 0; } // temporary
-
-		const int16 ContainerCount = 10; // temporary
-		const int16 SocketCount = 6; // temporary
-
+		
 	} /*inventory*/
 
+	namespace invtype {
+		using namespace RoF2::invtype::enum_;
+
+		using RoF2::invtype::POSSESSIONS_SIZE;
+		using RoF2::invtype::BANK_SIZE;
+		using RoF2::invtype::SHARED_BANK_SIZE;
+		using RoF2::invtype::TRADE_SIZE;
+		using RoF2::invtype::WORLD_SIZE;
+		using RoF2::invtype::LIMBO_SIZE;
+		using RoF2::invtype::TRIBUTE_SIZE;
+		using RoF2::invtype::TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::GUILD_TRIBUTE_SIZE;
+		using RoF2::invtype::MERCHANT_SIZE;
+		using RoF2::invtype::DELETED_SIZE;
+		using RoF2::invtype::CORPSE_SIZE;
+		using RoF2::invtype::BAZAAR_SIZE;
+		using RoF2::invtype::INSPECT_SIZE;
+		using RoF2::invtype::REAL_ESTATE_SIZE;
+		using RoF2::invtype::VIEW_MOD_PC_SIZE;
+		using RoF2::invtype::VIEW_MOD_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_SHARED_BANK_SIZE;
+		using RoF2::invtype::VIEW_MOD_LIMBO_SIZE;
+		using RoF2::invtype::ALT_STORAGE_SIZE;
+		using RoF2::invtype::ARCHIVED_SIZE;
+		using RoF2::invtype::MAIL_SIZE;
+		using RoF2::invtype::GUILD_TROPHY_TRIBUTE_SIZE;
+		using RoF2::invtype::KRONO_SIZE;
+		using RoF2::invtype::OTHER_SIZE;
+
+		using Titanium::invtype::TRADE_NPC_SIZE;
+
+		using RoF2::invtype::TYPE_INVALID;
+		using RoF2::invtype::TYPE_BEGIN;
+		using RoF2::invtype::TYPE_END;
+		using RoF2::invtype::TYPE_COUNT;
+
+		int16 GetInvTypeSize(int16 inv_type);
+		using RoF2::invtype::GetInvTypeName;
+
+	} // namespace invtype
+
+	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::SLOT_TRADESKILL_EXPERIMENT_COMBINE;
+
+		const int16 SLOT_AUGMENT_GENERIC_RETURN = 1001; // clients don't appear to use this method... (internal inventory return value)
+
+		using RoF2::invslot::POSSESSIONS_BEGIN;
+		using RoF2::invslot::POSSESSIONS_END;
+		using RoF2::invslot::POSSESSIONS_COUNT;
+
+		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;
+
+		using Titanium::invslot::SHARED_BANK_BEGIN;
+		using Titanium::invslot::SHARED_BANK_END;
+
+		using Titanium::invslot::TRADE_BEGIN;
+		using Titanium::invslot::TRADE_END;
+
+		using Titanium::invslot::TRADE_NPC_END;
+
+		using Titanium::invslot::WORLD_BEGIN;
+		using Titanium::invslot::WORLD_END;
+
+		using Titanium::invslot::TRIBUTE_BEGIN;
+		using Titanium::invslot::TRIBUTE_END;
+
+		using Titanium::invslot::GUILD_TRIBUTE_BEGIN;
+		using Titanium::invslot::GUILD_TRIBUTE_END;
+
+		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;
+
+		using RoF2::invslot::GetInvPossessionsSlotName;
+		using RoF2::invslot::GetInvSlotName;
+
+	} // namespace invslot
+
+	namespace invbag {
+		using Titanium::invbag::SLOT_INVALID;
+		using Titanium::invbag::SLOT_BEGIN;
+		using Titanium::invbag::SLOT_END;
+		using Titanium::invbag::SLOT_COUNT;
+
+		using Titanium::invbag::GENERAL_BAGS_BEGIN;
+		const int16 GENERAL_BAGS_COUNT = invslot::GENERAL_COUNT * SLOT_COUNT;
+		const int16 GENERAL_BAGS_END = (GENERAL_BAGS_BEGIN + GENERAL_BAGS_COUNT) - 1;
+
+		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 = 351;
+		const int16 CURSOR_BAG_COUNT = SLOT_COUNT;
+		const int16 CURSOR_BAG_END = (CURSOR_BAG_BEGIN + CURSOR_BAG_COUNT) - 1;
+
+		using Titanium::invbag::BANK_BAGS_BEGIN;
+		const int16 BANK_BAGS_COUNT = (invtype::BANK_SIZE * SLOT_COUNT);
+		const int16 BANK_BAGS_END = (BANK_BAGS_BEGIN + BANK_BAGS_COUNT) - 1;
+
+		const int16 BANK_BAGS_16_COUNT = 16 * SLOT_COUNT;
+		const int16 BANK_BAGS_16_END = (BANK_BAGS_BEGIN + BANK_BAGS_16_COUNT) - 1;
+
+		using Titanium::invbag::SHARED_BANK_BAGS_BEGIN;
+		const int16 SHARED_BANK_BAGS_COUNT = invtype::SHARED_BANK_SIZE * SLOT_COUNT;
+		const int16 SHARED_BANK_BAGS_END = (SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::TRADE_BAGS_BEGIN;
+		const int16 TRADE_BAGS_COUNT = invtype::TRADE_SIZE * SLOT_COUNT;
+		const int16 TRADE_BAGS_END = (TRADE_BAGS_BEGIN + TRADE_BAGS_COUNT) - 1;
+
+		using Titanium::invbag::GetInvBagIndexName;
+
+	} // namespace invbag
+
+	namespace invaug {
+		using RoF2::invaug::SOCKET_INVALID;
+		using RoF2::invaug::SOCKET_BEGIN;
+		using RoF2::invaug::SOCKET_END;
+		using RoF2::invaug::SOCKET_COUNT;
+
+		using RoF2::invaug::GetInvAugIndexName;
+
+	} // namespace invaug
+
 	namespace constants {
-		const EQEmu::versions::ClientVersion CharacterCreationClient = EQEmu::versions::ClientVersion::RoF2;
-		const size_t CharacterCreationMax = RoF2::constants::CharacterCreationLimit;
+		const EQEmu::versions::ClientVersion CHARACTER_CREATION_CLIENT = EQEmu::versions::ClientVersion::Titanium;
 
-		const size_t SayLinkOpenerSize = 1;
-		const size_t SayLinkBodySize = RoF2::constants::SayLinkBodySize;
-		const size_t SayLinkTextSize = 256; // this may be varied until it breaks something (tested:374) - the others are constant
-		const size_t SayLinkCloserSize = 1;
-		const size_t SayLinkMaximumSize = (SayLinkOpenerSize + SayLinkBodySize + SayLinkTextSize + SayLinkCloserSize);
+		using RoF2::constants::EXPANSION;
+		using RoF2::constants::EXPANSION_BIT;
+		using RoF2::constants::EXPANSIONS_MASK;
 
-		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;
+		using RoF2::constants::CHARACTER_CREATION_LIMIT;
+		
+		const size_t SAY_LINK_OPENER_SIZE = 1;
+		using RoF2::constants::SAY_LINK_BODY_SIZE;
+		const size_t SAY_LINK_TEXT_SIZE = 256; // this may be varied until it breaks something (tested:374) - the others are constant
+		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);
+
+		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*/
 
+	namespace profile {
+		using RoF2::profile::BANDOLIERS_SIZE;
+		using RoF2::profile::BANDOLIER_ITEM_COUNT;
+		
+		using RoF2::profile::POTION_BELT_SIZE;
+
+		using RoF2::profile::SKILL_ARRAY_SIZE;
+
+	} // namespace profile
+
+	namespace behavior {
+		using RoF2::behavior::CoinHasWeight;
+
+	} // 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,
@@ -161,27 +307,6 @@ 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
-	};
-
 } /*EQEmu*/
 
 #endif /*COMMON_EMU_CONSTANTS_H*/

common/emu_legacy.cpp

@@ -1,20 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 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
-*/
-
-#include "emu_legacy.h"

common/emu_legacy.h

@@ -1,182 +0,0 @@
-/*	EQEMu:  Everquest Server Emulator
-	
-	Copyright (C) 2001-2016 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
-*/
-
-#ifndef COMMON_EMU_LEGACY_H
-#define COMMON_EMU_LEGACY_H
-
-#include "types.h"
-
-#include <stdlib.h>
-
-
-namespace EQEmu
-{
-	// this is for perl and other legacy systems
-	namespace legacy {
-		enum InventorySlot {
-			SLOT_CHARM = 0,
-			SLOT_EAR01 = 1,
-			SLOT_HEAD = 2,
-			SLOT_FACE = 3,
-			SLOT_EAR02 = 4,
-			SLOT_NECK = 5,
-			SLOT_SHOULDER = 6,
-			SLOT_ARMS = 7,
-			SLOT_BACK = 8,
-			SLOT_BRACER01 = 9,
-			SLOT_BRACER02 = 10,
-			SLOT_RANGE = 11,
-			SLOT_HANDS = 12,
-			SLOT_PRIMARY = 13,
-			SLOT_SECONDARY = 14,
-			SLOT_RING01 = 15,
-			SLOT_RING02 = 16,
-			SLOT_CHEST = 17,
-			SLOT_LEGS = 18,
-			SLOT_FEET = 19,
-			SLOT_WAIST = 20,
-			SLOT_POWER_SOURCE = 9999,
-			SLOT_AMMO = 21,
-			SLOT_GENERAL_1 = 22,
-			SLOT_GENERAL_2 = 23,
-			SLOT_GENERAL_3 = 24,
-			SLOT_GENERAL_4 = 25,
-			SLOT_GENERAL_5 = 26,
-			SLOT_GENERAL_6 = 27,
-			SLOT_GENERAL_7 = 28,
-			SLOT_GENERAL_8 = 29,
-			SLOT_CURSOR = 30,
-			SLOT_CURSOR_END = (int16)0xFFFE, // I hope no one is using this...
-			SLOT_TRADESKILL = 1000,
-			SLOT_AUGMENT = 1001,
-			SLOT_INVALID = (int16)0xFFFF,
-			SLOT_POSSESSIONS_BEGIN = 0,
-			SLOT_POSSESSIONS_END = 30,
-			SLOT_EQUIPMENT_BEGIN = 0,
-			SLOT_EQUIPMENT_END = 21,
-			SLOT_PERSONAL_BEGIN = 22,
-			SLOT_PERSONAL_END = 29,
-			SLOT_PERSONAL_BAGS_BEGIN = 251,
-			SLOT_PERSONAL_BAGS_END = 330,
-			SLOT_CURSOR_BAG_BEGIN = 331,
-			SLOT_CURSOR_BAG_END = 340,
-			SLOT_TRIBUTE_BEGIN = 400,
-			SLOT_TRIBUTE_END = 404,
-			SLOT_GUILD_TRIBUTE_BEGIN = 450,
-			SLOT_GUILD_TRIBUTE_END = 451,
-			SLOT_BANK_BEGIN = 2000,
-			SLOT_BANK_END = 2023,
-			SLOT_BANK_BAGS_BEGIN = 2031,
-			SLOT_BANK_BAGS_END = 2270,
-			SLOT_SHARED_BANK_BEGIN = 2500,
-			SLOT_SHARED_BANK_END = 2501,
-			SLOT_SHARED_BANK_BAGS_BEGIN = 2531,
-			SLOT_SHARED_BANK_BAGS_END = 2550,
-			SLOT_TRADE_BEGIN = 3000,
-			SLOT_TRADE_END = 3007,
-			SLOT_TRADE_BAGS_BEGIN = 3031,
-			SLOT_TRADE_BAGS_END = 3110,
-			SLOT_WORLD_BEGIN = 4000,
-			SLOT_WORLD_END = 4009
-		};
-
-		// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
-		static const uint16	TYPE_POSSESSIONS_SIZE = 31;
-		static const uint16 TYPE_BANK_SIZE = 24;
-		static const uint16 TYPE_SHARED_BANK_SIZE = 2;
-		static const uint16 TYPE_TRADE_SIZE = 8;
-		static const uint16 TYPE_WORLD_SIZE = 10;
-		static const uint16 TYPE_LIMBO_SIZE = 36;
-		static const uint16 TYPE_TRIBUTE_SIZE = 5; // (need client values)
-		static const uint16 TYPE_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_GUILD_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_MERCHANT_SIZE = 0;
-		static const uint16 TYPE_DELETED_SIZE = 0;
-		static const uint16 TYPE_CORPSE_SIZE = 31; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
-		static const uint16 TYPE_BAZAAR_SIZE = 80;
-		static const uint16 TYPE_INSPECT_SIZE = 22;
-		static const uint16 TYPE_REAL_ESTATE_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_PC_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_SHARED_BANK_SIZE = 0;
-		static const uint16 TYPE_VIEW_MOD_LIMBO_SIZE = 0;
-		static const uint16 TYPE_ALT_STORAGE_SIZE = 0;
-		static const uint16 TYPE_ARCHIVED_SIZE = 0;
-		static const uint16 TYPE_MAIL_SIZE = 0;
-		static const uint16 TYPE_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-		static const uint16 TYPE_KRONO_SIZE = 0;
-		static const uint16 TYPE_OTHER_SIZE = 0;
-
-		// most of these definitions will go away with the structure-based system..this maintains compatibility for now
-		// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
-		static const int16 EQUIPMENT_BEGIN = 0;
-		static const int16 EQUIPMENT_END = 21;
-		static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
-
-		static const int16 GENERAL_BEGIN = 22;
-		static const int16 GENERAL_END = 29;
-		static const uint16 GENERAL_SIZE = 8;
-		static const int16 GENERAL_BAGS_BEGIN = 251;
-		static const int16 GENERAL_BAGS_END_OFFSET = 79;
-		static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
-
-		static const int16 CURSOR_BAG_BEGIN = 331;
-		static const int16 CURSOR_BAG_END_OFFSET = 9;
-		static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
-
-		static const int16 BANK_BEGIN = 2000;
-		static const int16 BANK_END = 2023;
-		static const int16 BANK_BAGS_BEGIN = 2031;
-		static const int16 BANK_BAGS_END_OFFSET = 239;
-		static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
-
-		static const int16 SHARED_BANK_BEGIN = 2500;
-		static const int16 SHARED_BANK_END = 2501;
-		static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-		static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-		static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
-
-		static const int16 TRADE_BEGIN = 3000;
-		static const int16 TRADE_END = 3007;
-		static const int16 TRADE_NPC_END = 3003;
-		static const int16 TRADE_BAGS_BEGIN = 3031;
-		static const int16 TRADE_BAGS_END_OFFSET = 79;
-		static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
-
-		static const int16 WORLD_BEGIN = 4000;
-		static const int16 WORLD_END = 4009;
-		static const int16 WORLD_SIZE = TYPE_WORLD_SIZE;
-
-		static const int16 TRIBUTE_BEGIN = 400;
-		static const int16 TRIBUTE_END = 404;
-		static const int16 TRIBUTE_SIZE = TYPE_TRIBUTE_SIZE;
-
-		static const int16 CORPSE_BEGIN = 22;
-
-		// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t BANDOLIERS_SIZE = 20;		// number of bandolier instances
-		static const size_t BANDOLIER_ITEM_COUNT = 4;	// number of equipment slots in bandolier instance
-
-		// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-		static const size_t POTION_BELT_ITEM_COUNT = 5;
-	}
-
-}
-
-#endif /* COMMON_EMU_LEGACY_H */

common/emu_limits.h

@@ -28,74 +28,98 @@
 namespace EntityLimits
 {
 	namespace NPC {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*NPC*/
 
 	namespace NPCMerchant {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*NPCMerchant*/
 
 	namespace Merc {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Merc*/
 
 	namespace Bot {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 8;
 
-		const size_t InvTypeTradeSize = 8;
+		} // namespace invtype
+
+		namespace invslot {
+			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
 
 	} /*Bot*/
 
 	namespace ClientPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace NPCPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace MercPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 
 	namespace BotPet {
-		enum : int { Invalid = -1, Null, Safety };
+		const int16 IINVALID = -1;
+		const int16 INULL = 0;
 
-		enum : bool { False = false, True = true };
+		namespace invtype {
+			const int16 TRADE_SIZE = 4;
 
-		const size_t InvTypeTradeSize = 4;
+		} // namespace invtype
 
 	} /*Pet*/
 

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_limits.h

@@ -20,7 +20,6 @@
 #ifndef COMMON_EQ_LIMITS_H
 #define COMMON_EQ_LIMITS_H
 
-#include "emu_legacy.h"
 #include "types.h"
 #include "eq_constants.h"
 #include "emu_versions.h"
@@ -34,10 +33,166 @@
 
 namespace EQEmu
 {
+	void InitializeDynamicLookups();
+
 	namespace constants {
-		class LookupEntry {
-		public:
-			size_t CharacterCreationLimit;
+		struct LookupEntry {
+			EQEmu::expansions::Expansion Expansion;
+			uint32 ExpansionBit;
+			uint32 ExpansionsMask;
+			int16 CharacterCreationLimit;
+			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)
+			{ }
+		};
+
+		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 {
+		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 CorpseBitmask..size is not dependent)
+
+			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;
+			int16 AugSocketCount;
+
+			bool AllowEmptyBagInBag;
+			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)
+			{ }
+		};
+
+		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 {
+		struct LookupEntry {
+			bool CoinHasWeight;
+
+			LookupEntry(const LookupEntry *lookup_entry) { }
+			LookupEntry(
+				bool CoinHasWeight
+			) :
+				CoinHasWeight(CoinHasWeight)
+			{ }
+		};
+
+		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;
@@ -45,56 +200,69 @@ namespace EQEmu
 			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);
 
-		const LookupEntry* Lookup(versions::ClientVersion client_version);
-
-	} /*constants*/
-	
-	namespace inventory {
-		class LookupEntry {
-		public:
-			size_t InventoryTypeSize[25]; // should reflect EQEmu::inventory::typeCount referenced in emu_constants.h
-
-			uint64 PossessionsBitmask;
-			size_t ItemBagSize;
-			size_t ItemAugSize;
-
-			bool AllowEmptyBagInBag;
-			bool AllowClickCastFromBag;
-			bool ConcatenateInvTypeLimbo;
-			bool AllowOverLevelEquipment;
-		};
-
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
-
-	} /*inventory*/
-	
-	namespace behavior {
-		class LookupEntry {
-		public:
-			bool CoinHasWeight;
-		};
-
-		const LookupEntry* Lookup(versions::MobVersion mob_version);
-
-	} /*behavior*/
+	} /*spells*/
 
 } /*EQEmu*/
 
 namespace ClientUnknown
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
+	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
 {
-	enum : int { Invalid = -1, Null, Safety };
+	const int16 IINVALID = -1;
+	const int16 INULL = 0;
 
-	enum : bool { False = false, True = true };
+	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*/
 

common/eq_packet.h

@@ -51,6 +51,7 @@ protected:
 	EmuOpcode emu_opcode;
 
 	EQPacket(EmuOpcode opcode, const unsigned char *buf, const uint32 len);
+	EQPacket(EmuOpcode opcode, SerializeBuffer &buf) : BasePacket(buf), emu_opcode(opcode) { };
 //	EQPacket(const EQPacket &p) { }
 	EQPacket() { emu_opcode=OP_Unknown; pBuffer=nullptr; size=0; }
 
@@ -104,6 +105,8 @@ public:
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	EQApplicationPacket(const EmuOpcode op, const unsigned char *buf, const uint32 len) : EQPacket(op, buf, len), opcode_bypass(0)
 		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
+	EQApplicationPacket(const EmuOpcode op, SerializeBuffer &buf) : EQPacket(op, buf), opcode_bypass(0)
+		{ app_opcode_size = GetExecutablePlatform() == ExePlatformUCS ? 1 : 2; }
 	bool combine(const EQApplicationPacket *rhs);
 	uint32 serialize (uint16 opcode, unsigned char *dest) const;
 	uint32 Size() const { return size+app_opcode_size; }

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*/
 };
 
 /*
@@ -731,7 +734,7 @@ struct BandolierItem_Struct
 struct Bandolier_Struct
 {
 	char Name[32];
-	BandolierItem_Struct Items[EQEmu::legacy::BANDOLIER_ITEM_COUNT];
+	BandolierItem_Struct Items[EQEmu::profile::BANDOLIER_ITEM_COUNT];
 };
 
 //len = 72
@@ -745,7 +748,7 @@ struct PotionBeltItem_Struct
 //len = 288
 struct PotionBelt_Struct
 {
-	PotionBeltItem_Struct Items[EQEmu::legacy::POTION_BELT_ITEM_COUNT];
+	PotionBeltItem_Struct Items[EQEmu::profile::POTION_BELT_SIZE];
 };
 
 struct MovePotionToBelt_Struct
@@ -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
@@ -1049,7 +1048,7 @@ struct PlayerProfile_Struct
 /*7212*/	uint32				tribute_points;
 /*7216*/	uint32				unknown7252;
 /*7220*/	uint32				tribute_active;		//1=active
-/*7224*/	Tribute_Struct		tributes[EQEmu::legacy::TRIBUTE_SIZE];
+/*7224*/	Tribute_Struct		tributes[EQEmu::invtype::TRIBUTE_SIZE];
 /*7264*/	Disciplines_Struct	disciplines;
 /*7664*/	uint32				recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
 /*7744*/	char				unknown7780[160];
@@ -1076,7 +1075,7 @@ struct PlayerProfile_Struct
 /*12800*/	uint32				expAA;
 /*12804*/	uint32				aapoints;			//avaliable, unspent
 /*12808*/	uint8				unknown12844[36];
-/*12844*/	Bandolier_Struct	bandoliers[EQEmu::legacy::BANDOLIERS_SIZE];
+/*12844*/	Bandolier_Struct	bandoliers[EQEmu::profile::BANDOLIERS_SIZE];
 /*14124*/	uint8				unknown14160[4506];
 /*18630*/	SuspendedMinion_Struct	SuspendedMinion; // No longer in use
 /*19240*/	uint32				timeentitledonaccount;
@@ -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;
 };
 
 
@@ -1181,15 +1192,15 @@ struct SpecialMesg_Struct
 ** 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*/
 };
 
@@ -1783,6 +1794,15 @@ struct CombatAbility_Struct {
 	uint32 m_skill;
 };
 
+// Disarm Struct incoming from Client [Size: 16]
+struct Disarm_Struct
+{
+	uint32 source;
+	uint32 target;
+	uint32 skill;
+	uint32 unknown;
+};
+
 //Instill Doubt
 struct Instill_Doubt_Struct {
 	uint8 i_id;
@@ -3449,8 +3469,8 @@ struct SelectTributeReply_Struct {
 
 struct TributeInfo_Struct {
 	uint32	active;		//0 == inactive, 1 == active
-	uint32	tributes[EQEmu::legacy::TRIBUTE_SIZE];	//-1 == NONE
-	uint32	tiers[EQEmu::legacy::TRIBUTE_SIZE];		//all 00's
+	uint32	tributes[EQEmu::invtype::TRIBUTE_SIZE];	//-1 == NONE
+	uint32	tiers[EQEmu::invtype::TRIBUTE_SIZE];		//all 00's
 	uint32	tribute_master_id;
 };
 
@@ -3782,7 +3802,7 @@ struct AcceptNewTask_Struct {
 //was all 0's from client, server replied with same op, all 0's
 struct CancelTask_Struct {
 	uint32 SequenceNumber;
-	uint32 unknown4; // Only seen 0x00000002
+	uint32 type; // Only seen 0x00000002
 };
 
 #if 0
@@ -3836,28 +3856,28 @@ struct AvailableTaskTrailer_Struct {
 struct TaskDescriptionHeader_Struct {
 	uint32	SequenceNumber; // The order the tasks appear in the journal. 0 for first task, 1 for second, etc.
 	uint32	TaskID;
-	uint32	unknown2;
-	uint32	unknown3;
-	uint8	unknown4;
+	uint8	open_window;
+	uint32	task_type;
+	uint32	reward_type; // if this != 4 says Ebon Crystals else Radiant Crystals
 };
 
 struct TaskDescriptionData1_Struct {
 	uint32	Duration;
-	uint32	unknown2;
+	uint32	dur_code; // if Duration == 0
 	uint32	StartTime;
 };
 
 struct TaskDescriptionData2_Struct {
-	uint32	RewardCount; // ??
-	uint32	unknown1;
-	uint32	unknown2;
-	uint16	unknown3;
-	//uint8	unknown4;
+	uint8 	has_rewards;
+	uint32	coin_reward;
+	uint32	xp_reward;
+	uint32	faction_reward;
 };
 
 struct TaskDescriptionTrailer_Struct {
 	//uint16	unknown1; // 0x0012
 	uint32	Points;
+	uint8	has_reward_selection; // uses newer reward selection window, not in all clients
 };
 
 struct TaskActivityHeader_Struct {
@@ -3897,11 +3917,11 @@ struct TaskActivityShort_Struct {
 
 struct TaskActivityComplete_Struct {
 	uint32	TaskIndex;
-	uint32	unknown2; // 0x00000002
-	uint32	unknown3;
+	uint32	TaskType; // task, shared task, quest
+	uint32	TaskID;		// must match
 	uint32	ActivityID;
-	uint32	unknown4; // 0x00000001
-	uint32	unknown5; // 0x00000001
+	uint32	task_completed; // Broadcasts "Task '%1' Completed" it not 0 and "Task '%1' Failed." if 0
+	uint32	stage_complete; // Broadcasts "Task Stage Completed"
 };
 
 #if 0
@@ -4361,7 +4381,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...
 };
 
@@ -5302,7 +5322,7 @@ struct MercenaryMerchantResponse_Struct {
 struct ServerLootItem_Struct {
 	uint32	item_id;	  // uint32	item_id;
 	int16	equip_slot;	  // int16	equip_slot;
-	uint16	charges;	  // uint8	charges; 
+	uint16	charges;	  // uint8	charges;
 	uint16	lootslot;	  // uint16	lootslot;
 	uint32	aug_1;		  // uint32	aug_1;
 	uint32	aug_2;		  // uint32	aug_2;
@@ -5330,7 +5350,7 @@ struct ClientMarqueeMessage_Struct {
 	uint32 fade_out_time; //The fade out time, in ms
 	uint32 duration; //in ms
 	char msg[1]; //message plus null terminator
-	
+
 };
 
 typedef std::list<ServerLootItem_Struct*> ItemList;

common/eq_stream_intf.h

@@ -6,6 +6,8 @@
 #include <string>
 #include "emu_versions.h"
 #include "eq_packet.h"
+#include "net/daybreak_connection.h"
+#include "event/event_loop.h"
 
 typedef enum {
 	ESTABLISHED,
@@ -18,6 +20,59 @@ typedef enum {
 class EQApplicationPacket;
 class OpcodeManager;
 
+struct EQStreamManagerInterfaceOptions
+{
+	EQStreamManagerInterfaceOptions() {
+		opcode_size = 2;
+		loop = &EQ::EventLoop::GetDefault();
+	}
+
+	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;
+		loop = &EQ::EventLoop::GetDefault();
+	}
+
+	int opcode_size;
+	EQ::Net::DaybreakConnectionManagerOptions daybreak_options;
+	EQ::EventLoop *loop;
+};
+
+enum EQStreamPriority : int32_t {
+	High,
+	Normal,
+	Low
+};
+
+class EQStreamInterface;
+class EQStreamManagerInterface
+{
+public:
+	EQStreamManagerInterface(const EQStreamManagerInterfaceOptions &options) { m_options = options; }
+	virtual ~EQStreamManagerInterface() { };
+
+	const EQStreamManagerInterfaceOptions& GetOptions() const { return m_options; }
+	EQStreamManagerInterfaceOptions& MutateOptions() { return m_options; }
+
+	virtual void OnNewConnection(std::function<void(std::shared_ptr<EQStreamInterface>)> func) = 0;
+	virtual void OnConnectionStateChange(std::function<void(std::shared_ptr<EQStreamInterface>, EQ::Net::DbProtocolStatus, EQ::Net::DbProtocolStatus)> func) = 0;
+	virtual void SetPriority(EQStreamPriority priority) = 0;
+protected:
+	EQStreamManagerInterfaceOptions m_options;
+};
+
 class EQStreamInterface {
 public:
 	virtual ~EQStreamInterface() {}
@@ -29,12 +84,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 +113,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_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"
@@ -33,106 +34,151 @@
 std::ofstream process_log;
 
 #ifdef _WINDOWS
-	#include <direct.h>
-	#include <conio.h>
-	#include <iostream>
-	#include <dos.h>
-	#include <windows.h>
-	#include <process.h>
+#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
 	};
 }
 
+enum GameChatColor {
+	yellow       = 15,
+	red          = 13,
+	light_green  = 14,
+	light_cyan   = 258,
+	light_purple = 5
+};
+
+/**
+ * EQEmuLogSys Constructor
+ */
 EQEmuLogSys::EQEmuLogSys()
 {
-	on_log_gmsay_hook = [](uint16 log_type, const std::string&) {};
+	on_log_gmsay_hook      = [](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 +190,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 +224,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 +235,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 +268,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 +296,68 @@ 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 GameChatColor::yellow;
 		case Logs::MySQLError:
 		case Logs::Error:
-			return 13; /* Red */
+			return GameChatColor::red;
 		case Logs::MySQLQuery:
 		case Logs::Debug:
-			return 14; /* Light Green */
+			return GameChatColor::light_green;
 		case Logs::Quests:
-			return 258; /* Light Cyan */
+			return GameChatColor::light_cyan;
 		case Logs::Commands:
 		case Logs::Mercenaries:
-			return 5; /* Light Purple */
+			return GameChatColor::light_purple;
 		case Logs::Crash:
-			return 13; /* Red */
+			return GameChatColor::red;
 		default:
-			return 15; /* Yellow */
+			return GameChatColor::yellow;
 	}
 }
 
+/**
+ * @param debug_level
+ * @param log_category
+ * @param message
+ */
 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-
-	#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
+#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
 }
 
+/**
+ * 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 +374,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,20 +385,32 @@ 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
@@ -315,8 +420,9 @@ void EQEmuLogSys::MakeDirectory(const std::string &directory_name)
 	_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 +434,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;
-
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
-		if (!log_name.empty())
-			platform_file_name = log_name;
-
-		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::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);
 	}
-}
+
+	/**
+	 * Zone
+	 */
+	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone) {
+		if (!log_name.empty()) {
+			platform_file_name = log_name;
+		}
+
+		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());
+
+		/**
+		 * Make directory if not exists
+		 */
+		EQEmuLogSys::MakeDirectory("logs/zone");
+
+		/**
+		 * 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,128 +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,
-	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"
-};
+	/**
+	 * 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 {
@@ -163,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;
@@ -203,32 +213,62 @@ 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; }
 
 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;
 
-	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,39 +0,0 @@
-#pragma once
-#include <functional>
-#include "event_loop.h"
-
-namespace EQ {
-	class BackgroundTask
-	{
-	public:
-		typedef std::function<void(void)> BackgroundTaskFunction;
-		struct BackgroundTaskBaton
-		{
-			BackgroundTaskFunction fn;
-			BackgroundTaskFunction on_finish;
-		};
-
-		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish) {
-			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;
-		
-			m_work->data = baton;
-			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->fn();
-			}, [](uv_work_t* req, int status) {
-				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
-				baton->on_finish();
-				delete baton;
-				delete req;
-			});
-		}
-
-		~BackgroundTask() {
-
-		}
-	};
-}

common/event/event_loop.h

@@ -7,15 +7,20 @@ namespace EQ
 {
 	class EventLoop
 	{
-	public:
-		static EventLoop &Get() {
-			static EventLoop inst;
-			return inst;
+	public:		
+		EventLoop() {
+			memset(&m_loop, 0, sizeof(uv_loop_t));
+			uv_loop_init(&m_loop);
 		}
 
 		~EventLoop() {
 			uv_loop_close(&m_loop);
 		}
+		
+		static EventLoop &GetDefault() {
+			static EventLoop inst;
+			return inst;
+		}
 
 		void Process() {
 			uv_run(&m_loop, UV_RUN_NOWAIT);
@@ -23,12 +28,7 @@ namespace EQ
 
 		uv_loop_t* Handle() { return &m_loop; }
 
-	private:
-		EventLoop() {
-			memset(&m_loop, 0, sizeof(uv_loop_t));
-			uv_loop_init(&m_loop);
-		}
-		
+	private:		
 		EventLoop(const EventLoop&);
 		EventLoop& operator=(const EventLoop&);
 	

common/event/task.h

@@ -0,0 +1,107 @@
+#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(EQ::EventLoop *loop, TaskFn fn) {
+			m_loop = loop;
+			m_fn = fn;
+		}
+
+		Task(TaskFn fn) {
+			m_loop = &EQ::EventLoop::GetDefault();
+			m_fn = fn;
+		}
+
+		~Task() {
+
+		}
+
+		Task& Then(ResolveFn fn) {
+			m_then = fn;
+			return *this;
+		}
+
+		Task& Catch(RejectFn fn) {
+			m_catch = fn;
+			return *this;
+		}
+
+		Task& Finally(FinallyFn fn) {
+			m_finally = fn;
+			return *this;
+		}
+
+		void Run() {
+			uv_work_t *m_work = new uv_work_t;
+			memset(m_work, 0, sizeof(uv_work_t));
+			TaskBaton *baton = new TaskBaton();
+			baton->fn = m_fn;
+			baton->on_then = m_then;
+			baton->on_catch = m_catch;
+			baton->on_finally = m_finally;
+			baton->has_result = false;
+			baton->has_error = false;
+
+			m_work->data = baton;
+
+			uv_queue_work(m_loop->Handle(), m_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:
+		EQ::EventLoop *m_loop;
+		TaskFn m_fn;
+		ResolveFn m_then;
+		RejectFn m_catch;
+		FinallyFn m_finally;
+	};
+}

common/event/timer.h

@@ -6,14 +6,31 @@ namespace EQ {
 	class Timer
 	{
 	public:
-		Timer(std::function<void(Timer *)> cb)
+		Timer(EQ::EventLoop *loop, std::function<void(Timer *)> cb)
 		{
+			m_loop = loop;
 			m_timer = nullptr;
 			m_cb = cb;
 		}
 
+		Timer(std::function<void(Timer *)> cb)
+		{
+			m_loop = &EQ::EventLoop::GetDefault();
+			m_timer = nullptr;
+			m_cb = cb;
+		}
+
+		Timer(EQ::EventLoop *loop, uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
+		{
+			m_loop = loop;
+			m_timer = nullptr;
+			m_cb = cb;
+			Start(duration_ms, repeats);
+		}
+
 		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
 		{
+			m_loop = &EQ::EventLoop::GetDefault();
 			m_timer = nullptr;
 			m_cb = cb;
 			Start(duration_ms, repeats);
@@ -25,7 +42,7 @@ namespace EQ {
 		}
 
 		void Start(uint64_t duration_ms, bool repeats) {
-			auto loop = EventLoop::Get().Handle();
+			auto loop = m_loop->Handle();
 			if (!m_timer) {
 				m_timer = new uv_timer_t;
 				memset(m_timer, 0, sizeof(uv_timer_t));
@@ -61,6 +78,7 @@ namespace EQ {
 			m_cb(this);
 		}
 	
+		EQ::EventLoop *m_loop;
 		uv_timer_t *m_timer;
 		std::function<void(Timer*)> m_cb;
 	};

common/event_sub.cpp

@@ -1,5 +1,4 @@
 #include "event_sub.h"
-#include <string.h>
 
 void EventSubscriptionWatcher::Subscribe(const std::string &event_name)
 {

common/event_sub.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <unordered_map>
+#include <string>
 
 class EventSubscriptionWatcher
 {

common/faction.cpp

@@ -59,31 +59,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 >= 1100) {
 		return FACTION_ALLY;
 	}
-	if (character_value >= 701 && character_value <= 1100) {
+	if (character_value >= 750 && character_value <= 1099) {
 		return FACTION_WARMLY;
 	}
-	if (character_value >= 401 && character_value <= 700) {
+	if (character_value >= 500 && character_value <= 749) {
 		return FACTION_KINDLY;
 	}
-	if (character_value >= 101 && character_value <= 400) {
+	if (character_value >= 100 && character_value <= 499) {
 		return FACTION_AMIABLE;
 	}
-	if (character_value >= 0 && character_value <= 100) {
+	if (character_value >= 0 && character_value <= 99) {
 		return FACTION_INDIFFERENT;
 	}
 	if (character_value >= -100 && character_value <= -1) {
 		return FACTION_APPREHENSIVE;
 	}
-	if (character_value >= -700 && character_value <= -101) {
+	if (character_value >= -500 && character_value <= -101) {
 		return FACTION_DUBIOUS;
 	}
-	if (character_value >= -999 && character_value <= -701) {
+	if (character_value >= -750 && character_value <= -501) {
 		return FACTION_THREATENLY;
 	}
-	if (character_value <= -1000) {
+	if (character_value <= -751) {
 		return FACTION_SCOWLS;
 	}
 	return FACTION_INDIFFERENT;

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,10 +150,11 @@ 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,
+	AI_scan_door_open_interval = 1000,
 	// AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
 	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed
@@ -267,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

common/glm/glm/detail/type_mat2x3.hpp

@@ -1,165 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x3.hpp
-
-#pragma once
-
-#include "../fwd.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_mat.hpp"
-#include <limits>
-#include <cstddef>
-
-namespace glm
-{
-	template <typename T, precision P = defaultp>
-	struct tmat2x3
-	{
-		typedef tvec3<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x3<T, P> type;
-		typedef tmat3x2<T, P> transpose_type;
-		typedef T value_type;
-
-	private:
-		col_type value[2];
-
-	public:
-		// -- Constructors --
-
-		GLM_FUNC_DECL tmat2x3() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x3(tmat2x3<T, Q> const & m);
-
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x3(ctor);
-		GLM_FUNC_DECL explicit tmat2x3(T scalar);
-		GLM_FUNC_DECL tmat2x3(
-			T x0, T y0, T z0,
-			T x1, T y1, T z1);
-		GLM_FUNC_DECL tmat2x3(
-			col_type const & v0,
-			col_type const & v1);
-
-		// -- Conversions --
-
-		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
-		GLM_FUNC_DECL tmat2x3(
-			X1 x1, Y1 y1, Z1 z1,
-			X2 x2, Y2 y2, Z2 z2);
-
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x3(
-			tvec3<U, P> const & v1,
-			tvec3<V, P> const & v2);
-
-		// -- Matrix conversions --
-
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x3<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat2x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x3(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 tmat2x3<T, P> & operator=(tmat2x3<T, P> const & m) GLM_DEFAULT;
-
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator+=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-=(tmat2x3<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x3<T, P> & operator/=(U s);
-
-		// -- Increment and decrement operators --
-
-		GLM_FUNC_DECL tmat2x3<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x3<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x3<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x3<T, P> operator--(int);
-	};
-
-	// -- Unary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m);
-
-	// -- Binary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(T scalar, tmat2x3<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x3<T, P>::col_type operator*(tmat2x3<T, P> const & m, typename tmat2x3<T, P>::row_type const & v);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x3<T, P>::row_type operator*(typename tmat2x3<T, P>::col_type const & v, tmat2x3<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x3<T, P> operator/(T scalar, tmat2x3<T, P> const & m);
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2);
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x3.inl"
-#endif

common/glm/glm/detail/type_mat2x3.inl

@@ -1,458 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x3.inl
-
-namespace glm
-{
-	// -- Constructors --
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P> 
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3()
-		{
-#			ifndef GLM_FORCE_NO_CTOR_INIT 
-				this->value[0] = col_type(1, 0, 0);
-				this->value[1] = col_type(0, 1, 0);
-#			endif
-		}
-#	endif
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<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 tmat2x3<T, P>::tmat2x3(tmat2x3<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 tmat2x3<T, P>::tmat2x3(ctor)
-	{}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(T scalar)
-	{
-		this->value[0] = col_type(scalar, 0, 0);
-		this->value[1] = col_type(0, scalar, 0);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
-	(
-		T x0, T y0, T z0,
-		T x1, T y1, T z1
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0);
-		this->value[1] = col_type(x1, y1, z1);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(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 Z1,
-		typename X2, typename Y2, typename Z2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
-	(
-		X1 x1, Y1 y1, Z1 z1,
-		X2 x2, Y2 y2, Z2 z2
-	)
-	{
-		this->value[0] = col_type(static_cast<T>(x1), value_type(y1), value_type(z1));
-		this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2));
-	}
-	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tvec3<V1, P> const & v1, tvec3<V2, P> const & v2)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	// -- Matrix conversions --
-
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat2x3<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 tmat2x3<T, P>::tmat2x3(tmat2x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER  tmat2x3<T, P>::tmat2x3(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 tmat2x3<T, P>::tmat2x3(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 tmat2x3<T, P>::tmat2x3(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 tmat2x3<T, P>::tmat2x3(tmat3x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(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 tmat2x3<T, P>::tmat2x3(tmat4x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3(tmat4x3<T, P> const & m)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	// -- Accesses --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type & tmat2x3<T, P>::operator[](typename tmat2x3<T, P>::length_type i)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type const & tmat2x3<T, P>::operator[](typename tmat2x3<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 tmat2x3<T, P>& tmat2x3<T, P>::operator=(tmat2x3<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 tmat2x3<T, P>& tmat2x3<T, P>::operator=(tmat2x3<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 tmat2x3<T, P> & tmat2x3<T, P>::operator+=(U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator+=(tmat2x3<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 tmat2x3<T, P>& tmat2x3<T, P>::operator-=(U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P>& tmat2x3<T, P>::operator-=(tmat2x3<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 tmat2x3<T, P>& tmat2x3<T, P>::operator*=(U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator/=(U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		return *this;
-	}
-
-	// -- Increment and decrement operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator++()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> & tmat2x3<T, P>::operator--()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> tmat2x3<T, P>::operator++(int)
-	{
-		tmat2x3<T, P> Result(*this);
-		++*this;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> tmat2x3<T, P>::operator--(int)
-	{
-		tmat2x3<T, P> Result(*this);
-		--*this;
-		return Result;
-	}
-
-	// -- Unary arithmetic operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m)
-	{
-		return m;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m)
-	{
-		return tmat2x3<T, P>(
-			-m[0],
-			-m[1]);
-	}
-
-	// -- Binary arithmetic operators --
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m, T scalar)
-	{
-		return tmat2x3<T, P>(
-			m[0] + scalar,
-			m[1] + scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator+(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
-	{
-		return tmat2x3<T, P>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m, T scalar)
-	{
-		return tmat2x3<T, P>(
-			m[0] - scalar,
-			m[1] - scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator-(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
-	{
-		return tmat2x3<T, P>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat2x3<T, P> const & m, T scalar)
-	{
-		return tmat2x3<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(T scalar, tmat2x3<T, P> const & m)
-	{
-		return tmat2x3<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::col_type operator*
-	(
-		tmat2x3<T, P> const & m,
-		typename tmat2x3<T, P>::row_type const & v)
-	{
-		return typename tmat2x3<T, P>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y,
-			m[0][2] * v.x + m[1][2] * v.y);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x3<T, P>::row_type operator*
-	(
-		typename tmat2x3<T, P>::col_type const & v,
-		tmat2x3<T, P> const & m)
-	{
-		return typename tmat2x3<T, P>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return tmat2x3<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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat3x2<T, P> const & m2)
-	{
-		T SrcA00 = m1[0][0];
-		T SrcA01 = m1[0][1];
-		T SrcA02 = m1[0][2];
-		T SrcA10 = m1[1][0];
-		T SrcA11 = m1[1][1];
-		T SrcA12 = m1[1][2];
-
-		T SrcB00 = m2[0][0];
-		T SrcB01 = m2[0][1];
-		T SrcB10 = m2[1][0];
-		T SrcB11 = m2[1][1];
-		T SrcB20 = m2[2][0];
-		T SrcB21 = m2[2][1];
-
-		tmat3x3<T, P> Result(uninitialize);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x3<T, P> operator*(tmat2x3<T, P> const & m1, tmat4x2<T, P> const & m2)
-	{
-		return tmat4x3<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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
-			m1[0][0] * m2[3][0] + m1[1][0] * m2[3][1],
-			m1[0][1] * m2[3][0] + m1[1][1] * m2[3][1],
-			m1[0][2] * m2[3][0] + m1[1][2] * m2[3][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator/(tmat2x3<T, P> const & m, T scalar)
-	{
-		return tmat2x3<T, P>(
-			m[0] / scalar,
-			m[1] / scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x3<T, P> operator/(T scalar, tmat2x3<T, P> const & m)
-	{
-		return tmat2x3<T, P>(
-			scalar / m[0],
-			scalar / m[1]);
-	}
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x3<T, P> const & m1, tmat2x3<T, P> const & m2)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-} //namespace glm

common/glm/glm/detail/type_mat2x4.hpp

@@ -1,167 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x4.hpp
-
-#pragma once
-
-#include "../fwd.hpp"
-#include "type_vec2.hpp"
-#include "type_vec4.hpp"
-#include "type_mat.hpp"
-#include <limits>
-#include <cstddef>
-
-namespace glm
-{
-	template <typename T, precision P = defaultp>
-	struct tmat2x4
-	{
-		typedef tvec4<T, P> col_type;
-		typedef tvec2<T, P> row_type;
-		typedef tmat2x4<T, P> type;
-		typedef tmat4x2<T, P> transpose_type;
-		typedef T value_type;
-
-	private:
-		col_type value[2];
-
-	public:
-		// -- Constructors --
-
-		GLM_FUNC_DECL tmat2x4() GLM_DEFAULT_CTOR;
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, P> const & m) GLM_DEFAULT;
-		template <precision Q>
-		GLM_FUNC_DECL tmat2x4(tmat2x4<T, Q> const & m);
-
-		GLM_FUNC_DECL GLM_CONSTEXPR_CTOR explicit tmat2x4(ctor);
-		GLM_FUNC_DECL explicit tmat2x4(T scalar);
-		GLM_FUNC_DECL tmat2x4(
-			T x0, T y0, T z0, T w0,
-			T x1, T y1, T z1, T w1);
-		GLM_FUNC_DECL tmat2x4(
-			col_type const & v0,
-			col_type const & v1);
-
-		// -- Conversions --
-
-		template <
-			typename X1, typename Y1, typename Z1, typename W1,
-			typename X2, typename Y2, typename Z2, typename W2>
-		GLM_FUNC_DECL tmat2x4(
-			X1 x1, Y1 y1, Z1 z1, W1 w1,
-			X2 x2, Y2 y2, Z2 z2, W2 w2);
-
-		template <typename U, typename V>
-		GLM_FUNC_DECL tmat2x4(
-			tvec4<U, P> const & v1,
-			tvec4<V, P> const & v2);
-
-		// -- Matrix conversions --
-
-		template <typename U, precision Q>
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x4<U, Q> const & m);
-
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat2x3<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat3x4<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(tmat4x2<T, P> const & x);
-		GLM_FUNC_DECL GLM_EXPLICIT tmat2x4(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 tmat2x4<T, P> & operator=(tmat2x4<T, P> const & m) GLM_DEFAULT;
-
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator+=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator+=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-=(tmat2x4<U, P> const & m);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator*=(U s);
-		template <typename U>
-		GLM_FUNC_DECL tmat2x4<T, P> & operator/=(U s);
-
-		// -- Increment and decrement operators --
-
-		GLM_FUNC_DECL tmat2x4<T, P> & operator++ ();
-		GLM_FUNC_DECL tmat2x4<T, P> & operator-- ();
-		GLM_FUNC_DECL tmat2x4<T, P> operator++(int);
-		GLM_FUNC_DECL tmat2x4<T, P> operator--(int);
-	};
-
-	// -- Unary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m);
-
-	// -- Binary operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator+(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator-(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(T scalar, tmat2x4<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x4<T, P>::col_type operator*(tmat2x4<T, P> const & m, typename tmat2x4<T, P>::row_type const & v);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL typename tmat2x4<T, P>::row_type operator*(typename tmat2x4<T, P>::col_type const & v, tmat2x4<T, P> const & m);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat4x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat4x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat2x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat3x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat3x2<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T scalar);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL tmat2x4<T, P> operator/(T scalar, tmat2x4<T, P> const & m);
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
-
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2);
-}//namespace glm
-
-#ifndef GLM_EXTERNAL_TEMPLATE
-#include "type_mat2x4.inl"
-#endif

common/glm/glm/detail/type_mat2x4.inl

@@ -1,467 +0,0 @@
-/// @ref core
-/// @file glm/detail/type_mat2x4.inl
-
-namespace glm
-{
-	// -- Constructors --
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS || !defined(GLM_FORCE_NO_CTOR_INIT)
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4()
-		{
-#			ifndef GLM_FORCE_NO_CTOR_INIT 
-				this->value[0] = col_type(1, 0, 0, 0);
-				this->value[1] = col_type(0, 1, 0, 0);
-#			endif
-		}
-#	endif
-
-#	if !GLM_HAS_DEFAULTED_FUNCTIONS
-		template <typename T, precision P>
-		GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<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 tmat2x4<T, P>::tmat2x4(tmat2x4<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 tmat2x4<T, P>::tmat2x4(ctor)
-	{}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(T scalar)
-	{
-		value_type const Zero(0);
-		this->value[0] = col_type(scalar, Zero, Zero, Zero);
-		this->value[1] = col_type(Zero, scalar, Zero, Zero);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
-	(
-		T x0, T y0, T z0, T w0,
-		T x1, T y1, T z1, T w1
-	)
-	{
-		this->value[0] = col_type(x0, y0, z0, w0);
-		this->value[1] = col_type(x1, y1, z1, w1);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(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 Z1, typename W1,
-		typename X2, typename Y2, typename Z2, typename W2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
-	(
-		X1 x1, Y1 y1, Z1 z1, W1 w1,
-		X2 x2, Y2 y2, Z2 z2, W2 w2
-	)
-	{
-		this->value[0] = col_type(static_cast<T>(x1), value_type(y1), value_type(z1), value_type(w1));
-		this->value[1] = col_type(static_cast<T>(x2), value_type(y2), value_type(z2), value_type(w2));
-	}
-	
-	template <typename T, precision P>
-	template <typename V1, typename V2>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tvec4<V1, P> const & v1, tvec4<V2, P> const & v2)
-	{
-		this->value[0] = col_type(v1);
-		this->value[1] = col_type(v2);
-	}
-
-	// -- Matrix conversions --
-
-	template <typename T, precision P>
-	template <typename U, precision Q>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat2x4<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 tmat2x4<T, P>::tmat2x4(tmat2x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0, 0);
-		this->value[1] = col_type(m[1], 0, 0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(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 tmat2x4<T, P>::tmat2x4(tmat2x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0, 0);
-		this->value[1] = col_type(m[1], 0, 0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat3x4<T, P> const & m)
-	{
-		this->value[0] = m[0];
-		this->value[1] = m[1];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x2<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0, 0);
-		this->value[1] = col_type(m[1], 0, 0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4(tmat4x3<T, P> const & m)
-	{
-		this->value[0] = col_type(m[0], 0);
-		this->value[1] = col_type(m[1], 0);
-	}
-
-	// -- Accesses --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type & tmat2x4<T, P>::operator[](typename tmat2x4<T, P>::length_type i)
-	{
-		assert(i < this->length());
-		return this->value[i];
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type const & tmat2x4<T, P>::operator[](typename tmat2x4<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 tmat2x4<T, P>& tmat2x4<T, P>::operator=(tmat2x4<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 tmat2x4<T, P>& tmat2x4<T, P>::operator=(tmat2x4<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 tmat2x4<T, P>& tmat2x4<T, P>::operator+=(U s)
-	{
-		this->value[0] += s;
-		this->value[1] += s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator+=(tmat2x4<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 tmat2x4<T, P>& tmat2x4<T, P>::operator-=(U s)
-	{
-		this->value[0] -= s;
-		this->value[1] -= s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator-=(tmat2x4<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 tmat2x4<T, P>& tmat2x4<T, P>::operator*=(U s)
-	{
-		this->value[0] *= s;
-		this->value[1] *= s;
-		return *this;
-	}
-
-	template <typename T, precision P>
-	template <typename U>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> & tmat2x4<T, P>::operator/=(U s)
-	{
-		this->value[0] /= s;
-		this->value[1] /= s;
-		return *this;
-	}
-
-	// -- Increment and decrement operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator++()
-	{
-		++this->value[0];
-		++this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P>& tmat2x4<T, P>::operator--()
-	{
-		--this->value[0];
-		--this->value[1];
-		return *this;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> tmat2x4<T, P>::operator++(int)
-	{
-		tmat2x4<T, P> Result(*this);
-		++*this;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> tmat2x4<T, P>::operator--(int)
-	{
-		tmat2x4<T, P> Result(*this);
-		--*this;
-		return Result;
-	}
-
-	// -- Unary arithmetic operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m)
-	{
-		return m;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m)
-	{
-		return tmat2x4<T, P>(
-			-m[0], 
-			-m[1]);
-	}
-
-	// -- Binary arithmetic operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m, T scalar)
-	{
-		return tmat2x4<T, P>(
-			m[0] + scalar,
-			m[1] + scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator+(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
-	{
-		return tmat2x4<T, P>(
-			m1[0] + m2[0],
-			m1[1] + m2[1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m, T scalar)
-	{
-		return tmat2x4<T, P>(
-			m[0] - scalar,
-			m[1] - scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator-(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
-	{
-		return tmat2x4<T, P>(
-			m1[0] - m2[0],
-			m1[1] - m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat2x4<T, P> const & m, T scalar)
-	{
-		return tmat2x4<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(T scalar, tmat2x4<T, P> const & m)
-	{
-		return tmat2x4<T, P>(
-			m[0] * scalar,
-			m[1] * scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::col_type operator*(tmat2x4<T, P> const & m, typename tmat2x4<T, P>::row_type const & v)
-	{
-		return typename tmat2x4<T, P>::col_type(
-			m[0][0] * v.x + m[1][0] * v.y,
-			m[0][1] * v.x + m[1][1] * v.y,
-			m[0][2] * v.x + m[1][2] * v.y,
-			m[0][3] * v.x + m[1][3] * v.y);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER typename tmat2x4<T, P>::row_type operator*(typename tmat2x4<T, P>::col_type const & v, tmat2x4<T, P> const & m)
-	{
-		return typename tmat2x4<T, P>::row_type(
-			v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
-			v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat4x2<T, P> const & m2)
-	{
-		T SrcA00 = m1[0][0];
-		T SrcA01 = m1[0][1];
-		T SrcA02 = m1[0][2];
-		T SrcA03 = m1[0][3];
-		T SrcA10 = m1[1][0];
-		T SrcA11 = m1[1][1];
-		T SrcA12 = m1[1][2];
-		T SrcA13 = m1[1][3];
-
-		T SrcB00 = m2[0][0];
-		T SrcB01 = m2[0][1];
-		T SrcB10 = m2[1][0];
-		T SrcB11 = m2[1][1];
-		T SrcB20 = m2[2][0];
-		T SrcB21 = m2[2][1];
-		T SrcB30 = m2[3][0];
-		T SrcB31 = m2[3][1];
-
-		tmat4x4<T, P> Result(uninitialize);
-		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
-		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
-		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
-		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
-		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
-		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
-		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
-		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
-		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
-		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
-		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
-		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
-		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
-		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
-		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
-		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
-		return Result;
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat2x2<T, P> const & m2)
-	{
-		return tmat2x4<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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x4<T, P> operator*(tmat2x4<T, P> const & m1, tmat3x2<T, P> const & m2)
-	{
-		return tmat3x4<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][2] * m2[0][0] + m1[1][2] * m2[0][1],
-			m1[0][3] * m2[0][0] + m1[1][3] * m2[0][1],
-			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
-			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1],
-			m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1],
-			m1[0][3] * m2[1][0] + m1[1][3] * m2[1][1],
-			m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1],
-			m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1],
-			m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1],
-			m1[0][3] * m2[2][0] + m1[1][3] * m2[2][1]);
-	}
-
-	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(tmat2x4<T, P> const & m, T scalar)
-	{
-		return tmat2x4<T, P>(
-			m[0] / scalar,
-			m[1] / scalar);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x4<T, P> operator/(T scalar, tmat2x4<T, P> const & m)
-	{
-		return tmat2x4<T, P>(
-			scalar / m[0],
-			scalar / m[1]);
-	}
-
-	// -- Boolean operators --
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator==(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
-	{
-		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER bool operator!=(tmat2x4<T, P> const & m1, tmat2x4<T, P> const & m2)
-	{
-		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
-	}
-} //namespace glm