Merge master compile fixes

Merge fix
Merge pull request #650 from noudess/master
2026-05-22 20:33:01 +00:00 · 2017-09-17 13:34:35 -07:00 · 2017-09-17 13:20:48 -07:00 · 2017-09-17 11:19:48 -05:00 · 2017-09-17 12:11:02 -04:00 · 2017-09-17 10:16:13 -05:00
1473 changed files with 316188 additions and 42439 deletions
@@ -33,5 +33,7 @@ Build_32/
 build_32/
 Build_64/
 build_64/
+x64/
+x86/
 log/
 logs/
@@ -3,15 +3,23 @@ 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
+install:
+  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi
 script:
-  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
-  - make -j8
+  - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON -DEQEMU_BUILD_LOGIN=ON
+  - make -j2
  - ./bin/tests
 branches:
  only:
@@ -13,12 +13,6 @@
 #EQEMU_LOG_LEVEL_QUEST
 #EQEMU_LOG_LEVEL_COMMANDS
 #EQEMU_LOG_LEVEL_CRASH
-#EQEMU_STREAM_SEND_RATE
-#EQEMU_STREAM_DECAY_RATE
-#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL
-#EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX
-#EQEMU_STREAM_AVERAGE_DELTA_MAX
-#EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS
 #EQEMU_DEPOP_INVALIDATES_CACHE
 #EQEMU_ENABLE_BOTS
 #EQEMU_DISABLE_LOGSYS
@@ -64,10 +58,28 @@ IF(MSVC)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x64")
 		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x64")
+		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x64")
+		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
+		IF(MSVC_VERSION GREATER 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v140/dynamic")
+		ELSEIF(MSVC_VERSION EQUAL 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v120/dynamic")
+		ELSE()
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v110/dynamic")
+		ENDIF()
 	ELSE(CMAKE_CL_64)
 		SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86")
 		SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86")
 		SET(LUA_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/luaj_x86")
+		SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include")
+		SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86")
+		IF(MSVC_VERSION GREATER 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic")
+		ELSEIF(MSVC_VERSION EQUAL 1800)
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v120/dynamic")
+		ELSE()
+			SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v110/dynamic")
+		ENDIF()
 	ENDIF(CMAKE_CL_64)

 	#disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere
@@ -219,14 +231,6 @@ SET(EQEMU_LOG_LEVEL_CRASH 3 CACHE STRING "EQEmu logging level for [Crash]:

 MARK_AS_ADVANCED(EQEMU_LOG_LEVEL_STATUS EQEMU_LOG_LEVEL_NORMAL EQEMU_LOG_LEVEL_ERROR EQEMU_LOG_LEVEL_DEBUG EQEMU_LOG_LEVEL_QUEST EQEMU_LOG_LEVEL_COMMANDS EQEMU_LOG_LEVEL_CRASH)

-SET(EQEMU_STREAM_SEND_RATE 1048576 CACHE STRING "Advanced: Base amount of data stream can send before throttle.")
-SET(EQEMU_STREAM_DECAY_RATE 78642 CACHE STRING "Advanced: Base amount of data stream recovers per tic.")
-SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL 3.0 CACHE STRING "Advanced: Multiplier on retransmit timeout.")
-SET(EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX 5000 CACHE STRING "Advanced: Max in ms for retransmit timeout timer.")
-SET(EQEMU_STREAM_AVERAGE_DELTA_MAX 2500 CACHE STRING "Advanced: The maximum average delta in ms allowed.")
-SET(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS TRUE CACHE BOOL "Advanced: Whether or not acked packets can be retransmitted")
-MARK_AS_ADVANCED(EQEMU_STREAM_SEND_RATE EQEMU_STREAM_DECAY_RATE EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX EQEMU_STREAM_AVERAGE_DELTA_MAX EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-
 #NPC Types Cache Behavior
 OPTION(EQEMU_DEPOP_INVALIDATES_CACHE "#repop invalidates the npc_types cache (will cause a larger database hit on #repop but is more convienent)." ON)

@@ -254,6 +258,7 @@ ENDIF(EQEMU_ENABLE_BOTS)
 #What to build
 OPTION(EQEMU_BUILD_SERVER "Build the game server." ON)
 OPTION(EQEMU_BUILD_LOGIN "Build the login server." OFF)
+OPTION(EQEMU_BUILD_HC "Build the headless client." OFF)
 OPTION(EQEMU_BUILD_TESTS "Build utility tests." OFF)
 OPTION(EQEMU_BUILD_PERL "Build Perl parser." ON)
 OPTION(EQEMU_BUILD_LUA "Build Lua parser." ON)
@@ -287,11 +292,6 @@ ADD_DEFINITIONS(-DEQDEBUG=${EQEMU_DEBUG_LEVEL})
 ADD_DEFINITIONS(-DINVERSEXY)
 ADD_DEFINITIONS(-DFIELD_ITEMS)
 ADD_DEFINITIONS(-DMAP_DIR="${EQEMU_MAP_DIR}")
-ADD_DEFINITIONS(-DRATEBASE=${EQEMU_STREAM_SEND_RATE})
-ADD_DEFINITIONS(-DDECAYBASE=${EQEMU_STREAM_DECAY_RATE})
-ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MULT=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MUL})
-ADD_DEFINITIONS(-DRETRANSMIT_TIMEOUT_MAX=${EQEMU_STREAM_RETRANSMIT_TIMEOUT_MAX})
-ADD_DEFINITIONS(-DAVERAGE_DELTA_MAX=${EQEMU_STREAM_AVERAGE_DELTA_MAX})
 ADD_DEFINITIONS(-DLOG_LEVEL_STATUS=${EQEMU_LOG_LEVEL_STATUS})
 ADD_DEFINITIONS(-DLOG_LEVEL_NORMAL=${EQEMU_LOG_LEVEL_NORMAL})
 ADD_DEFINITIONS(-DLOG_LEVEL_ERROR=${EQEMU_LOG_LEVEL_ERROR})
@@ -301,12 +301,6 @@ ADD_DEFINITIONS(-DLOG_LEVEL_COMMANDS=${EQEMU_LOG_LEVEL_COMMANDS})
 ADD_DEFINITIONS(-DLOG_LEVEL_CRASH=${EQEMU_LOG_LEVEL_CRASH})
 ADD_DEFINITIONS(-DGLM_FORCE_RADIANS)

-IF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=true)
-ELSE(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-	ADD_DEFINITIONS(-DRETRANSMIT_ACKED_PACKETS=false)
-ENDIF(EQEMU_STREAM_RETRANSMIT_ACKED_PACKETS)
-
 #Find everything we need
 FIND_PACKAGE(ZLIB REQUIRED)
 FIND_PACKAGE(MySQL REQUIRED)
@@ -315,6 +309,30 @@ 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 recast_navigation)
+
+FIND_PACKAGE(Sodium REQUIRED)
+IF(SODIUM_FOUND)
+	OPTION(EQEMU_ENABLE_SECURITY "Use Encryption For TCP Connections" ON)
+	IF(EQEMU_ENABLE_SECURITY)
+		INCLUDE_DIRECTORIES(SYSTEM "${SODIUM_INCLUDE_DIRS}")
+		ADD_DEFINITIONS(-DENABLE_SECURITY)
+		SET(SERVER_LIBS ${SERVER_LIBS} ${SODIUM_LIBRARIES})
+	ENDIF()
+ENDIF()
+
+IF(WIN32)
+	SET(SERVER_LIBS ${SERVER_LIBS} "ws2_32" "psapi" "iphlpapi" "userenv")
+ENDIF()
+
+IF(UNIX)
+	SET(SERVER_LIBS ${SERVER_LIBS} ${CMAKE_DL_LIBS} "z" "m" "pthread")
+	IF(NOT DARWIN)
+		SET(SERVER_LIBS ${SERVER_LIBS} "rt")
+	ENDIF()
+	SET(SERVER_LIBS ${SERVER_LIBS} "uuid")
+ENDIF()
+
 IF(EQEMU_BUILD_LUA)
 	FIND_PACKAGE(EQLua51 REQUIRED)
 	SET(Boost_USE_STATIC_LIBS OFF)
@@ -323,7 +341,8 @@ IF(EQEMU_BUILD_LUA)
 	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")

 	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
+	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}")
+	INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/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)
@@ -331,15 +350,20 @@ IF(EQEMU_BUILD_LUA)
 	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
 ENDIF(EQEMU_BUILD_LUA)

-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}")
+INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" )
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/detour/include")
+INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/recast/recast/include")

-IF(EQEMU_BUILD_LUA)
-    ADD_SUBDIRECTORY(luabind)
-ENDIF(EQEMU_BUILD_LUA)
-
-IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
+IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 	ADD_SUBDIRECTORY(common)
-ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
+	ADD_SUBDIRECTORY(libs)
+ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC)
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)
 	ADD_SUBDIRECTORY(world)
@@ -352,6 +376,10 @@ IF(EQEMU_BUILD_LOGIN)
 	ADD_SUBDIRECTORY(loginserver)
 ENDIF(EQEMU_BUILD_LOGIN)

+IF(EQEMU_BUILD_HC)
+	ADD_SUBDIRECTORY(hc)
+ENDIF(EQEMU_BUILD_HC)
+
 IF(EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(tests)
 ENDIF(EQEMU_BUILD_TESTS)
@@ -8,26 +8,26 @@
 **EQEmulator is a custom completely from-scratch open source server implementation for EverQuest built mostly on C++**
 * MySQL/MariaDB is used as the database engine (over 200+ tables)
 * Perl and LUA are both supported scripting languages for NPC/Player/Quest oriented events
- * Open source database (Project EQ) has content up to expansion GoD (included in server installs)
+ * Open source database (Project EQ) has content up to expansion OoW (included in server installs)
  * Game server environments and databases can be heavily customized to create all new experiences
 * Hundreds of Quests/events created and maintained by Project EQ

 ## Server Installs
-||Windows|Linux|
+| |Windows|Linux|
 |:---:|:---:|:---:|
 |**Install Count**|![Windows Install Count](http://analytics.akkadius.com/?install_count&windows_count)|![Linux Install Count](http://analytics.akkadius.com/?install_count&linux_count)| 
 ### > Windows 
 * [Easy Install](http://wiki.eqemulator.org/p?Akkas_PEQ_Server_Installer&frm=Main#from-scratch-installation-instructions-windows)
 * [Advanced Setup](http://wiki.eqemulator.org/p?Complete_Windows-based_Server_Setup_Guide)

-### > Debian/Ubuntu
+
+
+### > Debian/Ubuntu/CentOS/Fedora
+* You can use curl or wget to kick off the installer (whichever your OS has)
+> curl -O https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh install.sh && chmod 755 install.sh && ./install.sh

 > wget --no-check-certificate https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh -O install.sh && chmod 755 install.sh && ./install.sh

-### > CentOS/Fedora
-
-> curl -O https://raw.githubusercontent.com/EQEmu/Server/master/utils/scripts/linux_installer/install.sh install.sh && chmod 755 install.sh && ./install.sh
-
 ## Supported Clients

 |Titanium Edition|Secrets of Faydwer|Seeds of Destruction|Underfoot|Rain of Fear|
@@ -1,5 +1,283 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+
+== 9/17/2017 ==
+Akkadius: Add model/race offset to FixZ calc (KLS)
+Akkadius: Fix 95% of food/water consumption issues, if there are additional modifiers for race/class combos - those will need to be applied
+
+Stages should be put in place if not already:
+https://wiki.project1999.com/Food_and_drink#Stages_of_Hunger_and_Thirst
+
+Values stored in the database are 0-6000, previously we capped it at 6000 but previous math would have normal values in the 60k+ range in order for food to be consumed at a reasonable rate. We are now using more native logic where 1 = 1 minute, following logic:
+
+(Minutes)
+0 -  5	- This is a snack.
+6 -  20	- This is a meal.
+21 - 30	- This is a hearty meal.
+31 - 40	- This is a banquet size meal.
+41 - 50	- This meal is a feast!
+51 - 60	- This is an enduring meal!
+61 - X	- This is a miraculous meal!
+
+== 7/14/2017 ==
+Akkadius: HP Update tuning - HP Updates are now forced when a client is targeted
+Akkadius: Client position updates should be smoother (granted the client has a good connection)
+	- Clients should also no longer randomly disappear 
+
+== 7/11/2017 ==
+Akkadius: Raid/Group/XTarget HP/Mana/Endurance updates now only send when percentage changes
+Akkadius: Raid/Group Mana/Endurance updates should now update real-time once again
+Akkadius: Fixed an issue with clients looking like they are 'skipping' when they are moving in view of another client
+Akkadius: Fixed an issue with NPC's who are ghosted in plain view of a client when they are not really there
+
+== 7/9/2017 ==
+Akkadius: Fix HP update issues, rework logic for more accurate HP updates
+Akkadius: Massive reductions in unnecessary network traffic especially during high spam combat fights
+	- HP Updates now only send to others when HP percentage changes (0-100%)
+		- HP Updates were sending excessively even during idle zones when HP wasn't changing at all
+	- Attack animations now only send once per second versus up to a hundred times a second per Mob/Client
+	- 17,000 OP_ClientUpdate packets per second have been observed in combat scenarios, some of the major culprits have been
+		throttled without affecting what the client should see
+	- Before and After packet differences under similar load/tests (Packets per second)
+		- 7,000 - 8,000 	OP_Animation pps	After: 600-800 pps
+		- 13,0000 - 17,000 	OP_MobHealth pps	After: 1-10 pps
+		- 15,0000 - 20,000 	OP_ClientUpdate pps	After: 500-1,000 pps
+	- Packet reports from a 46 client test here:
+		https://gist.github.com/Akkadius/28b7ad2fdd82bdd15ea737c68f404346
+	- Servers who use Marquee HP updates will also recieve far less packet spam as they will only be sent when HP changes
+
+== 7/1/2017 ==
+Akkadius: Resolve issues with NPC's hopping to the ceiling in small corridors
+Akkadius: Improved grounding issues with NPC's during combat
+Akkadius: Improved scenarios where NPC's need to be dragged out of the ground - they should correct themselves far more consistently
+	- Scenarios where an NPC is coming up from the bottom floor, or from the top floor, they will correct much better
+	- A video of these tests can be found here: https://www.youtube.com/watch?v=HtC7bVNM7ZQ&feature=youtu.be
+
+== 6/28/2017 ==
+Akkadius: Fixed issues with Z correctness when NPCs are pathing on normal grids
+Akkadius: Fixed issues with Z correctness when NPCs are engaged with players following
+Akkadius: NPC corpses should fall into the ground far less
+
+== 6/25/2017 ==
+Akkadius: New rules made by developers are now automatically created when world boots up, this keeps 
+	from having to issue schema SQL updates every time rules are added.
+	- Whenever a rule isn't present in the database, it will be automatically created
+Akkadius: Sped up saylink retrieval x1000 helpful for dialogues, plugins with many saylinks
+
+== 4/16/2017 ==
+KLS: Merge eqstream branch
+	- UDP client stack completely rewritten should both have better throughput and recover better (peq has had far fewer reports of desyncs).
+	- TCP Server to Server connection stack completely rewritten.
+		- Server connections reconnect much more reliably and quickly now.
+		- Now supports optional packet encryption via libsodium (https://download.libsodium.org/doc/).
+		- Protocol behind the tcp connections has changed (see breaking changes section).
+		- API significantly changed and should be easier to write new servers or handlers for.
+		- Telnet console connection has been separated out from the current port (see breaking changes section).
+			- Because of changes to the TCP stack, lsreconnect and echo have been disabled.
+	- The server tic rate has been changed to be approx 30 fps from 500+ fps.
+		- Changed how missiles and movement were calculated slightly to account for this (Missiles in particular are not perfect but close enough).
+	
+	- Breaking changes:
+		- Users who use the cmake install feature should be aware that the install directory is now %cmake_install_dir%/bin instead of just %cmake_install_dir%/
+		- To support new features such as encryption the underlying protocol had to change... however some servers such as the public login server will be slow to change so we've included a compatibility layer for legacy login connections:
+			- You should add <legacy>1</legacy> to the login section of your configuration file when connecting to a server that is using the old protocol.  
+			- The central eqemu login server uses the old protocol and probably will for the forseeable future so if your server is connecting to it be sure to add that tag to your configuration file in that section.
+			- Telnet no longer uses the same port as the Server to Server connection and because of this the tcp tag no longer has any effect on telnet connections.
+				- To enable telnet you need to add a telnet tag in the world section of configuration such as:
+					<telnet ip="0.0.0.0" port="9001" enabled="true"/>
+
+== 4/1/2017 ==
+Akkadius: Cleaned up some of the NPC to NPC aggro code, only do aggro checks to other NPC's when the NPC is flagged for it
+Akkadius: [Performance] Reworked how all log calls are made in the source
+	- Before we used Log.Out, we will now use a macro Log(
+		- Before: Log.Out(Logs::General, Logs::Status, "Importing Spells...");
+		- After: Log(Logs::General, Logs::Status, "Importing Spells...");
+	- The difference is 
+		1) It's 200-300x faster especially when log statements are inside very hot code paths. We already
+			had most hot paths checked before we logged them, but this blankets all existing logging calls now and not just the 
+			select few we had picked out in the source.
+		2) Strings don't get copied to the stack, popped and pushed constantly even when we hit a log statement that 
+			actually isn't going to log anything.
+				- We do an 'if (LogSys.log_settings[log_category].is_category_enabled == 1)' before we call a log function
+					in the log macro so the log function doesn't get called at all if we're not logging the category
+	- This has increased binary executables roughly 15KB
+	- The old extern for EQEmuLogSys is now named LogSys appropriately instead of Log (Ex: LogSys.StartFileLogs())
+	- The result keeps logging footprint non-existent for when we're not logging that category
+
+== 03/30/2017 ==
+Akkadius: [Performance] Fixed an overhead issue where many hot paths would trigger quest subroutines and beneath that the code would
+	try to see if a quest existed perpetually (checking if file exists) even though it should have determined the quest 
+	didn't exist the first time.
+	- This caused a lot of overhead in an instance where an entire zone of NPC's is pathing, triggering EVENT_WAYPOINT_ARRIVE
+	and EVENT_WAYPOINT_DEPART when there is no global_npc.pl/lua, or all NPC's pathing don't have a quest assigned, similar 
+	behavior would occur. This goes for any other type of quests: spells, items, encounters etc.
+
+== 03/28/2017 ==
+Akkadius: [Performance] Fixed a large overhead issue where every single NPC in a zone was checking to depop themselves
+	as a swarm pet every 3ms regardless of being a swarm pet or not. Swarm pets now check to depop only when their timer is up
+Akkadius: [Performance] Removed a timer where clients would constantly calculate light amount on equipment every 600ms, instead 
+	clients will update light when changing equipment or entering a zone
+Akkadius: [Performance] Disabled enraged timer checks for NPC's that do not actually have enrage as a special attack
+Akkadius: [Performance] Don't process ProjectileAttack checks for NPC's that are not engaged in any combat
+
+== 03/27/2017 ==
+Akkadius: [Performance] Reworked how client to NPC aggro checks are made
+	- Before when reverse aggro checks were done (client to NPC), checks would happen every 750 millseconds where a client would
+		check an entire entity list with distance calcs and other checks for aggro, with many clients in a zone and many NPC's this would
+		add a lot of unecessary overhead. A temporary adjustment on 3/25 was made and upped the check to 6 seconds.
+	- Now, there is a new methodology to scanning. The client will build a cache list of NPC's within close range as defined in new rule:
+		RULE_INT(Range, ClientNPCScan, 300) and will also get any NPC that has an aggro range beyond that defined range to use in 
+		the frequent checks for aggro, the result is far less overhead
+	- Client scanning changes when moving versus not moving, the client will scan aggro every 500 milliseconds while moving, and
+		3000 millseconds aggro check when not moving, with a 6000ms re-fetch for close NPC's
+	- A demo of these changes can be found here:
+		https://youtu.be/aGroiwLSTVU
+
+== 03/25/2017 ==
+Akkadius: [Performance] Reduced CPU footprint in non-combat zones doing constant checks for combat related activities
+Akkadius: [Performance] Reduced CPU footprint in cases where a client is checking for aggro excessively every 750 millseconds. This has 
+	been adjusted to 6 seconds per new rule RULE_INT(Aggro, ClientAggroCheckInterval)
+	- When zones have many players, with many NPC's, this adds up quickly
+
+== 03/12/2017 ==
+Akkadius: [Performance]
+- Implemented range rules for packets and other functions
+	RULE_INT ( Range, Say, 135 )
+	RULE_INT ( Range, Emote, 135 )
+	RULE_INT ( Range, BeginCast, 200)
+	RULE_INT ( Range, Anims, 135)
+	RULE_INT ( Range, SpellParticles, 135)
+	RULE_INT ( Range, DamageMessages, 50)
+	RULE_INT ( Range, SpellMessages, 75)
+	RULE_INT ( Range, SongMessages, 75)
+	RULE_INT ( Range, MobPositionUpdates, 600)
+	RULE_INT ( Range, CriticalDamage, 80)
+	
+ - (Readability) Also cleaned up some formatting in messaging and packets so it is easier to understand what is going on with the code
+
+== 03/09/2017 ==
+Uleat: Fixed a few glitches related to bot trading and other affected code
+	- Added a temporary fail clause for partial stack transfers to prevent client item overwrites
+	- Return messages no longer repeat the top cursor item when multiple items are pushed there
+	- Test slot for client returns is now handled appropriately for parent and bag searches
+	- FindFreeSlotForTradeItem() now begins at the correct bag index on subsequent parent iterations
+Uleat: First step of implementing inventory v2.0
+
+== 03/08/2017 ==
+Uleat: Complete rework of the bot trading system
+	- Equipment slot priority can now be tailored..though, a recompile will be required
+	- All item validations and slot assignments for trades and returns are now performed before any actual item movements occur
+	- Failed trade/returned items will now go straight into the client's inventory, just like a normal trade transaction
+		- A 'green' message appears at the end of each successful trade informing the trader of 'accepted' and 'returned' item counts
+		- Bots respond to the trader directly now instead of using BotGroupSay()
+	- Bots will still only allow trades from their owner (currently, too high a risk of exploit and/or malicious activity)
+	- Partial stack movements (i.e., ammo refills) have been scoped..but, not implemented
+	- I have not been able to reproduce any 'illegal' weapon combinations with this code
+	- NOTE: The report of item duplication with bot return items appears to be an inventory desync condition
+		- I experienced this condition both before and after the rework with RoF+ clients (UF- appears ok)
+		- The bug lies within the actual client inventory system and not with bot trades
+	- Please post any issues with this change as they arise
+
+== 02/27/2017 ==
+Uleat: Notes on bot movement speed changes:
+	- Clients (players) appear to be on a different speed scale than other entities (NPCs, etc...)
+	- The server does not calculate deltas/velocities for moving players..those come the client itself
+	- GetBotWalkspeed() and GetBotRunspeed() are specific to bot movement calculations
+	- The class Mob equivilents are not scalared so that a 'client-oriented' value can still be attained
+	- The value of ~1.786f is derived from the ratio of 1.25f/0.7f (npc speed/client speed)
+	- Modifying the two speeds like this is a rough guess-timate..but, appears to at least bring the incongruous behavior to acceptable levels
+
+== 02/26/2017 ==
+Uleat: Moved bot `npc_spells` entries from '701-712' to 3000 + <class_id> .. also, added melee types for future expansion
+Uleat: Moved bot spell casting chance values into database - this will allow admins to tailor their bots without having to rebuild server code
+	- Each entry uses a 3-dimensional identifier: [spell type index][class id][stance index]
+		- [spell type index] is not the SpellType_## bit value..use SpellType_##Index instead
+		- [class id] values of 1-16 are valid and hold a direct correlation to server-coded player class values
+		- [stance index] is a direct correlation (0-6)
+		- the 'conditional fields' are currently predicated on 4 compounded boolean states:
+			- `pH_value` represents bit '0'
+			- `pS_value` represents bit '1'
+			- `pN_value` represents bit '2'
+			- `pD_value` represents bit '3'
+			- all other conditional fields are masked based on these 4 predicates
+		- the full conditional field enumeration is as follows:
+			- `nHSND_value`		- negative Healer/Slower/Nuker/Doter
+			- `pH_value`		- positive Healer
+			- `pS_value`		- positive Slower
+			- `pHS_value`		- positive Healer/Slower
+			- `pN_value`		- positive Nuker
+			- `pHN_value`		- positive Healer/Nuker
+			- `pSN_value`		- positive Slower/Nuker
+			- `pHSN_value`		- positive Healer/Slower/Nuker
+			- `pD_value`		- positive Doter
+			- `pHD_value`		- positive Healer/Doter
+			- `pSD_value`		- positive Slower/Doter
+			- `pHSD_value`		- positive Healer/Slower/Doter
+			- `pND_value`		- positive Nuker/Doter
+			- `pHND_value`		- positive Healer/Nuker/Doter
+			- `pSND_value`		- positive Slower/Nuker/Doter
+			- `pHSND_value`		- positive Healer/Slower/Nuker/Doter
+	- Single- and mixed-bits fields should be filled-in based on the boolean 'AND' concept
+		- (i.e., if 'healer' then `pH_value`=x; if 'slower' then `pS_value`=y; if 'healer' AND 'slower' then `pHS_value`=z; )
+		- most cases can allow the same value across all fields..but, there are some that shouldn't and this format allows for their discrimination
+	- Valid `##_value` entries are 0-100..though, the field accepts up to 255... Anything above 100 is clamped to 100 upon loading, however...
+	- Not all conditions are currently coded and changing a field may not produce any results
+	- The 'default' database values will be changed and tweaked as bot spell code modifications occur
+
+== 02/25/2017 ==
+Uleat: Implemented rule-based node pathing for bots
+	- This currently applies to out-of-combat following movement and blocked los in-combat movement
+	- The default is set to 'true' (use node pathing)..so, consider disabling it if cpu use is too high
+	- If you want to disable node pathing, apply the optional sql '2017_02_25_bots_use_pathing_rule.sql' file located in the utils/sql/git/bots/optional sub-directory. This will apply a 'false' rule..but, it can be changed as desired
+	- This helps with bot movement..but, there are still issues...
+Uleat: Implemented rule-based position update packet with movement timer check for bots
+	- This currently only applies to out-of-combat movement
+	- The default is set to 'false' (original behavior) to help save bandwidth (each bot will send an update packet every 1/10th of a second when enabled)
+	- If you want to enable the position update packet, apply the optional sql '2017_02_25_bots_update_position_with_timer_rule.sql' file located in the utils/sql/git/bots/optional sub-directory. This will apply a 'true' rule..but, it can be changed as desired
+	- This appears to help with/eliminate rubber banding
+
+== 02/23/2017 ==
+** THIS NOTE HAS BEEN SUPERCEDED ON 02/26/2017 **
+Uleat: Moved bot spell casting chance values into database - this will allow admins to tailor their bots without having to rebuild server code
+	- Each entry uses a 4-dimensional identifier: [spell type index][class index][stance index][conditional index]
+		- [spell type index] is not the SpellType_## bit value..use SpellType_##Index instead
+		- [class index] values of 0-15 are valid and determined by subtracting 1 from the actual class value
+		- [stance index] is a direct correlation (0-6)
+		- the [conditional index] is currently predicated on 2 compounded boolean states:
+			- not primary healer/not primary slower: 0
+			- primary healer/not primary slower: 1
+			- not primary healer/ primary slower: 2
+			- primary healer/primary slower: 3
+	- Valid `value` entries are 0-100..though, the field accepts up to 255... Anything above 100 is clamped to 100 upon loading, however
+	- Not all conditions are currently coded and changing a field may not produce any results
+	- The 'default' database values will be changed and tweaked as bot spell code modifications occur
+
+== 02/20/2017 ==
+Uleat: Reworked bard bot spell twisting and updated their spell (song) list
+Uleat: Added ability to shift to pre-combat song buffing by selecting a non-pet npc target, eliminating the need to mix all bard buff songs together
+
+== 2/19/2017 ==
+Akkadius: Added a fix for limiting the amount of items sold in a stack when the resulting return coin is higher than the supporting struct for returning coin
+
+== 01/31/2017 ==
+Uleat: Modifed bot movement behavior in an attempt to 'normalize' it. This is a hack fix and will be revisited at some point. (Probably just need a follow function rather than use movement, when the leader of the follow chain is moving.)
+
+== 01/26/2017 ==
+Uleat: Change rogue bot behavior to eliminate twirling combat. They will only get behind the mob if they are not the mob's target or if the mob is feared or fleeing. This may lower rogue bot dps a small fraction..but, is more in-line with realistic game mechanics.
+
+== 01/17/2017 ==
+Mackal: Combat Revamp
+	- This change brings melee combat into line with how combat is done on live.
+	- This correctly applies the PC damage tables and corrects stacking order of many spells
+	- Given the scope of what had to be rewritten, it was not feasible to preserve the old combat system.
+	This means you will likely have to rebalance your server, which sucks, but this is very
+	accurate so shouldn't require any more changes, at least none that would cause you to have
+	to rebalance your server again.
+	- For rebalancing, I would recommend running the optional SQL and tweaking from there.
+	- To help with rebalancing there is a simulator included at utils/combat-sim.
+	- You can enter the mitigation or offense values you would like to balance around (#showstats will show you them)
+	a 1 on the sim is min damage 20 is max.
+	- Quick recommendations for best ways to improve PC DPS, give them some worn (or AA) SE_DamageModifier and/or SE_MinDamageModifier
 == 12/03/2016 ==
 Uleat: Added hack detection to trade code
 	- If illegal items are found in trade slots when the 'trade' button is clicked, the trade is cancelled and a message is sent to the offending player
@@ -28,7 +306,7 @@ take into account that rogue was sneaking.  Now sneaking rogues can see full
 inventory on merchants (well, unless an item requires a + faction value).

 == 09/12/2016 ==
-Akkadius: Massive overhaul of the update system and EQEmu Server management utility framework 
+Akkadius: Massive overhaul of the update system and EQEmu Server management utility framework
 	(known as eqemu_update.pl) now known as eqemu_server.pl
 	- eqemu_server.pl is now a general EQEmu Server management utiltiy framework that can be used
 		to extend to many purposes. It's main purpose is to simplify server management
@@ -49,7 +327,7 @@ Akkadius: Massive overhaul of the update system and EQEmu Server management util
 			- Regular bots database schema changes now happen automatically similarily to the above
 			- Database checks can also be ran manually via the script menu
 		- CLI Arguments
-			- Arguments passed to eqemu_server.pl can execute the same name-based operations that 
+			- Arguments passed to eqemu_server.pl can execute the same name-based operations that
 				are present in the interactive menu
 					- Example: "perl eqemu_server.pl opcodes" will download opcodes
 					- Example: "perl eqemu_server.pl backup_player_tables" will backup and export player tables
@@ -64,7 +342,7 @@ Akkadius: Massive overhaul of the update system and EQEmu Server management util
 					- server_start_dev.sh
 					- server_start.sh
 					- server_status.sh
-					- server_stop.sh 
+					- server_stop.sh
 		- Usage analytics
 			- eqemu_server.pl now collects usage analytics, this is very helpful for our developers
 				- Example: We can see how many installs have been performed:
@@ -76,10 +354,10 @@ Akkadius: Massive overhaul of the update system and EQEmu Server management util
 		- 'New Server' Utility
 			- Running 'new_server' from the main menu or 'perl eqemu_server.pl new_server' while in
 				a completely new folder with just the script present, will allow a server operator
-				to initiate a full clean PEQ install in that folder. Pulling down all assets and 
-				installing a PEQ database with the name the server operator gives the prompts in the 
+				to initiate a full clean PEQ install in that folder. Pulling down all assets and
+				installing a PEQ database with the name the server operator gives the prompts in the
 				script
-	
+
 == 09/10/2016 ==
 noudess: Task system experience based on a % of a level did not take into
 account the hell levels rule.  Now it does.
@@ -133,7 +411,7 @@ Kinglykrab: Implemented optional avoidance cap rules.
 	- Rule Names:
 		- Character:EnableAvoidanceCap (default is false)
 		- Character:AvoidanceCap (default is 750, beyond 1,000 seems to make characters dodge all attacks)
-	
+
 == 08/02/2016 ==
 Uleat: Changed 'SendZoneSpawnsBulk' behavior to use near/far criteria (live-like) when sending packets.
 	- Zone-to-Zone client loading will see a small decrease in time (less than 10~15%)
@@ -171,7 +449,7 @@ mackal: Fix up the SpellBuff struct
 Uleat: Important fix for mob pathing
 	- This should fix failed pathing issues (and high cpu usage for zone.exe) for mobs in affect zones
 	- Changed variable 'gridno' type from int16 to int32 to reflect actual return value of fetch (values do exceed 32767 aka int16.max)
-	- Precision loss from int32 to int16 conversion was causing grid id to be changed to quest controlled movement in cases where (gridno & 0x8000 == true) 
+	- Precision loss from int32 to int16 conversion was causing grid id to be changed to quest controlled movement in cases where (gridno & 0x8000 == true)

 == 06/28/2016 ==
 Noudess: Resurrection effects now block certain buffs like on live.
@@ -240,7 +518,7 @@ Uleat: Moved database query code out of bot.cpp and into the new BotDatabase cla

 == 03/25/2016 ==
 Uleat: Fix for heal rotation 'Stack Overflow' error
-Kayen: Defensive procs will now only proc once per attack round (instead of every attack chance). 
+Kayen: Defensive procs will now only proc once per attack round (instead of every attack chance).
       Live like modifier added that decreases defensive proc chance if you are higher level then your attacker.

 == 03/24/2016 ==
@@ -283,7 +561,7 @@ Kinglykrab: Modified #flag so you can refresh your target's account status (GM s
 	- Just target the person whose flag you want to refresh and type #flag.
 Uleat: Added itemlink functionality to the #summonitem command. Current use is limited to extracting the item id from the link.
 	- Invoking by item link '#summonitem Arrow' produces the same result as by item id '#summonitem 8005'
-	
+
 == 01/12/2016 ==
 Athrogate: Adding ClearCompassMark() to Lua.
 	- Lua didn't have ClearCompassMark().  Perl already had this.
@@ -313,7 +591,7 @@ Kinglykrab: Added GetInstanceTimer() to Perl and Lua.
 	- Note: If you do not provide an instance id in the method it defaults to instance id 0 and returns 0 for time remaining.
 	- Added UpdateZoneHeader(type, value) to Perl and Lua.
 	- Note: UpdateZoneHeader allows you to manipulate fog color, fog density, and many other zone header settings on the fly in Perl and Lua.
-	
+
 == 12/21/2015 ==
 Natedog: Updated item table fields and added a few missing fields for evolving items
 	-DO NOT implement Heirloom items till the inventory code is fixed to allow placing NO DROP
@@ -322,7 +600,7 @@ Natedog: Updated item table fields and added a few missing fields for evolving i
 		100% 2HSlashing (Max 50) - can only increase 2hslash by 50 MAX! (item field located though)
 Kinglykrab: Added GetMeleeMitigation() for NPCs and Clients in Perl and Lua.
 	- This allows you to check total item, spell, and AA melee mitigation contribution.
-	
+
 == 12/19/2015 ==
 Kinglykrab: Added many methods to Perl and Lua, list below:
 	- SeeInvisible()
@@ -344,7 +622,7 @@ Kinglykrab: Added many methods to Perl and Lua, list below:
 	- HasPet()
 	- IsSilenced()
 	- IsAmnesiad()
-	
+
 == 12/16/2015 ==
 Noudess: Repaired issue with Bind Wounds on someone else.  Message was not coming out on client (hold still) and a bind wounds on someone already binding their wounds would interrupt their bind and make them stand.  Also removed some duplicate messaging.

@@ -353,7 +631,7 @@ Kinglykrab: Added IsBlind() and IsFeared() functionality to Perl and Lua.
 	- Note: Both methods are Mob methods and may be used on NPCs or PCs.
 Natedog: Added Discipline functions, UpdateInstanceTimer function, and UnmemSpellBySpellID to lua and perl
 	-Examples: http://wiki.eqemulator.org/i?M=Pastebin&Paste=BJ0ygmNM
-	
+
 == 12/07/2015 ==
 Uleat: Command aliases are no longer handled through the command_add() function.
 	- To add a command alias, edit the database table `command_settings` - here, you will find three columns: `command`, `access` and `aliases`
@@ -366,7 +644,7 @@ Uleat: Command aliases are no longer handled through the command_add() function.
 	- If you need need more name space for aliases, simply edit the `command_settings` table and increase the size of the `aliases` column
 	- The old `commands` table has been renamed to `commands_old` for reference
 	- All of the current 'standard' commands have been added to the new `command_settings` table
-	
+
 	- YOU WILL NEED TO VERIFY/IMPORT OLD ACCESS VALUES AS THIS CHANGE REVERTS ALL COMMAND ACCESS VALUES TO THEIR PEQDB DEFAULTS

 == 11/30/2015 ==
@@ -388,7 +666,7 @@ Akkadius: Performance boost (exponential) - Adjusted default idle cast check tim
 	- Database version 9089 will take care of this update automatically only if you used the default values
 	- The CPU cost of NPC's checking the entire entity list to cast beneficial spells (Heals/Buffs) becomes extremely high when higher NPC count zones exist (Based off of process profiling)
 			- Distance checks for every single NPC to every single other NPC who are casting beneficial spells occur every .5 - 2 seconds unless npc_spells dictates other values, which most of the time it does not
-	- Zones that once fluctuated from 1-8% CPU with no activity (Idle but players present) now idle at .5% based on my testings due 
+	- Zones that once fluctuated from 1-8% CPU with no activity (Idle but players present) now idle at .5% based on my testings due
 		to this change in conjunction with the past few performance commits, these are zones that have 600-800 NPC's in them
 	- These values normally are overidden by the spells table (npc_spells), fields (idle_no_sp_recast_min, idle_no_sp_recast_max)

@@ -396,7 +674,7 @@ Akkadius: Performance boost (exponential) - Adjusted default idle cast check tim
 Akkadius: Made many performance optimizing oriented code changes in the source
 	- Added Rate limit the rate in which signals are processed for NPC's (.5 seconds instead of .01 seconds)
 Akkadius: Added Perl Export Settings which should heavily reduce the Perl footprint
-	- Normally when any sub EVENT_ gets triggered, all kinds of variables have to get exported every single time an event is triggered and 
+	- Normally when any sub EVENT_ gets triggered, all kinds of variables have to get exported every single time an event is triggered and
 		this can make Perl very slow when events are triggered constantly
 			- The two most taxing variable exports are the item variables ($itemcount{} $hasitem{} $oncursor{}) and qglobals ($qglobals{})
 			- qglobals can pose to be an issue quickly when global qglobals build up, it is highly recommend to use the GetGlobal() and SetGlobal()
@@ -424,7 +702,7 @@ Akkadius: Added Perl Export Settings which should heavily reduce the Perl footpr
 	|        4 | EVENT_ATTACK                            |               0 |          1 |           1 |           0 |            1 |
 	|        5 | EVENT_COMBAT                            |               1 |          1 |           1 |           0 |            1 |
 	+----------+-----------------------------------------+-----------------+------------+-------------+-------------+--------------+
-	
+
 	- If a change is made to this table while the server is live and running, you can hot reload all zone process settings via:
 		#reloadperlexportsettings
 	- For those who wonder what "exports" are, they are reference to variables that are made available at runtime of the sub event, such as:
@@ -433,7 +711,7 @@ Akkadius: Added Perl Export Settings which should heavily reduce the Perl footpr
 		(export_zone) : $zoneid, $instanceid, $zoneln etc. https://github.com/EQEmu/Server/blob/master/zone/embparser.cpp#L1083
 		(export_mob) : $x, $y, $z, $h, $hpratio etc. https://github.com/EQEmu/Server/blob/master/zone/embparser.cpp#L1032
 		(export_event) : (event specific) IE: EVENT_SAY ($text) https://github.com/EQEmu/Server/blob/master/zone/embparser.cpp#L1141
-	
+
 == 10/16/2015 ==
 Uleat: Added command '#bot clearfollowdistance [ <target> | spawned | all ]' to coincide with the activation of the load/save feature for follow_distance

@@ -465,7 +743,7 @@ rules:
 commands:
 	'#invsnapshot'						- Takes a snapshot of target client's inventory (feature active or inactive)
 	'#clearinvsnapshots [use rule]'		- Clears snapshot entries based on bool argument ([true] - honors the 'InvSnapshotHistoryD' rule, [false] - erases all)
-	
+
 == 08/02/2015 ==
 Shendare: VS2013 query StringFormat glitches when "%f" is passed for the int GetRunSpeed().
 Shendare: In CreateNewNPCCommand(), the npc_type_id and spawngroupid are created in the database, but never set in the spawn class, so later it can't delete them with #npcspawn remove or #npcspawn delete.
@@ -9,28 +9,8 @@ SET(export_headers

 ADD_EXECUTABLE(export_client_files ${export_sources} ${export_headers})

-INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+INSTALL(TARGETS export_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)

-TARGET_LINK_LIBRARIES(export_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
-
-IF(MSVC)
-	SET_TARGET_PROPERTIES(export_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
-	TARGET_LINK_LIBRARIES(export_client_files "Ws2_32.lib")
-ENDIF(MSVC)
-
-IF(MINGW)
-	TARGET_LINK_LIBRARIES(export_client_files "WS2_32")
-ENDIF(MINGW)
-
-IF(UNIX)
-	TARGET_LINK_LIBRARIES(export_client_files "${CMAKE_DL_LIBS}")
-	TARGET_LINK_LIBRARIES(export_client_files "z")
-	TARGET_LINK_LIBRARIES(export_client_files "m")
-	IF(NOT DARWIN)
-		TARGET_LINK_LIBRARIES(export_client_files "rt")
-	ENDIF(NOT DARWIN)
-	TARGET_LINK_LIBRARIES(export_client_files "pthread")
-	ADD_DEFINITIONS(-fPIC)
-ENDIF(UNIX)
+TARGET_LINK_LIBRARIES(export_client_files ${SERVER_LIBS})

 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -27,7 +27,7 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"

-EQEmuLogSys Log;
+EQEmuLogSys LogSys;

 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
@@ -36,46 +36,46 @@ void ExportDBStrings(SharedDatabase *db);

 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
-	Log.LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
+	Log(Logs::General, Logs::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}

 	auto Config = EQEmuConfig::get();

 	SharedDatabase database;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	Log(Logs::General, Logs::Status, "Connecting to database...");
 	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
 		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}

 	/* Register Log System and Settings */
-	database.LoadLogSettings(Log.log_settings);
-	Log.StartFileLogs();
+	database.LoadLogSettings(LogSys.log_settings);
+	LogSys.StartFileLogs();

 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
 	ExportDBStrings(&database);

-	Log.CloseFileLogs();
+	LogSys.CloseFileLogs();

 	return 0;
 }

 void ExportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
+	Log(Logs::General, Logs::Status, "Exporting Spells...");

 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}

@@ -142,11 +142,11 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
 }

 void ExportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
+	Log(Logs::General, Logs::Status, "Exporting Skill Caps...");

 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}

@@ -171,11 +171,11 @@ void ExportSkillCaps(SharedDatabase *db) {
 }

 void ExportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
+	Log(Logs::General, Logs::Status, "Exporting Base Data...");

 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}

@@ -202,11 +202,11 @@ void ExportBaseData(SharedDatabase *db) {
 }

 void ExportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting DB Strings...");
+	Log(Logs::General, Logs::Status, "Exporting DB Strings...");

 	FILE *f = fopen("export/dbstr_us.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
 		return;
 	}

@@ -9,28 +9,8 @@ SET(import_headers

 ADD_EXECUTABLE(import_client_files ${import_sources} ${import_headers})

-INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
+INSTALL(TARGETS import_client_files RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)

-TARGET_LINK_LIBRARIES(import_client_files common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY})
-
-IF(MSVC)
-	SET_TARGET_PROPERTIES(import_client_files PROPERTIES LINK_FLAGS_RELEASE "/OPT:REF /OPT:ICF")
-	TARGET_LINK_LIBRARIES(import_client_files "Ws2_32.lib")
-ENDIF(MSVC)
-
-IF(MINGW)
-	TARGET_LINK_LIBRARIES(import_client_files "WS2_32")
-ENDIF(MINGW)
-
-IF(UNIX)
-	TARGET_LINK_LIBRARIES(import_client_files "${CMAKE_DL_LIBS}")
-	TARGET_LINK_LIBRARIES(import_client_files "z")
-	TARGET_LINK_LIBRARIES(import_client_files "m")
-	IF(NOT DARWIN)
-		TARGET_LINK_LIBRARIES(import_client_files "rt")
-	ENDIF(NOT DARWIN)
-	TARGET_LINK_LIBRARIES(import_client_files "pthread")
-	ADD_DEFINITIONS(-fPIC)
-ENDIF(UNIX)
+TARGET_LINK_LIBRARIES(import_client_files ${SERVER_LIBS})

 SET(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)
@@ -25,7 +25,7 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"

-EQEmuLogSys Log;
+EQEmuLogSys LogSys;

 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
@@ -34,35 +34,35 @@ void ImportDBStrings(SharedDatabase *db);

 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	Log.LoadLogSettingsDefaults();
+	LogSys.LoadLogSettingsDefaults();
 	set_exception_handler();

-	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
+	Log(Logs::General, Logs::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+		Log(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}

 	auto Config = EQEmuConfig::get();

 	SharedDatabase database;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	Log(Logs::General, Logs::Status, "Connecting to database...");
 	if(!database.Connect(Config->DatabaseHost.c_str(), Config->DatabaseUsername.c_str(),
 		Config->DatabasePassword.c_str(), Config->DatabaseDB.c_str(), Config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+		Log(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
 			"database connection");
 		return 1;
 	}

-	database.LoadLogSettings(Log.log_settings);
-	Log.StartFileLogs();
+	database.LoadLogSettings(LogSys.log_settings);
+	LogSys.StartFileLogs();

 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
 	ImportDBStrings(&database);

-	Log.CloseFileLogs();
+	LogSys.CloseFileLogs();
 	
 	return 0;
 }
@@ -97,10 +97,10 @@ bool IsStringField(int i) {
 }

 void ImportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
+	Log(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}

@@ -173,23 +173,23 @@ void ImportSpells(SharedDatabase *db) {

 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+			Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 		}
 	}

 	if(spells_imported % 1000 != 0) {
-		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+		Log(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 	}

 	fclose(f);
 }

 void ImportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
+	Log(Logs::General, Logs::Status, "Importing Skill Caps...");

 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}

@@ -220,11 +220,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }

 void ImportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
+	Log(Logs::General, Logs::Status, "Importing Base Data...");

 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}

@@ -265,11 +265,11 @@ void ImportBaseData(SharedDatabase *db) {
 }

 void ImportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing DB Strings...");
+	Log(Logs::General, Logs::Status, "Importing DB Strings...");

 	FILE *f = fopen("import/dbstr_us.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
+		Log(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
 		return;
 	}

@@ -0,0 +1,30 @@
+if (NOT MSVC)
+include(FindPkgConfig)
+pkg_check_modules(PC_SODIUM "libsodium")
+if (NOT PC_SODIUM_FOUND)
+    pkg_check_modules(PC_SODIUM "sodium")
+endif (NOT PC_SODIUM_FOUND)
+if (PC_SODIUM_FOUND)
+  set(SODIUM_INCLUDE_HINTS ${PC_SODIUM_INCLUDE_DIRS} ${PC_SODIUM_INCLUDE_DIRS}/*)
+  set(SODIUM_LIBRARY_HINTS ${PC_SODIUM_LIBRARY_DIRS} ${PC_SODIUM_LIBRARY_DIRS}/*)
+endif()
+endif (NOT MSVC)
+
+# some libraries install the headers is a subdirectory of the include dir
+# returned by pkg-config, so use a wildcard match to improve chances of finding
+# headers and libraries.
+find_path(
+    SODIUM_INCLUDE_DIRS
+    NAMES sodium.h
+    HINTS ${SODIUM_INCLUDE_HINTS}
+)
+
+find_library(
+    SODIUM_LIBRARIES
+    NAMES libsodium sodium
+    HINTS ${SODIUM_LIBRARY_HINTS}
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(SODIUM DEFAULT_MSG SODIUM_LIBRARIES SODIUM_INCLUDE_DIRS)
+mark_as_advanced(SODIUM_FOUND SODIUM_LIBRARIES SODIUM_INCLUDE_DIRS)
@@ -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
@@ -16,8 +17,6 @@ SET(common_sources
 	emu_legacy.cpp
 	emu_limits.cpp
 	emu_opcodes.cpp
-	emu_tcp_connection.cpp
-	emu_tcp_server.cpp
 	emu_versions.cpp
 	eqdb.cpp
 	eqdb_res.cpp
@@ -26,11 +25,10 @@ SET(common_sources
 	eqemu_logsys.cpp
 	eq_limits.cpp
 	eq_packet.cpp
-	eq_stream.cpp
-	eq_stream_factory.cpp
 	eq_stream_ident.cpp
 	eq_stream_proxy.cpp
 	eqtime.cpp
+	event_sub.cpp
 	extprofile.cpp
 	faction.cpp
 	guild_base.cpp
@@ -40,6 +38,7 @@ SET(common_sources
 	ipc_mutex.cpp
 	item_data.cpp
 	item_instance.cpp
+	json_config.cpp
 	light_source.cpp
 	md5.cpp
 	memory_buffer.cpp
@@ -68,15 +67,25 @@ SET(common_sources
 	spdat.cpp
 	string_util.cpp
 	struct_strategy.cpp
-	tcp_connection.cpp
-	tcp_server.cpp
 	textures.cpp
-	timeoutmgr.cpp
 	timer.cpp
 	unix.cpp
-	worldconn.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/packet.cpp
+	net/servertalk_client_connection.cpp
+	net/servertalk_legacy_client_connection.cpp
+	net/servertalk_server.cpp
+	net/servertalk_server_connection.cpp
+	net/tcp_connection.cpp
+	net/tcp_server.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sod_limits.cpp
@@ -90,22 +99,13 @@ SET(common_sources
 	patches/titanium_limits.cpp
 	patches/uf.cpp
 	patches/uf_limits.cpp
-	SocketLib/Base64.cpp
-	SocketLib/File.cpp
-	SocketLib/HttpdCookies.cpp
-	SocketLib/HttpdForm.cpp
-	SocketLib/HttpdSocket.cpp
-	SocketLib/HTTPSocket.cpp
-	SocketLib/MemFile.cpp
-	SocketLib/Mime.cpp
-	SocketLib/Parse.cpp
-	SocketLib/socket_include.cpp
-	SocketLib/Utility.cpp
 	StackWalker/StackWalker.cpp
 	tinyxml/tinystr.cpp
 	tinyxml/tinyxml.cpp
 	tinyxml/tinyxmlerror.cpp
 	tinyxml/tinyxmlparser.cpp
+	util/directory.cpp
+	util/uuid.cpp
 )

 SET(common_headers
@@ -114,6 +114,7 @@ SET(common_headers
 	base_data.h
 	bodytypes.h
 	classes.h
+	compression.h
 	condition.h
 	crash.h
 	crc16.h
@@ -127,8 +128,6 @@ SET(common_headers
 	emu_limits.h
 	emu_opcodes.h
 	emu_oplist.h
-	emu_tcp_connection.h
-	emu_tcp_server.h
 	emu_versions.h
 	eq_constants.h
 	eq_packet_structs.h
@@ -140,15 +139,13 @@ SET(common_headers
 	eqemu_logsys.h
 	eq_limits.h
 	eq_packet.h
-	eq_stream.h
-	eq_stream_factory.h
 	eq_stream_ident.h
 	eq_stream_intf.h
 	eq_stream_locator.h
 	eq_stream_proxy.h
-	eq_stream_type.h
 	eqtime.h
 	errmsg.h
+	event_sub.h
 	extprofile.h
 	faction.h
 	features.h
@@ -163,6 +160,7 @@ SET(common_headers
 	item_data.h
 	item_fieldlist.h
 	item_instance.h
+	json_config.h
 	languages.h
 	light_source.h
 	linked_list.h
@@ -201,19 +199,35 @@ SET(common_headers
 	spdat.h
    string_util.h
 	struct_strategy.h
-	tcp_basic_server.h
-	tcp_connection.h
-	tcp_server.h
 	textures.h
-	timeoutmgr.h
 	timer.h
 	types.h
 	unix.h
 	useperl.h
 	version.h
-	worldconn.h
 	xml_parser.h
 	zone_numbers.h
+	event/background_task.h
+	event/event_loop.h
+	event/timer.h
+	json/json.h
+	json/json-forwards.h
+	net/console_server.h
+	net/console_server_connection.h
+	net/crc32.h
+	net/daybreak_connection.h
+	net/daybreak_structs.h
+	net/dns.h
+	net/endian.h
+	net/eqstream.h
+	net/packet.h
+	net/servertalk_client_connection.h
+	net/servertalk_legacy_client_connection.h
+	net/servertalk_common.h
+	net/servertalk_server.h
+	net/servertalk_server_connection.h
+	net/tcp_connection.h
+	net/tcp_server.h
 	patches/patches.h
 	patches/sod.h
 	patches/sod_limits.h
@@ -242,21 +256,58 @@ SET(common_headers
 	patches/uf_limits.h
 	patches/uf_ops.h
 	patches/uf_structs.h
-	SocketLib/Base64.h
-	SocketLib/File.h
-	SocketLib/HttpdCookies.h
-	SocketLib/HttpdForm.h
-	SocketLib/HttpdSocket.h
-	SocketLib/HTTPSocket.h
-	SocketLib/IFile.h
-	SocketLib/MemFile.h
-	SocketLib/Mime.h
-	SocketLib/Parse.h
-	SocketLib/socket_include.h
-	SocketLib/Utility.h
 	StackWalker/StackWalker.h
 	tinyxml/tinystr.h
 	tinyxml/tinyxml.h
+	util/memory_stream.h
+	util/directory.h
+	util/uuid.h
+)
+
+SOURCE_GROUP(Event FILES
+	event/background_task.h
+	event/event_loop.cpp
+	event/event_loop.h
+	event/timer.h
+)
+
+SOURCE_GROUP(Json FILES
+	json/json.h
+	json/jsoncpp.cpp
+	json/json-forwards.h
+)
+
+SOURCE_GROUP(Net FILES
+	net/console_server.cpp
+	net/console_server.h
+	net/console_server_connection.cpp
+	net/console_server_connection.h
+	net/crc32.cpp
+	net/crc32.h
+	net/daybreak_connection.cpp
+	net/daybreak_connection.h
+	net/daybreak_structs.h
+	net/dns.h
+	net/endian.h
+	net/eqmq.cpp
+	net/eqmq.h
+	net/eqstream.cpp
+	net/eqstream.h
+	net/packet.cpp
+	net/packet.h
+	net/servertalk_client_connection.cpp
+	net/servertalk_client_connection.h
+	net/servertalk_legacy_client_connection.cpp
+	net/servertalk_legacy_client_connection.h
+	net/servertalk_common.h
+	net/servertalk_server.cpp
+	net/servertalk_server.h
+	net/servertalk_server_connection.cpp
+	net/servertalk_server_connection.h
+	net/tcp_connection.cpp
+	net/tcp_connection.h
+	net/tcp_server.cpp
+	net/tcp_server.h
 )

 SOURCE_GROUP(Patches FILES
@@ -303,32 +354,6 @@ SOURCE_GROUP(Patches FILES
 	patches/uf_limits.cpp
 )

-SOURCE_GROUP(SocketLib FILES
-	SocketLib/Base64.h
-	SocketLib/File.h
-	SocketLib/HttpdCookies.h
-	SocketLib/HttpdForm.h
-	SocketLib/HttpdSocket.h
-	SocketLib/HTTPSocket.h
-	SocketLib/IFile.h
-	SocketLib/MemFile.h
-	SocketLib/Mime.h
-	SocketLib/Parse.h
-	SocketLib/socket_include.h
-	SocketLib/Utility.h
-	SocketLib/Base64.cpp
-	SocketLib/File.cpp
-	SocketLib/HttpdCookies.cpp
-	SocketLib/HttpdForm.cpp
-	SocketLib/HttpdSocket.cpp
-	SocketLib/HTTPSocket.cpp
-	SocketLib/MemFile.cpp
-	SocketLib/Mime.cpp
-	SocketLib/Parse.cpp
-	SocketLib/socket_include.cpp
-	SocketLib/Utility.cpp
-)
-
 SOURCE_GROUP(StackWalker FILES
 	StackWalker/StackWalker.h
 	StackWalker/StackWalker.cpp
@@ -343,12 +368,19 @@ SOURCE_GROUP(TinyXML FILES
 	tinyxml/tinyxmlparser.cpp
 )

+SOURCE_GROUP(Util FILES
+	util/memory_stream.h
+	util/directory.cpp
+	util/directory.h
+	util/uuid.cpp
+	util/uuid.h
+)
+
 INCLUDE_DIRECTORIES(Patches SocketLib StackWalker TinyXML)

 ADD_LIBRARY(common ${common_sources} ${common_headers})

 IF(UNIX)
-	ADD_DEFINITIONS(-fPIC)
 	SET_SOURCE_FILES_PROPERTIES("SocketLib/Mime.cpp" PROPERTY COMPILE_FLAGS -Wno-unused-result)
 	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp"  "patches/rof2.cpp" "patches/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)
@@ -35,6 +35,7 @@ typedef enum {
 	BT_Greater_Akheva	= 14,
 	BT_Khati_Sha		= 15,
 	BT_Seru				= 16,	//not confirmed....
+	BT_Draz_Nurakk      = 18,
 	BT_Zek				= 19,
 	BT_Luggald			= 20,
 	BT_Animal			= 21,
@@ -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;
+		}
+	}
+}
@@ -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);
+}
@@ -25,7 +25,7 @@ public:
 			}
 		}

-		Log.Out(Logs::General, Logs::Crash, buffer);
+		Log(Logs::General, Logs::Crash, buffer);
 		StackWalker::OnOutput(szText);
 	}
 };
@@ -35,67 +35,67 @@ LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
 			break;
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
 			break;
 		case EXCEPTION_BREAKPOINT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
 			break;
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
 			break;
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
 			break;
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_FLT_INEXACT_RESULT:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
 			break;
 		case EXCEPTION_FLT_INVALID_OPERATION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
 			break;
 		case EXCEPTION_FLT_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
 			break;
 		case EXCEPTION_FLT_STACK_CHECK:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
 			break;
 		case EXCEPTION_FLT_UNDERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
 			break;
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
 			break;
 		case EXCEPTION_IN_PAGE_ERROR:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
 			break;
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_INT_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
 			break;
 		case EXCEPTION_INVALID_DISPOSITION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
 			break;
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
 			break;
 		case EXCEPTION_PRIV_INSTRUCTION:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
 			break;
 		case EXCEPTION_SINGLE_STEP:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
 			break;
 		case EXCEPTION_STACK_OVERFLOW:
-			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
+			Log(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
 			break;
 		default:
-			Log.Out(Logs::General, Logs::Crash, "Unknown Exception");
+			Log(Logs::General, Logs::Crash, "Unknown Exception");
 			break;
 	}

@@ -64,11 +64,11 @@ bool Database::Connect(const char* host, const char* user, const char* passwd, c
 	uint32 errnum= 0;
 	char errbuf[MYSQL_ERRMSG_SIZE];
 	if (!Open(host, user, passwd, database, port, &errnum, errbuf)) {
-		Log.Out(Logs::General, Logs::Error, "Failed to connect to database: Error: %s", errbuf); 
+		Log(Logs::General, Logs::Error, "Failed to connect to database: Error: %s", errbuf); 
 		return false; 
 	}
 	else {
-		Log.Out(Logs::General, Logs::Status, "Using database '%s' at %s:%d", database, host,port);
+		Log(Logs::General, Logs::Status, "Using database '%s' at %s:%d", database, host,port);
 		return true;
 	}
 }
@@ -208,7 +208,7 @@ uint32 Database::CreateAccount(const char* name, const char* password, int16 sta
 	else
 		query = StringFormat("INSERT INTO account SET name='%s', status=%i, lsaccount_id=%i, time_creation=UNIX_TIMESTAMP();",name, status, lsaccount_id);

-	Log.Out(Logs::General, Logs::World_Server, "Account Attempting to be created: '%s' status: %i", name, status);
+	Log(Logs::General, Logs::World_Server, "Account Attempting to be created: '%s' status: %i", name, status);
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
@@ -225,7 +225,7 @@ uint32 Database::CreateAccount(const char* name, const char* password, int16 sta

 bool Database::DeleteAccount(const char* name) {
 	std::string query = StringFormat("DELETE FROM account WHERE name='%s';",name); 
-	Log.Out(Logs::General, Logs::World_Server, "Account Attempting to be deleted:'%s'", name);
+	Log(Logs::General, Logs::World_Server, "Account Attempting to be deleted:'%s'", name);

 	auto results = QueryDatabase(query); 
 	if (!results.Success()) {
@@ -272,7 +272,7 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) {
 		if (row[0] && atoi(row[0]) > 0){
-			Log.Out(Logs::General, Logs::World_Server, "Account: %i tried to request name: %s, but it is already taken...", account_id, name);
+			Log(Logs::General, Logs::World_Server, "Account: %i tried to request name: %s, but it is already taken...", account_id, name);
 			return false;
 		}
 	}
@@ -290,23 +290,24 @@ bool Database::ReserveName(uint32 account_id, char* name) {
 bool Database::DeleteCharacter(char *name) {
 	uint32 charid = 0;
 	if(!name ||	!strlen(name)) {
-		Log.Out(Logs::General, Logs::World_Server, "DeleteCharacter: request to delete without a name (empty char slot)");
+		Log(Logs::General, Logs::World_Server, "DeleteCharacter: request to delete without a name (empty char slot)");
 		return false;
 	}
-	Log.Out(Logs::General, Logs::World_Server, "Database::DeleteCharacter name : '%s'", name);
+	Log(Logs::General, Logs::World_Server, "Database::DeleteCharacter name : '%s'", name);

 	/* Get id from character_data before deleting record so we can clean up the rest of the tables */
 	std::string query = StringFormat("SELECT `id` from `character_data` WHERE `name` = '%s'", name);
 	auto results = QueryDatabase(query);
 	for (auto row = results.begin(); row != results.end(); ++row) { charid = atoi(row[0]); }
 	if (charid <= 0){ 
-		Log.Out(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
+		Log(Logs::General, Logs::Error, "Database::DeleteCharacter :: Character (%s) not found, stopping delete...", name);
 		return false; 
 	}

 	query = StringFormat("DELETE FROM `quest_globals` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_activities` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `character_enabledtasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
+	query = StringFormat("DELETE FROM `character_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `completed_tasks` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `friends` WHERE `charid` = '%d'", charid); QueryDatabase(query);
 	query = StringFormat("DELETE FROM `mail` WHERE `charid` = '%d'", charid); QueryDatabase(query);
@@ -686,7 +687,7 @@ bool Database::StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, EQEmu
 	charid = GetCharacterID(pp->name);

 	if(!charid) {
-		Log.Out(Logs::General, Logs::Error, "StoreCharacter: no character id");
+		Log(Logs::General, Logs::Error, "StoreCharacter: no character id");
 		return false;
 	}

@@ -1499,7 +1500,7 @@ void Database::SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ism
 		auto results = QueryDatabase(query);

 		if (!results.Success())
-			Log.Out(Logs::General, Logs::Error, "Error deleting character from group id: %s", results.ErrorMessage().c_str());
+			Log(Logs::General, Logs::Error, "Error deleting character from group id: %s", results.ErrorMessage().c_str());

 		return;
 	}
@@ -1542,7 +1543,7 @@ uint32 Database::GetGroupID(const char* name){
 	if (results.RowCount() == 0)
 	{
 		// Commenting this out until logging levels can prevent this from going to console
-		//Log.Out(Logs::General, Logs::None,, "Character not in a group: %s", name);
+		//Log(Logs::General, Logs::None,, "Character not in a group: %s", name);
 		return 0;
 	}

@@ -1589,7 +1590,7 @@ void Database::SetGroupLeaderName(uint32 gid, const char* name) {
 	result = QueryDatabase(query);

 	if(!result.Success()) {
-		Log.Out(Logs::General, Logs::None, "Error in Database::SetGroupLeaderName: %s", result.ErrorMessage().c_str());
+		Log(Logs::General, Logs::None, "Error in Database::SetGroupLeaderName: %s", result.ErrorMessage().c_str());
 	}
 }

@@ -1786,7 +1787,7 @@ const char* Database::GetRaidLeaderName(uint32 raid_id)
 	auto results = QueryDatabase(query);

 	if (!results.Success()) {
-		Log.Out(Logs::General, Logs::Debug, "Unable to get Raid Leader Name for Raid ID: %u", raid_id);
+		Log(Logs::General, Logs::Debug, "Unable to get Raid Leader Name for Raid ID: %u", raid_id);
 		return "UNKNOWN";
 	}

@@ -2055,6 +2056,8 @@ uint32 Database::GetGuildIDByCharID(uint32 character_id)

 void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 {
+	// log_settings previously initialized to '0' by EQEmuLogSys::LoadLogSettingsDefaults()
+	
 	std::string query = 
 		"SELECT "
 		"log_category_id, "
@@ -2068,10 +2071,13 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 	auto results = QueryDatabase(query);

 	int log_category = 0;
-	Log.file_logs_enabled = false;
+	LogSys.file_logs_enabled = false;

 	for (auto row = results.begin(); row != results.end(); ++row) {
 		log_category = atoi(row[0]);
+		if (log_category <= Logs::None || log_category >= 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]);
@@ -2091,7 +2097,7 @@ void Database::LoadLogSettings(EQEmuLogSys::LogSettings* log_settings)
 			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){
-			Log.file_logs_enabled = true;
+			LogSys.file_logs_enabled = true;
 		}
 	}
 }
@@ -2113,7 +2119,7 @@ struct TimeOfDay_Struct Database::LoadTime(time_t &realtime)
 	auto results = QueryDatabase(query);

 	if (!results.Success() || results.RowCount() == 0){
-		Log.Out(Logs::Detail, Logs::World_Server, "Loading EQ time of day failed. Using defaults.");
+		Log(Logs::Detail, Logs::World_Server, "Loading EQ time of day failed. Using defaults.");
 		eqTime.minute = 0;
 		eqTime.hour = 9;
 		eqTime.day = 1;
@@ -110,8 +110,8 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo

 		/* Implement Logging at the Root */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
-				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
+			if (LogSys.log_settings[Logs::MySQLError].is_category_enabled == 1)
+				Log(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
 		}

 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
@@ -127,12 +127,14 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo

 	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
 	
-	if (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
+	if (LogSys.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
 	{
-		if ((strncasecmp(query, "select", 6) == 0))
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
-		else
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+		if ((strncasecmp(query, "select", 6) == 0)) {
+			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
+		}
+		else {
+			Log(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+		}
 	}

 	return requestResult;
@@ -49,7 +49,7 @@ namespace EQEmu
 		};

 		enum DeityTypeBit : uint32 {
-			bit_DeityAll = 0x00000000,
+			bit_DeityNone = 0x00000000,
 			bit_DeityAgnostic = 0x00000001,
 			bit_DeityBertoxxulous = 0x00000002,
 			bit_DeityBrellSirilis = 0x00000004,
@@ -66,7 +66,8 @@ namespace EQEmu
 			bit_DeitySolusekRo = 0x00002000,
 			bit_DeityTheTribunal = 0x00004000,
 			bit_DeityTunare = 0x00008000,
-			bit_DeityVeeshan = 0x00010000
+			bit_DeityVeeshan = 0x00010000,
+			bit_DeityAll = 0xFFFFFFFF
 		};

 		extern DeityTypeBit ConvertDeityTypeToDeityTypeBit(DeityType deity_type);
@@ -25,6 +25,9 @@ N(OP_AdventureRequest),
 N(OP_AdventureStatsReply),
 N(OP_AdventureStatsRequest),
 N(OP_AdventureUpdate),
+N(OP_AggroMeterLockTarget),
+N(OP_AggroMeterTargetInfo),
+N(OP_AggroMeterUpdate),
 N(OP_AltCurrency),
 N(OP_AltCurrencyMerchantReply),
 N(OP_AltCurrencyMerchantRequest),
@@ -352,6 +355,7 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
+N(OP_PetCommandState),
 N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
@@ -404,6 +408,7 @@ N(OP_ReloadUI),
 N(OP_RemoveAllDoors),
 N(OP_RemoveBlockedBuffs),
 N(OP_RemoveNimbusEffect),
+N(OP_RemoveTrap),
 N(OP_Report),
 N(OP_ReqClientSpawn),
 N(OP_ReqNewZone),
@@ -519,6 +524,7 @@ N(OP_TributeToggle),
 N(OP_TributeUpdate),
 N(OP_Untargetable),
 N(OP_UpdateAA),
+N(OP_UpdateAura),
 N(OP_UpdateLeadershipAA),
 N(OP_VetClaimReply),
 N(OP_VetClaimRequest),
@@ -1,818 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2006 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
-*/
-
-/*
-There are really two or three different objects shoe-hored into this
-connection object. Sombody really needs to factor out the relay link
-crap into its own subclass of this object, it will clean things up
-tremendously.
-*/
-
-#include "../common/global_define.h"
-
-#include <iostream>
-#include <string.h>
-
-#include "emu_tcp_connection.h"
-#include "emu_tcp_server.h"
-#include "../common/servertalk.h"
-
-#ifdef FREEBSD //Timothy Whitman - January 7, 2003
-	#define MSG_NOSIGNAL 0
-#endif
-
-#define TCPN_DEBUG				0
-#define TCPN_DEBUG_Console		0
-#define TCPN_DEBUG_Memory		0
-#define TCPN_LOG_PACKETS		0
-#define TCPN_LOG_RAW_DATA_OUT	0
-#define TCPN_LOG_RAW_DATA_IN	0
-
-
-//server side case
-EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET in_socket, uint32 irIP, uint16 irPort, bool iOldFormat)
-:	TCPConnection(ID, in_socket, irIP, irPort),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	id = 0;
-	Server = nullptr;
-	pOldFormat = iOldFormat;
-	#ifdef MINILOGIN
-		TCPMode = modePacket;
-		PacketMode = packetModeLogin;
-	#else
-		if (pOldFormat)
-			TCPMode = modePacket;
-		else
-			TCPMode = modeConsole;
-		PacketMode = packetModeZone;
-	#endif
-	RelayLink = 0;
-	RelayServer = false;
-	RelayCount = 0;
-	RemoteID = 0;
-
-}
-
-//client outgoing connection case (and client side relay)
-EmuTCPConnection::EmuTCPConnection(bool iOldFormat, EmuTCPServer* iRelayServer, eTCPMode iMode)
-:	TCPConnection(),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	Server = iRelayServer;
-	if (Server)
-		RelayServer = true;
-	else
-		RelayServer = false;
-	RelayLink = 0;
-	RelayCount = 0;
-	RemoteID = 0;
-	pOldFormat = iOldFormat;
-	TCPMode = iMode;
-	PacketMode = packetModeZone;
-#if TCPN_DEBUG_Memory >= 7
-	std::cout << "Constructor #1 on outgoing TCP# " << GetID() << std::endl;
-#endif
-}
-
-//server side relay case
-EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort)
-:	TCPConnection(ID, 0, irIP, irPort),
-	keepalive_timer(SERVER_TIMEOUT),
-	timeout_timer(SERVER_TIMEOUT * 2)
-{
-	Server = iServer;
-	RelayLink = iRelayLink;
-	RelayServer = true;
-	RelayCount = 0;
-	RemoteID = iRemoteID;
-	pOldFormat = false;
-	ConnectionType = Incoming;
-	TCPMode = modePacket;
-	PacketMode = packetModeZone;
-#if TCPN_DEBUG_Memory >= 7
-	std::cout << "Constructor #3 on outgoing TCP# " << GetID() << std::endl;
-#endif
-}
-
-EmuTCPConnection::~EmuTCPConnection() {
-	//the queues free their content right now I believe.
-}
-
-EmuTCPNetPacket_Struct* EmuTCPConnection::MakePacket(ServerPacket* pack, uint32 iDestination) {
-	int32 size = sizeof(EmuTCPNetPacket_Struct) + pack->size;
-	if (pack->compressed) {
-		size += 4;
-	}
-	if (iDestination) {
-		size += 4;
-	}
-	EmuTCPNetPacket_Struct* tnps = (EmuTCPNetPacket_Struct*) new uchar[size];
-	tnps->size = size;
-	tnps->opcode = pack->opcode;
-	*((uint8*) &tnps->flags) = 0;
-	uchar* buffer = tnps->buffer;
-	if (pack->compressed) {
-		tnps->flags.compressed = 1;
-		*((int32*) buffer) = pack->InflatedSize;
-		buffer += 4;
-	}
-	if (iDestination) {
-		tnps->flags.destination = 1;
-		*((int32*) buffer) = iDestination;
-		buffer += 4;
-	}
-	memcpy(buffer, pack->pBuffer, pack->size);
-	return tnps;
-}
-
-SPackSendQueue* EmuTCPConnection::MakeOldPacket(ServerPacket* pack) {
-	SPackSendQueue* spsq = (SPackSendQueue*) new uchar[sizeof(SPackSendQueue) + pack->size + 4];
-	if (pack->pBuffer != 0 && pack->size != 0)
-		memcpy((char *) &spsq->buffer[4], (char *) pack->pBuffer, pack->size);
-	memcpy((char *) &spsq->buffer[0], (char *) &pack->opcode, 2);
-	spsq->size = pack->size+4;
-	memcpy((char *) &spsq->buffer[2], (char *) &spsq->size, 2);
-	return spsq;
-}
-
-bool EmuTCPConnection::SendPacket(ServerPacket* pack, uint32 iDestination) {
-	if (!Connected())
-		return false;
-	eTCPMode tmp = GetMode();
-	if (tmp != modePacket && tmp != modeTransition)
-		return false;
-	LockMutex lock(&MState);
-	if (RemoteID)
-		return RelayLink->SendPacket(pack, RemoteID);
-	else if (pOldFormat) {
-		#if TCPN_LOG_PACKETS >= 1
-			if (pack && pack->opcode != 0) {
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				CoutTimestamp(true);
-				std::cout << ": Logging outgoing TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-				#if TCPN_LOG_PACKETS == 2
-					if (pack->size >= 32)
-						DumpPacket(pack->pBuffer, 32);
-					else
-						DumpPacket(pack);
-				#endif
-				#if TCPN_LOG_PACKETS >= 3
-					DumpPacket(pack);
-				#endif
-			}
-		#endif
-		SPackSendQueue* spsq = MakeOldPacket(pack);
-		ServerSendQueuePushEnd(spsq->buffer, spsq->size);
-		safe_delete_array(spsq);
-	}
-	else {
-		EmuTCPNetPacket_Struct* tnps = MakePacket(pack, iDestination);
-		if (tmp == modeTransition) {
-			InModeQueuePush(tnps);
-		}
-		else {
-			#if TCPN_LOG_PACKETS >= 1
-				if (pack && pack->opcode != 0) {
-					struct in_addr	in;
-					in.s_addr = GetrIP();
-					CoutTimestamp(true);
-					std::cout << ": Logging outgoing TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-					#if TCPN_LOG_PACKETS == 2
-						if (pack->size >= 32)
-							DumpPacket(pack->pBuffer, 32);
-						else
-							DumpPacket(pack);
-					#endif
-					#if TCPN_LOG_PACKETS >= 3
-						DumpPacket(pack);
-					#endif
-				}
-			#endif
-			ServerSendQueuePushEnd((uchar**) &tnps, tnps->size);
-		}
-	}
-	return true;
-}
-
-bool EmuTCPConnection::SendPacket(EmuTCPNetPacket_Struct* tnps) {
-	if (RemoteID)
-		return false;
-	if (!Connected())
-		return false;
-	if (GetMode() != modePacket)
-		return false;
-
-	LockMutex lock(&MState);
-	eTCPMode tmp = GetMode();
-	if (tmp == modeTransition) {
-		EmuTCPNetPacket_Struct* tnps2 = (EmuTCPNetPacket_Struct*) new uchar[tnps->size];
-		memcpy(tnps2, tnps, tnps->size);
-		InModeQueuePush(tnps2);
-		return true;
-	}
-	#if TCPN_LOG_PACKETS >= 1
-		if (tnps && tnps->opcode != 0) {
-			struct in_addr	in;
-			in.s_addr = GetrIP();
-			CoutTimestamp(true);
-			std::cout << ": Logging outgoing TCP NetPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << tnps->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << tnps->size << " " << inet_ntoa(in) << ":" << GetrPort();
-			if (pOldFormat)
-				std::cout << " (OldFormat)";
-			std::cout << std::endl;
-			#if TCPN_LOG_PACKETS == 2
-				if (tnps->size >= 32)
-					DumpPacket((uchar*) tnps, 32);
-				else
-					DumpPacket((uchar*) tnps, tnps->size);
-			#endif
-			#if TCPN_LOG_PACKETS >= 3
-				DumpPacket((uchar*) tnps, tnps->size);
-			#endif
-		}
-	#endif
-	ServerSendQueuePushEnd((const uchar*) tnps, tnps->size);
-	return true;
-}
-
-ServerPacket* EmuTCPConnection::PopPacket() {
-	ServerPacket* ret;
-	if (!MOutQueueLock.trylock())
-		return nullptr;
-	ret = OutQueue.pop();
-	MOutQueueLock.unlock();
-	return ret;
-}
-
-void EmuTCPConnection::InModeQueuePush(EmuTCPNetPacket_Struct* tnps) {
-	MSendQueue.lock();
-	InModeQueue.push(tnps);
-	MSendQueue.unlock();
-}
-
-void EmuTCPConnection::OutQueuePush(ServerPacket* pack) {
-	MOutQueueLock.lock();
-	OutQueue.push(pack);
-	MOutQueueLock.unlock();
-}
-
-
-bool EmuTCPConnection::LineOutQueuePush(char* line) {
-	#if defined(GOTFRAGS) && 0
-		if (strcmp(line, "**CRASHME**") == 0) {
-			int i = 0;
-			std::cout << (5 / i) << std::endl;
-		}
-	#endif
-	if(line[0] == '*') {
-		if (strcmp(line, "**PACKETMODE**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODE**\r", 16);
-			TCPMode = modePacket;
-			PacketMode = packetModeLogin;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEZONE**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEZONE**\r", 20);
-			TCPMode = modePacket;
-			PacketMode = packetModeZone;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODELAUNCHER**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODELAUNCHER**\r", 24);
-			TCPMode = modePacket;
-			PacketMode = packetModeLauncher;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEUCS**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEUCS**\r", 19);
-			TCPMode = modePacket;
-			PacketMode = packetModeUCS;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-		if (strcmp(line, "**PACKETMODEQS**") == 0) {
-			MSendQueue.lock();
-			safe_delete_array(sendbuf);
-			if (TCPMode == modeConsole)
-				Send((const uchar*) "\0**PACKETMODEQS**\r", 18);
-			TCPMode = modePacket;
-			PacketMode = packetModeQueryServ;
-			EmuTCPNetPacket_Struct* tnps = 0;
-			while ((tnps = InModeQueue.pop())) {
-				SendPacket(tnps);
-				safe_delete_array(tnps);
-			}
-			MSendQueue.unlock();
-			safe_delete_array(line);
-			return(true);
-		}
-	}
-
-	return(TCPConnection::LineOutQueuePush(line));
-}
-
-void EmuTCPConnection::Disconnect(bool iSendRelayDisconnect) {
-	TCPConnection::Disconnect();
-
-	if (RelayLink) {
-		RelayLink->RemoveRelay(this, iSendRelayDisconnect);
-		RelayLink = 0;
-	}
-}
-
-bool EmuTCPConnection::ConnectIP(uint32 irIP, uint16 irPort, char* errbuf) {
-	if(!TCPConnection::ConnectIP(irIP, irPort, errbuf))
-		return(false);
-
-	MSendQueue.lock();
-	#ifdef MINILOGIN
-		TCPMode = modePacket;
-	#else
-		if (pOldFormat) {
-			TCPMode = modePacket;
-		}
-		else if (TCPMode == modePacket || TCPMode == modeTransition) {
-			TCPMode = modeTransition;
-			if(PacketMode == packetModeLauncher) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 24;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODELAUNCHER**\r", sendbuf_size);
-			} else if(PacketMode == packetModeLogin) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 16;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODE**\r", sendbuf_size);
-			} else if(PacketMode == packetModeUCS) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 19;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEUCS**\r", sendbuf_size);
-			}
-			else if(PacketMode == packetModeQueryServ) {
-				safe_delete_array(sendbuf);
-				sendbuf_size = 18;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEQS**\r", sendbuf_size);
-			} 
-			else {
-				//default: packetModeZone
-				safe_delete_array(sendbuf);
-				sendbuf_size = 20;
-				sendbuf_used = sendbuf_size;
-				sendbuf = new uchar[sendbuf_size];
-				memcpy(sendbuf, "\0**PACKETMODEZONE**\r", sendbuf_size);
-			}
-		}
-	#endif
-	MSendQueue.unlock();
-
-	return(true);
-}
-
-void EmuTCPConnection::ClearBuffers() {
-	TCPConnection::ClearBuffers();
-
-	LockMutex lock2(&MOutQueueLock);
-	ServerPacket* pack = 0;
-	while ((pack = OutQueue.pop()))
-		safe_delete(pack);
-
-	EmuTCPNetPacket_Struct* tnps = 0;
-	while ((tnps = InModeQueue.pop()))
-		safe_delete(tnps);
-
-	keepalive_timer.Start();
-	timeout_timer.Start();
-}
-
-void EmuTCPConnection::SendNetErrorPacket(const char* reason) {
-	#if TCPC_DEBUG >= 1
-		struct in_addr	in;
-		in.s_addr = GetrIP();
-		std::cout "NetError: '";
-		if (reason)
-			std::cout << reason;
-		std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-	#endif
-		auto pack = new ServerPacket(0);
-		pack->size = 1;
-		if (reason)
-			pack->size += strlen(reason) + 1;
-		pack->pBuffer = new uchar[pack->size];
-		memset(pack->pBuffer, 0, pack->size);
-		pack->pBuffer[0] = 255;
-		strcpy((char *)&pack->pBuffer[1], reason);
-		SendPacket(pack);
-		safe_delete(pack);
-}
-
-void EmuTCPConnection::RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect) {
-	if (iSendRelayDisconnect) {
-		auto pack = new ServerPacket(0, 5);
-		pack->pBuffer[0] = 3;
-		*((uint32*) &pack->pBuffer[1]) = relay->GetRemoteID();
-		SendPacket(pack);
-		safe_delete(pack);
-	}
-	RelayCount--;
-}
-
-
-
-bool EmuTCPConnection::ProcessReceivedData(char* errbuf) {
-	if (errbuf)
-		errbuf[0] = 0;
-	timeout_timer.Start();
-	if (!recvbuf)
-		return true;
-	if (TCPMode == modePacket) {
-		if (pOldFormat)
-			return ProcessReceivedDataAsOldPackets(errbuf);
-		else
-			return ProcessReceivedDataAsPackets(errbuf);
-	}
-	//else, use the base class's text processing.
-	bool ret = TCPConnection::ProcessReceivedData(errbuf);
-	//see if we made the transition to packet mode...
-	if(ret && TCPMode == modePacket) {
-		return ProcessReceivedDataAsPackets(errbuf);
-	}
-	return(ret);
-}
-
-
-
-bool EmuTCPConnection::ProcessReceivedDataAsPackets(char* errbuf) {
-	if (errbuf)
-		errbuf[0] = 0;
-	int32 base = 0;
-	int32 size = 7;
-	uchar* buffer;
-	ServerPacket* pack = 0;
-	while ((recvbuf_used - base) >= size) {
-		EmuTCPNetPacket_Struct* tnps = (EmuTCPNetPacket_Struct*) &recvbuf[base];
-		buffer = tnps->buffer;
-		size = tnps->size;
-		if (size >= MaxTCPReceiveBuffferSize) {
-#if TCPN_DEBUG_Memory >= 1
-			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
-			DumpPacket(&recvbuf[base], 16);
-#endif
-			if (errbuf)
-				snprintf(errbuf, TCPConnection_ErrorBufferSize, "EmuTCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBuffferSize");
-			return false;
-		}
-		if ((recvbuf_used - base) >= size) {
-			// ok, we got enough data to make this packet!
-			pack = new ServerPacket;
-			pack->size = size - sizeof(EmuTCPNetPacket_Struct);
-			// read headers
-			pack->opcode = tnps->opcode;
-			if (tnps->flags.compressed) {
-				pack->compressed = true;
-				pack->InflatedSize = *((int32*)buffer);
-				pack->size -= 4;
-				buffer += 4;
-			}
-			if (tnps->flags.destination) {
-				pack->destination = *((int32*)buffer);
-				pack->size -= 4;
-				buffer += 4;
-			}
-			// end read headers
-			if (pack->size > 0) {
-				if (tnps->flags.compressed) {
-					// Lets decompress the packet here
-					pack->compressed = false;
-					pack->pBuffer = new uchar[pack->InflatedSize];
-					pack->size = InflatePacket(buffer, pack->size, pack->pBuffer, pack->InflatedSize);
-				}
-				else {
-					pack->pBuffer = new uchar[pack->size];
-					memcpy(pack->pBuffer, buffer, pack->size);
-				}
-			}
-			if (pack->opcode == 0) {
-				if (pack->size) {
-					#if TCPN_DEBUG >= 2
-						std::cout << "Received TCP Network layer packet" << std::endl;
-					#endif
-					ProcessNetworkLayerPacket(pack);
-				}
-				#if TCPN_DEBUG >= 5
-					else {
-						std::cout << "Received TCP keepalive packet. (opcode=0)" << std::endl;
-					}
-				#endif
-				// keepalive, no need to process
-				safe_delete(pack);
-			}
-			else {
-				#if TCPN_LOG_PACKETS >= 1
-					if (pack && pack->opcode != 0) {
-						struct in_addr	in;
-						in.s_addr = GetrIP();
-						CoutTimestamp(true);
-						std::cout << ": Logging incoming TCP packet. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-						#if TCPN_LOG_PACKETS == 2
-							if (pack->size >= 32)
-								DumpPacket(pack->pBuffer, 32);
-							else
-								DumpPacket(pack);
-						#endif
-						#if TCPN_LOG_PACKETS >= 3
-							DumpPacket(pack);
-						#endif
-					}
-				#endif
-				if (RelayServer && Server && pack->destination) {
-					EmuTCPConnection* con = Server->FindConnection(pack->destination);
-					if (!con) {
-						#if TCPN_DEBUG >= 1
-							std::cout << "Error relaying packet: con = 0" << std::endl;
-						#endif
-						safe_delete(pack);
-					}
-					else
-						con->OutQueuePush(pack);
-				}
-				else
-					OutQueuePush(pack);
-			}
-			base += size;
-			size = 7;
-		}
-	}
-	if (base != 0) {
-		if (base >= recvbuf_used) {
-			safe_delete_array(recvbuf);
-		} else {
-			auto tmpbuf = new uchar[recvbuf_size - base];
-			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
-			safe_delete_array(recvbuf);
-			recvbuf = tmpbuf;
-			recvbuf_used -= base;
-			recvbuf_size -= base;
-		}
-	}
-	return true;
-}
-
-bool EmuTCPConnection::ProcessReceivedDataAsOldPackets(char* errbuf) {
-	int32 base = 0;
-	int32 size = 4;
-	uchar* buffer;
-	ServerPacket* pack = 0;
-	while ((recvbuf_used - base) >= size) {
-		buffer = &recvbuf[base];
-		memcpy(&size, &buffer[2], 2);
-		if (size >= MaxTCPReceiveBuffferSize) {
-#if TCPN_DEBUG_Memory >= 1
-			std::cout << "TCPConnection[" << GetID() << "]::ProcessReceivedDataAsPackets(): size[" << size << "] >= MaxTCPReceiveBuffferSize" << std::endl;
-#endif
-			if (errbuf)
-				snprintf(errbuf, TCPConnection_ErrorBufferSize, "EmuTCPConnection::ProcessReceivedDataAsPackets(): size >= MaxTCPReceiveBuffferSize");
-			return false;
-		}
-		if ((recvbuf_used - base) >= size) {
-			// ok, we got enough data to make this packet!
-			pack = new ServerPacket;
-			memcpy(&pack->opcode, &buffer[0], 2);
-			pack->size = size - 4;
-/*			if () { // TODO: Checksum or size check or something similar
-				// Datastream corruption, get the hell outta here!
-				delete pack;
-				return false;
-			}*/
-			if (pack->size > 0) {
-				pack->pBuffer = new uchar[pack->size];
-				memcpy(pack->pBuffer, &buffer[4], pack->size);
-			}
-			if (pack->opcode == 0) {
-				// keepalive, no need to process
-				safe_delete(pack);
-			}
-			else {
-				#if TCPN_LOG_PACKETS >= 1
-					if (pack && pack->opcode != 0) {
-						struct in_addr	in;
-						in.s_addr = GetrIP();
-						CoutTimestamp(true);
-						std::cout << ": Logging incoming TCP OldPacket. OPCode: 0x" << std::hex << std::setw(4) << std::setfill('0') << pack->opcode << std::dec << ", size: " << std::setw(5) << std::setfill(' ') << pack->size << " " << inet_ntoa(in) << ":" << GetrPort() << std::endl;
-						#if TCPN_LOG_PACKETS == 2
-							if (pack->size >= 32)
-								DumpPacket(pack->pBuffer, 32);
-							else
-								DumpPacket(pack);
-						#endif
-						#if TCPN_LOG_PACKETS >= 3
-							DumpPacket(pack);
-						#endif
-					}
-				#endif
-				OutQueuePush(pack);
-			}
-			base += size;
-			size = 4;
-		}
-	}
-	if (base != 0) {
-		if (base >= recvbuf_used) {
-			safe_delete_array(recvbuf);
-		}
-		else {
-			auto tmpbuf = new uchar[recvbuf_size - base];
-			memcpy(tmpbuf, &recvbuf[base], recvbuf_used - base);
-			safe_delete_array(recvbuf);
-			recvbuf = tmpbuf;
-			recvbuf_used -= base;
-			recvbuf_size -= base;
-		}
-	}
-	return true;
-}
-
-void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
-	uint8 opcode = pack->pBuffer[0];
-	uint8* data = &pack->pBuffer[1];
-	switch (opcode) {
-		case 0: {
-			break;
-		}
-		case 1: { // Switch to RelayServer mode
-			if (pack->size != 1) {
-				SendNetErrorPacket("New RelayClient: wrong size, expected 1");
-				break;
-			}
-			if (RelayServer) {
-				SendNetErrorPacket("Switch to RelayServer mode when already in RelayServer mode");
-				break;
-			}
-			if (RemoteID) {
-				SendNetErrorPacket("Switch to RelayServer mode by a Relay Client");
-				break;
-			}
-			if (ConnectionType != Incoming) {
-				SendNetErrorPacket("Switch to RelayServer mode on outgoing connection");
-				break;
-			}
-			#if TCPC_DEBUG >= 3
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				std::cout << "Switching to RelayServer mode: " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-			#endif
-			RelayServer = true;
-			break;
-		}
-		case 2: { // New Relay Client
-			if (!RelayServer) {
-				SendNetErrorPacket("New RelayClient when not in RelayServer mode");
-				break;
-			}
-			if (pack->size != 11) {
-				SendNetErrorPacket("New RelayClient: wrong size, expected 11");
-				break;
-			}
-			if (ConnectionType != Incoming) {
-				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
-				break;
-			}
-			auto con = new EmuTCPConnection(Server->GetNextID(), Server, this, *((uint32 *)data),
-							*((uint32 *)&data[4]), *((uint16 *)&data[8]));
-			Server->AddConnection(con);
-			RelayCount++;
-			break;
-		}
-		case 3: { // Delete Relay Client
-			if (!RelayServer) {
-				SendNetErrorPacket("Delete RelayClient when not in RelayServer mode");
-				break;
-			}
-			if (pack->size != 5) {
-				SendNetErrorPacket("Delete RelayClient: wrong size, expected 5");
-				break;
-			}
-			EmuTCPConnection* con = Server->FindConnection(*((uint32*)data));
-			if (con) {
-				if (ConnectionType == Incoming) {
-					if (con->GetRelayLink() != this) {
-						SendNetErrorPacket("Delete RelayClient: RelayLink != this");
-						break;
-					}
-				}
-				con->Disconnect(false);
-			}
-			break;
-		}
-		case 255: {
-			#if TCPC_DEBUG >= 1
-				struct in_addr	in;
-				in.s_addr = GetrIP();
-				std::cout "Received NetError: '";
-				if (pack->size > 1)
-					std::cout << (char*) data;
-				std::cout << "': " << inet_ntoa(in) << ":" << GetPort() << std::endl;
-			#endif
-			break;
-		}
-	}
-}
-
-bool EmuTCPConnection::SendData(bool &sent_something, char* errbuf) {
-	sent_something = false;
-	if(!TCPConnection::SendData(sent_something, errbuf))
-		return(false);
-
-	if(sent_something)
-		keepalive_timer.Start();
-	else if (TCPMode == modePacket && keepalive_timer.Check()) {
-		auto pack = new ServerPacket(0, 0);
-		SendPacket(pack);
-		safe_delete(pack);
-		#if TCPN_DEBUG >= 5
-		std::cout << "Sending TCP keepalive packet. (timeout=" << timeout_timer.GetRemainingTime() << " remaining)" << std::endl;
-		#endif
-	}
-
-	return(true);
-}
-
-bool EmuTCPConnection::RecvData(char* errbuf) {
-	if(!TCPConnection::RecvData(errbuf)) {
-		if (OutQueue.count())
-			return(true);
-		else
-			return(false);
-	}
-
-	if ((TCPMode == modePacket || TCPMode == modeTransition) && timeout_timer.Check()) {
-		if (errbuf)
-			snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::RecvData(): Connection timeout");
-		return false;
-	}
-
-	return(true);
-}
-
@@ -1,104 +0,0 @@
-#ifndef EmuTCPCONNECTION_H_
-#define EmuTCPCONNECTION_H_
-
-#include "tcp_connection.h"
-#include "timer.h"
-
-//moved out of TCPConnection:: to be more exportable
-#pragma pack(1)
-	struct EmuTCPNetPacket_Struct {
-		uint32	size;
-		struct {
-			uint8
-				compressed : 1,
-				destination : 1,
-				flag3 : 1,
-				flag4 : 1,
-				flag5 : 1,
-				flag6 : 1,
-				flag7 : 1,
-				flag8 : 1;
-		} flags;
-		uint16	opcode;
-		uchar	buffer[0];
-	};
-#pragma pack()
-
-struct SPackSendQueue;
-class EmuTCPServer;
-class ServerPacket;
-
-class EmuTCPConnection : public TCPConnection {
-public:
-	enum eTCPMode { modeConsole, modeTransition, modePacket };
-	enum ePacketMode { packetModeZone, packetModeLauncher, packetModeLogin, packetModeUCS, packetModeQueryServ };
-
-	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, SOCKET iSock, uint32 irIP, uint16 irPort, bool iOldFormat = false);
-	EmuTCPConnection(bool iOldFormat = false, EmuTCPServer* iRelayServer = 0, eTCPMode iMode = modePacket);	// for outgoing connections
-	EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConnection* iRelayLink, uint32 iRemoteID, uint32 irIP, uint16 irPort);				// for relay connections
-	virtual ~EmuTCPConnection();
-
-	virtual bool	ConnectIP(uint32 irIP, uint16 irPort, char* errbuf = 0);
-	virtual void	Disconnect(bool iSendRelayDisconnect = true);
-
-	static EmuTCPNetPacket_Struct* MakePacket(ServerPacket* pack, uint32 iDestination = 0);
-	static SPackSendQueue* MakeOldPacket(ServerPacket* pack);
-
-	virtual bool	SendPacket(ServerPacket* pack, uint32 iDestination = 0);
-	virtual bool	SendPacket(EmuTCPNetPacket_Struct* tnps);
-	ServerPacket*	PopPacket(); // OutQueuePop()
-	void SetPacketMode(ePacketMode mode) { PacketMode = mode; }
-
-	eTCPMode		GetMode()	const		{ return TCPMode; }
-	ePacketMode		GetPacketMode() const	{ return(PacketMode); }
-
-	//relay crap:
-	inline bool		IsRelayServer() const { return RelayServer; }
-	inline TCPConnection* GetRelayLink() const	{ return RelayLink; }
-	inline uint32	GetRemoteID() const	{ return RemoteID; }
-
-protected:
-	void	OutQueuePush(ServerPacket* pack);
-	void	RemoveRelay(EmuTCPConnection* relay, bool iSendRelayDisconnect);
-
-	void	SendNetErrorPacket(const char* reason = 0);
-
-	virtual bool SendData(bool &sent_something, char* errbuf = 0);
-	virtual bool RecvData(char* errbuf = 0);
-
-	virtual bool ProcessReceivedData(char* errbuf = 0);
-	bool ProcessReceivedDataAsPackets(char* errbuf = 0);
-	bool ProcessReceivedDataAsOldPackets(char* errbuf = 0);
-	void ProcessNetworkLayerPacket(ServerPacket* pack);
-
-	virtual bool LineOutQueuePush(char* line);
-	virtual void ClearBuffers();
-
-	EmuTCPServer*		Server;
-
-	eTCPMode		TCPMode;
-	ePacketMode		PacketMode;
-	bool pOldFormat;
-
-	Timer keepalive_timer;
-	Timer timeout_timer;
-
-	//relay crap:
-	EmuTCPConnection*	RelayLink;
-	int32			RelayCount;
-	bool	RelayServer;
-	uint32			RemoteID;
-
-	//input queue...
-	void	InModeQueuePush(EmuTCPNetPacket_Struct* tnps);
-	MyQueue<EmuTCPNetPacket_Struct> InModeQueue;
-
-	//output queue...
-	MyQueue<ServerPacket> OutQueue;
-	Mutex	MOutQueueLock;
-};
-
-#endif /*EmuTCPCONNECTION_H_*/
-
-
-
@@ -1,81 +0,0 @@
-#include "global_define.h"
-#include "emu_tcp_server.h"
-#include "emu_tcp_connection.h"
-
-EmuTCPServer::EmuTCPServer(uint16 iPort, bool iOldFormat)
-:	TCPServer<EmuTCPConnection>(iPort),
-	pOldFormat(iOldFormat)
-{
-}
-
-EmuTCPServer::~EmuTCPServer() {
-	MInQueue.lock();
-	while(!m_InQueue.empty()) {
-		delete m_InQueue.front();
-		m_InQueue.pop();
-	}
-	MInQueue.unlock();
-}
-
-void EmuTCPServer::Process() {
-	CheckInQueue();
-	TCPServer<EmuTCPConnection>::Process();
-}
-
-void EmuTCPServer::CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort)
-{
-	auto conn = new EmuTCPConnection(ID, this, in_socket, irIP, irPort, pOldFormat);
-	AddConnection(conn);
-}
-
-
-void EmuTCPServer::SendPacket(ServerPacket* pack) {
-	EmuTCPNetPacket_Struct* tnps = EmuTCPConnection::MakePacket(pack);
-	SendPacket(&tnps);
-}
-
-void EmuTCPServer::SendPacket(EmuTCPNetPacket_Struct** tnps) {
-	MInQueue.lock();
-	m_InQueue.push(*tnps);
-	MInQueue.unlock();
-	tnps = nullptr;
-}
-
-void EmuTCPServer::CheckInQueue() {
-	EmuTCPNetPacket_Struct* tnps = 0;
-
-	while (( tnps = InQueuePop() )) {
-		vitr cur, end;
-		cur = m_list.begin();
-		end = m_list.end();
-		for(; cur != end; cur++) {
-			if ((*cur)->GetMode() != EmuTCPConnection::modeConsole && (*cur)->GetRemoteID() == 0)
-				(*cur)->SendPacket(tnps);
-		}
-		safe_delete(tnps);
-	}
-}
-
-EmuTCPNetPacket_Struct* EmuTCPServer::InQueuePop() {
-	EmuTCPNetPacket_Struct* ret = nullptr;
-	MInQueue.lock();
-	if(!m_InQueue.empty()) {
-		ret = m_InQueue.front();
-		m_InQueue.pop();
-	}
-	MInQueue.unlock();
-	return ret;
-}
-
-
-EmuTCPConnection *EmuTCPServer::FindConnection(uint32 iID) {
-	vitr cur, end;
-	cur = m_list.begin();
-	end = m_list.end();
-	for(; cur != end; cur++) {
-		if ((*cur)->GetID() == iID)
-			return *cur;
-	}
-	return(nullptr);
-}
-
@@ -1,38 +0,0 @@
-#ifndef EmuTCPSERVER_H_
-#define EmuTCPSERVER_H_
-
-#include "tcp_server.h"
-
-class EmuTCPConnection;
-struct EmuTCPNetPacket_Struct;
-class ServerPacket;
-
-class EmuTCPServer : public TCPServer<EmuTCPConnection> {
-public:
-	EmuTCPServer(uint16 iPort = 0, bool iOldFormat = false);
-	virtual ~EmuTCPServer();
-
-	//packet broadcast routines.
-	void	SendPacket(ServerPacket* pack);
-	void	SendPacket(EmuTCPNetPacket_Struct** tnps);
-
-	//special crap for relay management
-	EmuTCPConnection *FindConnection(uint32 iID);
-
-	//exposed for some crap we pull. Do not call from outside this object.
-	using TCPServer<EmuTCPConnection>::AddConnection;
-
-protected:
-	virtual void	Process();
-
-	virtual void CreateNewConnection(uint32 ID, SOCKET in_socket, uint32 irIP, uint16 irPort);
-
-	bool pOldFormat;
-
-	//broadcast packet queue..
-	void	CheckInQueue();
-	Mutex	MInQueue;
-	EmuTCPNetPacket_Struct*	InQueuePop();	//returns ownership
-	std::queue<EmuTCPNetPacket_Struct *> m_InQueue;
-};
-#endif /*EmuTCPSERVER_H_*/
@@ -27,7 +27,7 @@
 //SpawnAppearance types: (compared two clients for server-originating types: SoF & RoF2)
 #define AT_Die 0			// this causes the client to keel over and zone to bind point (default action)
 #define AT_WhoLevel 1		// the level that shows up on /who
-//#define AT_2 2			// unknown
+#define AT_HPMax 2			// idk
 #define AT_Invis 3			// 0 = visible, 1 = invisible
 #define AT_PVP 4			// 0 = blue, 1 = pvp (red)
 #define AT_Light 5			// light type emitted by player (lightstone, shiny shield)
@@ -36,33 +36,37 @@
 #define AT_SpawnID 16		// server to client, sets player spawn id
 #define AT_HP 17			// Client->Server, my HP has changed (like regen tic)
 #define AT_Linkdead 18		// 0 = normal, 1 = linkdead
-#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate
+#define AT_Levitate 19		// 0=off, 1=flymode, 2=levitate max 5, see GravityBehavior enum
 #define AT_GM 20			// 0 = normal, 1 = GM - all odd numbers seem to make it GM
 #define AT_Anon 21			// 0 = normal, 1 = anon, 2 = roleplay
 #define AT_GuildID 22
 #define AT_GuildRank 23		// 0=member, 1=officer, 2=leader
 #define AT_AFK 24			// 0 = normal, 1 = afk
 #define AT_Pet 25			// Param is EntityID of owner, or 0 for when charm breaks
-//#define AT_27 27			// unknown
+#define AT_Summoned 27		// Unsure
 #define AT_Split 28			// 0 = normal, 1 = autosplit on (not showing in SoF+) (client-to-server only)
 #define AT_Size 29			// spawn's size (present: SoF, absent: RoF2)
-//#define AT_30 30			// unknown
-#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name
-//#define AT_32 32			// unknown
-//#define AT_33 33			// unknown
+#define AT_SetType 30		// 0 = PC, 1 = NPC, 2 <= = corpse
+#define AT_NPCName 31		// change PC's name's color to NPC color 0 = normal, 1 = npc name, Trader on RoF2?
+#define AT_AARank 32		// AA Rank Title ID thingy, does is this the title in /who?
+#define AT_CancelSneakHide 33	// Turns off Hide and Sneak
 //#define AT_34 34			// unknown (present: SoF, absent: RoF2)
-//#define AT_35 35			// unknown
-//#define AT_36 36			// unknown
-//#define AT_37 37			// unknown
-//#define AT_38 38			// unknown
-//#define AT_39 39			// unknown
+#define AT_AreaHPRegen 35	// guild hall regen pool sets to value * 0.001
+#define AT_AreaManaRegen 36	// guild hall regen pool sets to value * 0.001
+#define AT_AreaEndRegen 37	// guild hall regen pool sets to value * 0.001
+#define AT_FreezeBuffs 38	// Freezes beneficial buff timers
+#define AT_NpcTintIndex 39	// not 100% sure
+#define AT_GroupConsent 40	// auto consent group
+#define AT_RaidConsent 41	// auto consent raid
+#define AT_GuildConsent 42	// auto consent guild
 #define AT_ShowHelm 43		// 0 = hide graphic, 1 = show graphic
-#define AT_DamageState 44	// The damage state of a destructible object (0 through 4)
-//#define AT_46 46			// unknown
-//#define AT_48 48			// unknown
-//#define AT_49 49			// unknown
-//#define AT_52 52			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
-//#define AT_53 53			// (absent: SoF, present: RoF2) (not a replacement for RoF absent 29 or 34)
+#define AT_DamageState 44	// The damage state of a destructible object (0 through 10) plays soundids most only have 2 or 4 states though
+#define AT_EQPlayers 45		// /eqplayersupdate
+#define AT_FindBits 46		// set FindBits, whatever those are!
+#define AT_TextureType 48	// TextureType
+#define AT_FacePick 49		// Turns off face pick window? maybe ...
+#define AT_GuildShow 52		// this is what MQ2 call sit, not sure
+#define AT_Offline 53		// Offline mode

 //#define AT_Trader 300		// Bazaar Trader Mode (not present in SoF or RoF2)

@@ -132,7 +132,7 @@ void EQApplicationPacket::build_header_dump(char *buffer) const
 #ifdef STATIC_OPCODE
 	sprintf(buffer, "[OpCode 0x%04x Size=%u]\n", emu_opcode,size);
 #else
-	sprintf(buffer, "[OpCode %s Size=%u]",OpcodeManager::EmuToName(emu_opcode),size);
+	sprintf(buffer, "[OpCode %s(0x%04x) Size=%u]",OpcodeManager::EmuToName(emu_opcode), GetProtocolOpcode(), size);
 #endif
 }

@@ -115,11 +115,14 @@ public:
 	virtual void DumpRawHeader(uint16 seq=0xffff, FILE *to = stdout) const;
 	virtual void DumpRawHeaderNoTime(uint16 seq=0xffff, FILE *to = stdout) const;

-	uint16 GetOpcodeBypass() { return opcode_bypass; }
+	uint16 GetOpcodeBypass() const { return opcode_bypass; }
 	void SetOpcodeBypass(uint16 v) { opcode_bypass = v; }

+	uint16 GetProtocolOpcode() const { return protocol_opcode; }
+	void SetProtocolOpcode(uint16 v) { protocol_opcode = v; }
 protected:

+	uint16 protocol_opcode;
 	uint8 app_opcode_size;
 	uint16 opcode_bypass;
 private:
@@ -305,6 +305,7 @@ union
 	uint8 DestructibleUnk8;
 	uint32 DestructibleUnk9;
 	bool targetable_with_hotkey;
+	bool show_name;

 };

@@ -1116,6 +1117,11 @@ struct PetCommand_Struct {
 /*004*/ uint32	target;
 };

+struct PetCommandState_Struct {
+/*00*/	uint32	button_id;
+/*04*/	uint32	state;
+};
+
 /*
 ** Delete Spawn
 ** Length: 4 Bytes
@@ -1690,6 +1696,7 @@ struct OnLevelMessage_Struct
 	uint32	Duration;
 	uint32	PopupID;
 	uint32	NegativeID;
+	uint32  SoundControls;
 	char	ButtonName0[25];
 	char	ButtonName1[25];
 };
@@ -2243,6 +2250,7 @@ struct GroupFollow_Struct { // SoF Follow Struct
 /*0132*/
 };

+// this is generic struct
 struct GroupLeaderChange_Struct
 {
 /*000*/		char	Unknown000[64];
@@ -2495,6 +2503,7 @@ struct BookRequest_Struct {
 	uint8 window;	// where to display the text (0xFF means new window)
 	uint8 type;		//type: 0=scroll, 1=book, 2=item info.. prolly others.
 	uint32 invslot;	// Only used in Sof and later clients;
+	int16 subslot; // The subslot inside of a bag if it is inside one.
 	char txtfile[20];
 };

@@ -5324,6 +5333,24 @@ struct fling_struct {
 /* 28 */
 };

+// used when action == 0
+struct AuraCreate_Struct {
+/* 00 */	uint32 action; // 0 = add, 1 = delete, 2 = reset
+/* 04 */	uint32 type; // unsure -- normal auras show 1 clicky (ex. Circle of Power) show 0
+/* 08 */	char aura_name[64];
+/* 72 */	uint32 entity_id;
+/* 76 */	uint32 icon;
+/* 80 */
+};
+
+// used when action == 1
+struct AuraDestory_Struct {
+/* 00 */	uint32 action; // 0 = add, 1 = delete, 2 = reset
+/* 04 */	uint32 entity_id;
+/* 08 */
+};
+// I think we can assume it's just action for 2, client doesn't seem to do anything with the rest of the data in that case
+
 // Restore structure packing to default
 #pragma pack()

@@ -84,14 +84,14 @@ void EQStream::init(bool resetSession) {

 	OpMgr = nullptr;
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+		Log(Logs::Detail, Logs::Netcode, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}
 }

 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
+	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
 	// _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
 	ap = p->MakeAppPacket();
 	return ap;
@@ -100,7 +100,7 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
+	Log(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
 	ap = new EQRawApplicationPacket(buf, len);
 	return ap;
 }
@@ -130,7 +130,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 	}

 	if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Session not initialized, packet ignored" __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Session not initialized, packet ignored" __L);
 		// _raw(NET__DEBUG, 0xFFFF, p);
 		return;
 	}
@@ -141,7 +141,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed < p->size) {
 				subpacket_length=*(p->pBuffer+processed);
 				EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
+				Log(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
 				// _raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
 				subp->copyInfo(p);
 				ProcessPacket(subp);
@@ -156,12 +156,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed<p->size) {
 				EQRawApplicationPacket *ap=nullptr;
 				if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+1,subpacket_length);
 					processed+=subpacket_length+1;
 				} else {
 					subpacket_length=ntohs(*(uint16 *)(p->pBuffer+processed+1));
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					Log(Logs::Detail, Logs::Netcode, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
 					ap=MakeApplicationPacket(p->pBuffer+processed+3,subpacket_length);
 					processed+=subpacket_length+3;
 				}
@@ -176,29 +176,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Packet: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Packet that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Packet that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+					Log(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 					// _raw(NET__DEBUG, seq, p);

 					PacketQueue[seq]=p->Copy();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+					Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());

 				//SendOutOfOrderAck(seq);

 			} else if (check == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq); //we already got this packet but it was out of order
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
+					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
 					delete qp;
 				}

@@ -207,7 +207,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				// Check for an embedded OP_AppCombinded (protocol level 0x19)
 				if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 					EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+2,p->size-2);
-					Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
+					Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
 					// _raw(NET__NET_CREATE_HEX, seq, subp);
 					subp->copyInfo(p);
 					ProcessPacket(subp);
@@ -226,29 +226,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Fragment: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Fragment that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Fragment that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			SeqOrder check=CompareSequence(NextInSeq,seq);
 			if (check == SeqFuture) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);

 				PacketQueue[seq]=p->Copy();
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
+				Log(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());

 				//SendOutOfOrderAck(seq);

 			} else if (check == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
 				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq);
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
+					Log(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
 					delete qp;
 				}
 				SetNextAckToSend(seq);
@@ -256,18 +256,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				if (oversize_buffer) {
 					memcpy(oversize_buffer+oversize_offset,p->pBuffer+2,p->size-2);
 					oversize_offset+=p->size-2;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
+					Log(Logs::Detail, Logs::Netcode, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
 					if (oversize_offset==oversize_length) {
 						if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 							EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
-							Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
+							Log(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
 							//// _raw(NET__NET_CREATE_HEX, subp);
 							subp->copyInfo(p);
 							ProcessPacket(subp);
 							delete subp;
 						} else {
 							EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
-							Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
+							Log(Logs::Detail, Logs::Netcode, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
 							if (ap) {
 								ap->copyInfo(p);
 								InboundQueuePush(ap);
@@ -282,20 +282,20 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					oversize_buffer=new unsigned char[oversize_length];
 					memcpy(oversize_buffer,p->pBuffer+6,p->size-6);
 					oversize_offset=p->size-6;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
+					Log(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
 				}
 			}
 		}
 		break;
 		case OP_KeepAlive: {
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
 		}
 		break;
 		case OP_Ack: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
@@ -309,11 +309,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionRequest: {
 			if(p->Size() < sizeof(SessionRequest))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
 			if (GetState()==ESTABLISHED) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);

 				// client seems to try a max of 30 times (initial+3 retries) then gives up, giving it a few more attempts just in case
 				// streamactive means we identified the opcode for the stream, we cannot re-establish this connection
@@ -331,7 +331,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SessionRequest *Request=(SessionRequest *)p->pBuffer;
 			Session=ntohl(Request->Session);
 			SetMaxLen(ntohl(Request->MaxLength));
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
 			Key=0x11223344;
 			SendSessionResponse();
@@ -340,7 +340,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionResponse: {
 			if(p->Size() < sizeof(SessionResponse))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
 				break;
 			}

@@ -356,7 +356,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			compressed=(Response->Format&FLAG_COMPRESSED);
 			encoded=(Response->Format&FLAG_ENCODED);

-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse: session %lu, maxlen %d, key %lu, compressed? %s, encoded? %s" __L, (unsigned long)Session, MaxLen, (unsigned long)Key, compressed?"yes":"no", encoded?"yes":"no");

 			// Kinda kludgy, but trie for now
 			if (StreamType==UnknownStream) {
@@ -379,17 +379,17 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			EQStreamState state = GetState();
 			if(state == ESTABLISHED) {
 				//client initiated disconnect?
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else if(state == CLOSING) {
 				//we were waiting for this anyways, ignore pending messages, send the reply and be closed.
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else {
 				//we are expecting this (or have already gotten it, but dont care either way)
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
 				SetState(CLOSED);
 			}
 		}
@@ -397,24 +397,24 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_OutOfOrderAck: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
 			uint16 seq=ntohs(*(uint16 *)(p->pBuffer));
 			MOutboundQueue.lock();

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 			
 			//if the packet they got out of order is between our last acked packet and the last sent packet, then its valid.
 			if (CompareSequence(SequencedBase,seq) != SeqPast && CompareSequence(NextOutSeq,seq) == SeqPast) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
 					seq, SequencedBase, SequencedBase+SequencedQueue.size());

 				uint16 sqsize = SequencedQueue.size();
 				uint16 index = seq - SequencedBase;
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+				Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
 				if (index < sqsize) {
 					SequencedQueue[index]->acked = true;
 					// flag packets for a resend
@@ -423,7 +423,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end() && count < index; ++sitr, ++count) {
 						if (!(*sitr)->acked && (*sitr)->sent_time > 0 && (((*sitr)->sent_time + timeout) < Timer::GetCurrentTime())) {
 							(*sitr)->sent_time = 0;
-							Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
+							Log(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck Flagging packet %d for retransmission" __L, SequencedBase + count);
 						}
 					}
 				}
@@ -432,11 +432,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimer = Timer::GetCurrentTime();
 				}
 			} else {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
 			}

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}

 			MOutboundQueue.unlock();
@@ -445,11 +445,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionStatRequest: {
 			if(p->Size() < sizeof(ClientSessionStats))
 			{
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
+				Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
 			ClientSessionStats *ClientStats=(ClientSessionStats *)p->pBuffer;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
+			Log(Logs::Detail, Logs::Netcode, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
 				(unsigned long)ntohl(ClientStats->packets_received), (unsigned long)ntohl(ClientStats->packets_sent), (unsigned long)ntohl(ClientStats->last_local_delta),
 				(unsigned long)ntohl(ClientStats->low_delta), (unsigned long)ntohl(ClientStats->average_delta),
 				(unsigned long)ntohl(ClientStats->high_delta), (unsigned long)ntohl(ClientStats->last_remote_delta));
@@ -468,7 +468,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					retransmittimeout += 300;
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
+					Log(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
 				}
 			}

@@ -485,11 +485,11 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		}
 		break;
 		case OP_SessionStatResponse: {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
 		}
 		break;
 		case OP_OutOfSession: {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
 		}
 		break;
 		default:
@@ -520,7 +520,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 		return;

 	if(OpMgr == nullptr || *OpMgr == nullptr) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
 		delete pack;
 		return;
 	}
@@ -529,7 +529,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 	if(pack->GetOpcodeBypass() != 0) {
 		opcode = pack->GetOpcodeBypass();
 	} else {
-		opcode = (*OpMgr)->EmuToEQ(pack->emu_opcode);
+		opcode = (*OpMgr)->EmuToEQ(pack->GetOpcode());
 	}

 	if (!ack_req) {
@@ -545,32 +545,32 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 	uint32 chunksize, used;
 	uint32 length;

-	if (Log.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
-			Log.Out(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+			Log(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
 		}
 	}

-	if (Log.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
+	if (LogSys.log_settings[Logs::Server_Client_Packet_With_Dump].is_category_enabled == 1){
 		if (p->GetOpcode() != OP_SpecialMesg){
-			Log.Out(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
+			Log(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
 		}
 	}

 	// Convert the EQApplicationPacket to 1 or more EQProtocolPackets
 	if (p->size>(MaxLen-8)) { // proto-op(2), seq(2), app-op(2) ... data ... crc(2)
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());
+		Log(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->Size());

 		auto tmpbuff = new unsigned char[p->size + 3];
 		length=p->serialize(opcode, tmpbuff);
 		if (length != p->Size())
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);
+			Log(Logs::Detail, Logs::Netcode, _L "Packet adjustment, len %d to %d" __L, p->Size(), length);

 		auto out = new EQProtocolPacket(OP_Fragment, nullptr, MaxLen - 4);
 		*(uint32 *)(out->pBuffer+2)=htonl(length);
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
+		Log(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Payload size %d in the packet" __L, used, length, p->size);
 		SequencedPush(out);


@@ -581,7 +581,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
+			Log(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, length);
 		}
 		delete p;
 		delete[] tmpbuff;
@@ -602,18 +602,18 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
 	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+		Log(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
 			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
+	Log(Logs::Detail, Logs::Netcode, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L,
 		NextOutSeq, p->size, SequencedBase);
 	*(uint16 *)(p->pBuffer) = htons(NextOutSeq);
 	SequencedQueue.push_back(p);
 	NextOutSeq++;

 	if (uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
+		Log(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L,
 			SequencedBase, SequencedQueue.size(), NextOutSeq);
 	}

@@ -623,7 +623,7 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 void EQStream::NonSequencedPush(EQProtocolPacket *p)
 {
 	MOutboundQueue.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
+	Log(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
 	NonSequencedQueue.push(p);
 	MOutboundQueue.unlock();
 }
@@ -631,14 +631,14 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
 void EQStream::SendAck(uint16 seq)
 {
 uint16 Seq=htons(seq);
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending ack with sequence %d" __L, seq);
 	SetLastAckSent(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_Ack,(unsigned char *)&Seq,sizeof(uint16)));
 }

 void EQStream::SendOutOfOrderAck(uint16 seq)
 {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending out of order ack with sequence %d" __L, seq);
 uint16 Seq=htons(seq);
 	NonSequencedPush(new EQProtocolPacket(OP_OutOfOrderAck,(unsigned char *)&Seq,sizeof(uint16)));
 }
@@ -688,24 +688,24 @@ void EQStream::Write(int eq_fd)
 				// If we don't have a packet to try to combine into, use this one as the base
 				// And remove it form the queue
 				p = NonSequencedQueue.front();
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
 				NonSequencedQueue.pop();
 			} else if (!p->combine(NonSequencedQueue.front())) {
 				// Trying to combine this packet with the base didn't work (too big maybe)
 				// So just send the base packet (we'll try this packet again later)
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
 				ReadyToSend.push(p);
 				BytesWritten+=p->size;
 				p=nullptr;

 				if (BytesWritten > threshold) {
 					// Sent enough this round, lets stop to be fair
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
+					Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
 					break;
 				}
 			} else {
 				// Combine worked, so just remove this packet and it's spot in the queue
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
+				Log(Logs::Detail, Logs::Netcode, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
 				delete NonSequencedQueue.front();
 				NonSequencedQueue.pop();
 			}
@@ -718,7 +718,7 @@ void EQStream::Write(int eq_fd)
 			uint16 seq_send = SequencedBase + count;	//just for logging...

 			if(SequencedQueue.empty()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
 				SeqEmpty=true;
 				continue;
 			}
@@ -728,35 +728,35 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
 					}
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
+					Log(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
 				} else if (!p) {
 					// If we don't have a packet to try to combine into, use this one as the base
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send + 1, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 					if ((*sitr)->opcode != OP_Fragment && BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -766,7 +766,7 @@ void EQStream::Write(int eq_fd)
 					++sitr;
 					++count;
 					if (p) {
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+						Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
 						ReadyToSend.push(p);
 						BytesWritten += p->size;
 						p = nullptr;
@@ -776,25 +776,25 @@ void EQStream::Write(int eq_fd)
 					// Copy it first as it will still live until it is acked
 					p=(*sitr)->Copy();
 					(*sitr)->sent_time = Timer::GetCurrentTime();
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					++sitr;
 					++count;
 				} else if (!p->combine(*sitr)) {
 					// Trying to combine this packet with the base didn't work (too big maybe)
 					// So just send the base packet (we'll try this packet again later)
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;

 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						Log(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yielding %d combined." __L, seq_send, (*sitr)->size, p->size);
 					(*sitr)->sent_time = Timer::GetCurrentTime();
 					++sitr;
 					++count;
@@ -802,7 +802,7 @@ void EQStream::Write(int eq_fd)
 			}

 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log(Logs::Detail, Logs::Netcode, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 		} else {
 			// No more sequenced packets
@@ -814,7 +814,7 @@ void EQStream::Write(int eq_fd)

 	// We have a packet still, must have run out of both seq and non-seq, so send it
 	if (p) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
+		Log(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
 		ReadyToSend.push(p);
 		BytesWritten+=p->size;
 	}
@@ -831,7 +831,7 @@ void EQStream::Write(int eq_fd)
 	if(SeqEmpty && NonSeqEmpty) {
 		//no more data to send
 		if(CheckState(CLOSING)) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "All outgoing data flushed, closing stream." __L );
+			Log(Logs::Detail, Logs::Netcode, _L "All outgoing data flushed, closing stream." __L );
 			//we are waiting for the queues to empty, now we can do our disconnect.
 			//this packet will not actually go out until the next call to Write().
 			_SendDisconnect();
@@ -896,7 +896,7 @@ void EQStream::SendSessionResponse()

 	out->size=sizeof(SessionResponse);

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
 		(unsigned long)Session, MaxLen, Key, compressed?"yes":"no", encoded?"yes":"no");

 	NonSequencedPush(out);
@@ -910,7 +910,7 @@ void EQStream::SendSessionRequest()
 	Request->Session=htonl(time(nullptr));
 	Request->MaxLength=htonl(512);

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));

 	NonSequencedPush(out);
 }
@@ -924,7 +924,7 @@ void EQStream::_SendDisconnect()
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
+	Log(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
 }

 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@@ -950,7 +950,7 @@ EQRawApplicationPacket *p=nullptr;
 		if (OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if (emu_op == OP_Unknown) {
-				// Log.Out(Logs::General, Logs::Client_Server_Packet_Unhandled, "Unknown :: [%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->opcode, p->Size(), DumpPacketToString(p).c_str());
+				// Log(Logs::General, Logs::Client_Server_Packet_Unhandled, "Unknown :: [%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->opcode, p->Size(), DumpPacketToString(p).c_str());
 			} 
 			p->SetOpcode(emu_op);
 		}
@@ -976,7 +976,7 @@ EQRawApplicationPacket *p=nullptr;
 		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
 			if(emu_op == OP_Unknown) {
-				Log.Out(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
+				Log(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
 			}

 			p->SetOpcode(emu_op);
@@ -1004,7 +1004,7 @@ void EQStream::InboundQueueClear()
 {
 EQApplicationPacket *p=nullptr;

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);

 	MInboundQueue.lock();
 	if (!InboundQueue.empty()) {
@@ -1047,7 +1047,7 @@ void EQStream::OutboundQueueClear()
 {
 EQProtocolPacket *p=nullptr;

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);

 	MOutboundQueue.lock();
 	while(!NonSequencedQueue.empty()) {
@@ -1069,7 +1069,7 @@ void EQStream::PacketQueueClear()
 {
 EQProtocolPacket *p=nullptr;

-	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
+	Log(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);

 	if(!PacketQueue.empty()) {
 		std::map<unsigned short,EQProtocolPacket *>::iterator itr;
@@ -1101,7 +1101,7 @@ void EQStream::Process(const unsigned char *buffer, const uint32 length)
 		delete p;
 		ProcessQueue();
 	} else {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
 	}
 }

@@ -1132,23 +1132,23 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 	SeqOrder ord = CompareSequence(SequencedBase, seq);
 	if(ord == SeqInOrder) {
 		//they are not acking anything new...
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
+		Log(Logs::Detail, Logs::Netcode, _L "Received an ack with no window advancement (seq %d)." __L, seq);
 	} else if(ord == SeqPast) {
 		//they are nacking blocks going back before our buffer, wtf?
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
+		Log(Logs::Detail, Logs::Netcode, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
 	} else {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);
+		Log(Logs::Detail, Logs::Netcode, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);


 		//this is a good ack, we get to ack some blocks.
 		seq++;	//we stop at the block right after their ack, counting on the wrap of both numbers.
 		while(SequencedBase != seq) {
 			if(SequencedQueue.empty()) {
-				Log.Out(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, SequencedQueue.size());
+				Log(Logs::Detail, Logs::Netcode, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, SequencedQueue.size());
 				SequencedBase = NextOutSeq;
 				break;
 			}
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
+			Log(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu." __L, (unsigned long)SequencedBase);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
@@ -1156,7 +1156,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 			SequencedBase++;
 		}
 		if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
+			Log(Logs::Detail, Logs::Netcode, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, SequencedBase, SequencedQueue.size(), NextOutSeq);
 		}
 	}

@@ -1166,7 +1166,7 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 void EQStream::SetNextAckToSend(uint32 seq)
 {
 	MAcks.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
 	NextAckToSend=seq;
 	MAcks.unlock();
 }
@@ -1174,7 +1174,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
 void EQStream::SetLastAckSent(uint32 seq)
 {
 	MAcks.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
+	Log(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
 	LastAckSent=seq;
 	MAcks.unlock();
 }
@@ -1187,10 +1187,10 @@ void EQStream::ProcessQueue()

 	EQProtocolPacket *qp=nullptr;
 	while((qp=RemoveQueue(NextInSeq))!=nullptr) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
+		Log(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
 		ProcessPacket(qp);
 		delete qp;
-		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 }

@@ -1201,21 +1201,21 @@ EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
-		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		Log(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 	return qp;
 }

 void EQStream::SetStreamType(EQStreamType type)
 {
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
+	Log(Logs::Detail, Logs::Netcode, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
 	StreamType=type;
 	switch (StreamType) {
 		case LoginStream:
 			app_opcode_size=1;
 			compressed=false;
 			encoded=false;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
 			break;
 		case ChatOrMailStream:
 		case ChatStream:
@@ -1223,7 +1223,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=1;
 			compressed=false;
 			encoded=true;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
 			break;
 		case ZoneStream:
 		case WorldStream:
@@ -1231,7 +1231,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=2;
 			compressed=true;
 			encoded=false;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
+			Log(Logs::Detail, Logs::Netcode, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
 			break;
 	}
 }
@@ -1281,7 +1281,7 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)

 void EQStream::SetState(EQStreamState state) {
 	MState.lock();
-	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
+	Log(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
 	State=state;
 	MState.unlock();
 }
@@ -1293,29 +1293,29 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {

 	EQStreamState orig_state = GetState();
 	if (orig_state == CLOSING && !outgoing_data) {
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Out of data in closing state, disconnecting." __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Out of data in closing state, disconnecting." __L);
 		_SendDisconnect();
 		SetState(DISCONNECTING);
 	} else if (LastPacket && (now-LastPacket) > timeout) {
 		switch(orig_state) {
 		case CLOSING:
 			//if we time out in the closing state, they are not acking us, just give up
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in closing state. Moving to closed state." __L);
 			_SendDisconnect();
 			SetState(CLOSED);
 			break;
 		case DISCONNECTING:
 			//we timed out waiting for them to send us the disconnect reply, just give up.
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
 			SetState(CLOSED);
 			break;
 		case CLOSED:
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in closed state??" __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in closed state??" __L);
 			break;
 		case ESTABLISHED:
 			//we timed out during normal operation. Try to be nice about it.
 			//we will almost certainly time out again waiting for the disconnect reply, but oh well.
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in established state. Closing connection." __L);
+			Log(Logs::Detail, Logs::Netcode, _L "Timeout expired in established state. Closing connection." __L);
 			_SendDisconnect();
 			SetState(DISCONNECTING);
 			break;
@@ -1342,7 +1342,7 @@ void EQStream::Decay()
 		for (auto sitr = SequencedQueue.begin(); sitr != SequencedQueue.end(); ++sitr, count++) {
 			if (!(*sitr)->acked && (*sitr)->sent_time > 0 && ((*sitr)->sent_time + retransmittimeout) < Timer::GetCurrentTime()) {
 				(*sitr)->sent_time = 0;
-				Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
+				Log(Logs::Detail, Logs::Netcode, _L "Timeout exceeded for seq %d.  Flagging packet for retransmission" __L, SequencedBase + count);
 			}
 		}
 		MOutboundQueue.unlock();
@@ -1359,11 +1359,11 @@ void EQStream::AdjustRates(uint32 average_delta)
 			DecayRate=DECAYBASE/average_delta;
 			if (BytesWritten > RateThreshold)
 				BytesWritten = RateThreshold + DecayRate;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
 				RateThreshold, DecayRate, average_delta);
 			MRate.unlock();
 		} else {
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
 				average_delta, AVERAGE_DELTA_MAX);
 			AverageDelta = AVERAGE_DELTA_MAX;
 		}
@@ -1374,7 +1374,7 @@ void EQStream::AdjustRates(uint32 average_delta)
 			BytesWritten = 0;
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
-			Log.Out(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log(Logs::Detail, Logs::Netcode, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
 				RateThreshold, DecayRate, average_delta);
 			MRate.unlock();
 		}
@@ -1384,12 +1384,12 @@ void EQStream::AdjustRates(uint32 average_delta)
 void EQStream::Close() {
 	if(HasOutgoingData()) {
 		//there is pending data, wait for it to go out.
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
 		SetState(CLOSING);
 	} else {
 		//otherwise, we are done, we can drop immediately.
 		_SendDisconnect();
-		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream closing immediate due to Close()" __L);
+		Log(Logs::Detail, Logs::Netcode, _L "Stream closing immediate due to Close()" __L);
 		SetState(DISCONNECTING);
 	}
 }
@@ -1417,19 +1417,19 @@ EQStream::MatchState EQStream::CheckSignature(const Signature *sig) {
 		} else if(p->opcode == sig->first_eq_opcode) {
 			//opcode matches, check length..
 			if(p->size == sig->first_length) {
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length matched %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else if(sig->first_length == 0) {
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
+				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x and length (%d) is ignored", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size);
 				res = MatchSuccessful;
 			} else {
 				//opcode matched but length did not.
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
+				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode matched 0x%x, but length %d did not match expected %d", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), sig->first_eq_opcode, p->size, sig->first_length);
 				res = MatchFailed;
 			}
 		} else {
 			//first opcode did not match..
-			Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
+			Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: First opcode 0x%x did not match expected 0x%x", long2ip(GetRemoteIP()).c_str(), ntohs(GetRemotePort()), p->opcode, sig->first_eq_opcode);
 			res = MatchFailed;
 		}
 	}
@@ -241,7 +241,7 @@ class EQStream : public EQStreamInterface {
 		virtual bool CheckState(EQStreamState state) { return GetState() == state; }
 		virtual std::string Describe() const { return("Direct EQStream"); }

-		void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }
+		virtual void SetOpcodeManager(OpcodeManager **opm) { OpMgr = opm; }

 		void CheckTimeout(uint32 now, uint32 timeout=30);
 		bool HasOutgoingData();
@@ -250,13 +250,13 @@ class EQStream : public EQStreamInterface {
 		void Write(int eq_fd);

 		// whether or not the stream has been assigned (we passed our stream match)
-		void SetActive(bool val) { streamactive = val; }
+		virtual void SetActive(bool val) { streamactive = val; }

 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }

-		inline EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }
+		virtual EQStreamState GetState() { EQStreamState s; MState.lock(); s=State; MState.unlock(); return s; }

 		static SeqOrder CompareSequence(uint16 expected_seq , uint16 seq);

@@ -306,19 +306,7 @@ class EQStream : public EQStreamInterface {
 		const uint64 GetPacketsReceived() { return received_packet_count; }

 		//used for dynamic stream identification
-		class Signature {
-		public:
-			//this object could get more complicated if needed...
-			uint16 ignore_eq_opcode;		//0=dont ignore
-			uint16 first_eq_opcode;
-			uint32 first_length;			//0=dont check length
-		};
-		typedef enum {
-			MatchNotReady,
-			MatchSuccessful,
-			MatchFailed
-		} MatchState;
-		MatchState CheckSignature(const Signature *sig);
+		virtual MatchState CheckSignature(const Signature *sig);

 };

@@ -23,18 +23,10 @@

 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
-EQStreamFactory *fs=(EQStreamFactory *)eqfs;
-
-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
-#endif
+	EQStreamFactory *fs=(EQStreamFactory *)eqfs;

 	fs->ReaderLoop();

-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
-#endif
-
 	THREAD_RETURN(nullptr);
 }

@@ -42,16 +34,8 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 {
 	EQStreamFactory *fs=(EQStreamFactory *)eqfs;

-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
-#endif
-
 	fs->WriterLoop();

-#ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
-#endif
-
 	THREAD_RETURN(nullptr);
 }

@@ -4,7 +4,7 @@
 #include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
 #include "eq_stream_proxy.h"
-
+#include "misc.h"

 EQStreamIdentifier::~EQStreamIdentifier() {
 	while(!m_identified.empty()) {
@@ -26,7 +26,7 @@ EQStreamIdentifier::~EQStreamIdentifier() {
 	}
 }

-void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
+void EQStreamIdentifier::RegisterPatch(const EQStreamInterface::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs) {
 	auto p = new Patch;
 	p->signature = sig;
 	p->name = name;
@@ -46,9 +46,9 @@ void EQStreamIdentifier::Process() {

 		//first see if this stream has expired
 		if(r.expire.Check(false)) {
-			//this stream has failed to match any pattern in our timeframe.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
-			r.stream->ReleaseFromUse();
+			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", r.stream->GetRemoteAddr().c_str(), ntohs(r.stream->GetRemotePort()));
+			r.stream->Close();
+
 			cur = m_streams.erase(cur);
 			continue;
 		}
@@ -62,23 +62,23 @@ void EQStreamIdentifier::Process() {
 		}
 		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before it closed.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
 				break;
 			case CLOSING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
 				break;
 			default:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
 				break;
 			}
 			r.stream->ReleaseFromUse();
@@ -98,17 +98,17 @@ void EQStreamIdentifier::Process() {
 			Patch *p = *curp;

 			//ask the stream to see if it matches the supplied signature
-			EQStream::MatchState res = r.stream->CheckSignature(&p->signature);
+			EQStreamInterface::MatchState res = r.stream->CheckSignature(&p->signature);
 			switch(res) {
-			case EQStream::MatchNotReady:
+			case EQStreamInterface::MatchNotReady:
 				//the stream has not received enough packets to compare with this signature
 //				Log.LogDebugType(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, but stream is not ready for it.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				all_ready = false;
 				break;
-			case EQStream::MatchSuccessful: {
+			case EQStreamInterface::MatchSuccessful: {
 				//yay, a match.

-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				Log(Logs::General, Logs::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());

 				// before we assign the eqstream to an interface, let the stream recognize it is in use and the session should not be reset any further
 				r.stream->SetActive(true);
@@ -120,9 +120,9 @@ void EQStreamIdentifier::Process() {
 				found_one = true;
 				break;
 			}
-			case EQStream::MatchFailed:
+			case EQStreamInterface::MatchFailed:
 				//do nothing...
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				Log(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
 				break;
 			}
 		}
@@ -130,7 +130,7 @@ void EQStreamIdentifier::Process() {
 		//if we checked all patches and did not find a match.
 		if(all_ready && !found_one) {
 			//the stream cannot be identified.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
+			Log(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
 			r.stream->ReleaseFromUse();
 		}

@@ -144,7 +144,7 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }

-void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
+void EQStreamIdentifier::AddStream(std::shared_ptr<EQStreamInterface> eqs) {
 	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
@@ -157,7 +157,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }

-EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
+EQStreamIdentifier::Record::Record(std::shared_ptr<EQStreamInterface> s)
 :	stream(std::move(s)),
 	expire(STREAM_IDENT_WAIT_MS)
 {
@@ -1,13 +1,13 @@
 #ifndef EQSTREAMIDENT_H_
 #define EQSTREAMIDENT_H_

-#include "eq_stream.h"
+#include "eq_stream_intf.h"
 #include "timer.h"
 #include <vector>
 #include <queue>
 #include <memory>

-#define STREAM_IDENT_WAIT_MS 10000
+#define STREAM_IDENT_WAIT_MS 30000

 class OpcodeManager;
 class StructStrategy;
@@ -18,11 +18,11 @@ public:
 	~EQStreamIdentifier();

 	//registration interface.
-	void RegisterPatch(const EQStream::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs);
+	void RegisterPatch(const EQStreamInterface::Signature &sig, const char *name, OpcodeManager ** opcodes, const StructStrategy *structs);

 	//main processing interface
 	void Process();
-	void AddStream(std::shared_ptr<EQStream> &eqs);
+	void AddStream(std::shared_ptr<EQStreamInterface> eqs);
 	EQStreamInterface *PopIdentified();

 protected:
@@ -31,7 +31,7 @@ protected:
 	class Patch {
 	public:
 		std::string				name;
-		EQStream::Signature		signature;
+		EQStreamInterface::Signature		signature;
 		OpcodeManager **		opcodes;
 		const StructStrategy *structs;
 	};
@@ -40,8 +40,8 @@ protected:
 	//pending streams..
 	class Record {
 	public:
-		Record(std::shared_ptr<EQStream> s);
-		std::shared_ptr<EQStream> stream;		//we own this
+		Record(std::shared_ptr<EQStreamInterface> s);
+		std::shared_ptr<EQStreamInterface> stream;		//we own this
 		Timer expire;
 	};
 	std::vector<Record> m_streams;	//we own these objects, and the streams contained in them.
@@ -5,6 +5,7 @@

 #include <string>
 #include "emu_versions.h"
+#include "eq_packet.h"

 typedef enum {
 	ESTABLISHED,
@@ -15,21 +16,40 @@ typedef enum {
 } EQStreamState;

 class EQApplicationPacket;
+class OpcodeManager;

 class EQStreamInterface {
 public:
 	virtual ~EQStreamInterface() {}

+	class Signature {
+	public:
+		//this object could get more complicated if needed...
+		uint16 ignore_eq_opcode;		//0=dont ignore
+		uint16 first_eq_opcode;
+		uint32 first_length;			//0=dont check length
+	};
+	typedef enum {
+		MatchNotReady,
+		MatchSuccessful,
+		MatchFailed
+	} MatchState;
+
 	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;
 	virtual void Close() = 0;
 	virtual void ReleaseFromUse() = 0;
 	virtual void RemoveData() = 0;
+	virtual std::string GetRemoteAddr() const = 0;
 	virtual uint32 GetRemoteIP() const = 0;
 	virtual uint16 GetRemotePort() const = 0;
 	virtual bool CheckState(EQStreamState state) = 0;
 	virtual std::string Describe() const = 0;
+	virtual void SetActive(bool val) { }
+	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; }
@@ -1,11 +1,12 @@

 #include "global_define.h"
 #include "eq_stream_proxy.h"
-#include "eq_stream.h"
 #include "struct_strategy.h"
+#include "eqemu_logsys.h"
+#include "opcodemgr.h"


-EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -26,10 +27,25 @@ const EQEmu::versions::ClientVersion EQStreamProxy::ClientVersion() const
 	return m_structs->ClientVersion();
 }

+EQStreamState EQStreamProxy::GetState()
+{
+	return m_stream->GetState();
+}
+
+void EQStreamProxy::SetOpcodeManager(OpcodeManager **opm)
+{
+	return m_stream->SetOpcodeManager(opm);
+}
+
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
 	if(p == nullptr)
 		return;

+	if (p->GetOpcode() != OP_SpecialMesg) {
+		Log(Logs::General, Logs::Server_Client_Packet, "[%s - 0x%04x] [Size: %u]", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size());
+		Log(Logs::General, Logs::Server_Client_Packet_With_Dump, "[%s - 0x%04x] [Size: %u] %s", OpcodeManager::EmuToName(p->GetOpcode()), p->GetOpcode(), p->Size(), DumpPacketToString(p).c_str());
+	}
+
 	EQApplicationPacket *newp = p->Copy();
 	FastQueuePacket(&newp, ack_req);
 }
@@ -54,6 +70,10 @@ void EQStreamProxy::Close() {
 	m_stream->Close();
 }

+std::string EQStreamProxy::GetRemoteAddr() const {
+	return(m_stream->GetRemoteAddr());
+}
+
 uint32 EQStreamProxy::GetRemoteIP() const {
 	return(m_stream->GetRemoteIP());
 }
@@ -4,7 +4,6 @@

 #include "types.h"
 #include "eq_stream_intf.h"
-#include "eq_stream.h"
 #include <memory>

 class StructStrategy;
@@ -14,7 +13,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(std::shared_ptr<EQStreamInterface> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();

 	//EQStreamInterface:
@@ -22,6 +21,7 @@ public:
 	virtual void FastQueuePacket(EQApplicationPacket **p, bool ack_req=true);
 	virtual EQApplicationPacket *PopPacket();
 	virtual void Close();
+	virtual std::string GetRemoteAddr() const;
 	virtual uint32 GetRemoteIP() const;
 	virtual uint16 GetRemotePort() const;
 	virtual void ReleaseFromUse();
@@ -29,6 +29,8 @@ public:
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
 	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;
@@ -36,8 +38,8 @@ public:
 	virtual const uint32 GetBytesRecvPerSecond() const;

 protected:
-	std::shared_ptr<EQStream> const					m_stream;	//we own this stream object.
-	const StructStrategy *const		m_structs;	//we do not own this object.
+	std::shared_ptr<EQStreamInterface> const m_stream;	//we own this stream object.
+	const StructStrategy *const	m_structs;	//we do not own this object.
 	//this is a pointer to a pointer to make it less likely that a packet will
 	//reference an invalid opcode manager when they are being reloaded.
 	OpcodeManager **const			m_opcodes;	//we do not own this object.
@@ -66,6 +66,10 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 		if (text) {
 			LoginPort = atoi(text);
 		}
+		text = ParseTextBlock(sub_ele, "legacy", true);
+		if (text) {
+			LoginLegacy = atoi(text) > 0 ? true : false;
+		}
 		text = ParseTextBlock(sub_ele, "account", true);
 		if (text) {
 			LoginAccount = text;
@@ -89,6 +93,10 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 				if (text) {
 					loginconfig->LoginPort = atoi(text);
 				}
+				text = ParseTextBlock(sub_ele, "legacy", true);
+				if (text) {
+					loginconfig->LoginLegacy = atoi(text) > 0 ? true : false;
+				}
 				text = ParseTextBlock(sub_ele, "account", true);
 				if (text) {
 					loginconfig->LoginAccount = text;
@@ -117,11 +125,24 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 		if (text) {
 			WorldTCPPort = atoi(text);
 		}
-		text = sub_ele->Attribute("telnet");
-		if (text && !strcasecmp(text, "enabled")) {
+	}
+
+	sub_ele = ele->FirstChildElement("telnet");
+	if (sub_ele != nullptr) {
+		text = sub_ele->Attribute("ip");
+		if (text) {
+			TelnetIP = text;
+		}
+		text = sub_ele->Attribute("port");
+		if (text) {
+			TelnetTCPPort = atoi(text);
+		}
+		text = sub_ele->Attribute("enabled");
+		if (text && !strcasecmp(text, "true")) {
 			TelnetEnabled = true;
 		}
 	}
+
 	// Get the <http> element
 	sub_ele = ele->FirstChildElement("http");
 	if (sub_ele != nullptr) {
@@ -370,6 +391,9 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "LoginPort") {
 		return (itoa(LoginPort));
 	}
+	if (var_name == "LoginLegacy") {
+		return (itoa(LoginLegacy ? 1 : 0));
+	}
 	if (var_name == "Locked") {
 		return (Locked ? "true" : "false");
 	}
@@ -379,6 +403,12 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "WorldIP") {
 		return (WorldIP);
 	}
+	if (var_name == "TelnetTCPPort") {
+		return (itoa(TelnetTCPPort));
+	}
+	if (var_name == "TelnetIP") {
+		return (TelnetIP);
+	}
 	if (var_name == "TelnetEnabled") {
 		return (TelnetEnabled ? "true" : "false");
 	}
@@ -495,9 +525,12 @@ void EQEmuConfig::Dump() const
 	std::cout << "LoginAccount = " << LoginAccount << std::endl;
 	std::cout << "LoginPassword = " << LoginPassword << std::endl;
 	std::cout << "LoginPort = " << LoginPort << std::endl;
+	std::cout << "LoginLegacy = " << LoginLegacy << std::endl;
 	std::cout << "Locked = " << Locked << std::endl;
 	std::cout << "WorldTCPPort = " << WorldTCPPort << std::endl;
 	std::cout << "WorldIP = " << WorldIP << std::endl;
+	std::cout << "TelnetTCPPort = " << TelnetTCPPort << std::endl;
+	std::cout << "TelnetIP = " << TelnetIP << std::endl;
 	std::cout << "TelnetEnabled = " << TelnetEnabled << std::endl;
 	std::cout << "WorldHTTPPort = " << WorldHTTPPort << std::endl;
 	std::cout << "WorldHTTPMimeFile = " << WorldHTTPMimeFile << std::endl;
@@ -26,6 +26,7 @@ struct LoginConfig {
 	std::string LoginAccount;
 	std::string LoginPassword;
 	uint16 LoginPort;
+	bool LoginLegacy;
 };

 class EQEmuConfig : public XMLParser
@@ -42,11 +43,14 @@ class EQEmuConfig : public XMLParser
 		std::string LoginAccount;
 		std::string LoginPassword;
 		uint16 LoginPort;
+		bool LoginLegacy;
 		uint32 LoginCount;
 		LinkedList<LoginConfig*> loginlist;
 		bool Locked;
 		uint16 WorldTCPPort;
 		std::string WorldIP;
+		uint16 TelnetTCPPort;
+		std::string TelnetIP;
 		bool TelnetEnabled;
 		int32 MaxClients;
 		bool WorldHTTPEnabled;
@@ -127,11 +131,13 @@ class EQEmuConfig : public XMLParser
 #include "eqemu_config_elements.h"
 			// Set sane defaults
 			// Login server
-			LoginHost = "eqemulator.net";
+			LoginHost = "login.eqemulator.net";
 			LoginPort = 5998;
+			LoginLegacy = false;
 			// World
 			Locked = false;
 			WorldTCPPort = 9000;
+			TelnetTCPPort = 9001;
 			TelnetEnabled = false;
 			WorldHTTPEnabled = false;
 			WorldHTTPPort = 9080;
@@ -186,6 +192,7 @@ class EQEmuConfig : public XMLParser
 			DefaultStatus = 0;
 			// For where zones need to connect to.
 			WorldIP = "127.0.0.1";
+			TelnetIP = "127.0.0.1";
 			// Dynamics to start
 			//DynamicCount=5;
 			MaxClients = -1;
@@ -103,6 +103,16 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 	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;
+
+	/* 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;

 	/*	Declare process file names for log writing
 		If there is no process_file_name declared, no log file will be written, simply
@@ -119,30 +129,27 @@ void EQEmuLogSys::LoadLogSettingsDefaults()
 		platform_file_name = "login";
 	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformLaunch)
 		platform_file_name = "launcher";
+	else if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformHC)
+		platform_file_name = "hc";
 }

 std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
 {
-	std::string category_string;
-	if (log_category > 0 && Logs::LogCategoryName[log_category])
-		category_string = StringFormat("[%s] ", Logs::LogCategoryName[log_category]);
-	return StringFormat("%s%s", category_string.c_str(), in_message.c_str());
+	std::string ret;
+	ret.push_back('[');
+	ret.append(Logs::LogCategoryName[log_category]);
+	ret.push_back(']');
+	ret.push_back(' ');
+	ret.append(in_message);
+	return ret;
 }

 void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_gmsay == 0)
-		return;
-
 	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
 	if (log_category == Logs::LogCategory::Netcode)
 		return;

-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_gmsay < debug_level)
-		return;
-
 	/* 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);
@@ -160,14 +167,6 @@ void EQEmuLogSys::ProcessLogWrite(uint16 debug_level, uint16 log_category, const
 		crash_log.close();
 	}

-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_file == 0)
-		return;
-
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_file < debug_level)
-		return;
-
 	char time_stamp[80];
 	EQEmuLogSys::SetCurrentTimeStamp(time_stamp);

@@ -246,13 +245,6 @@ uint16 EQEmuLogSys::GetGMSayColorFromCategory(uint16 log_category) {

 void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message)
 {
-	/* Check if category enabled for process */
-	if (log_settings[log_category].log_to_console == 0)
-		return;
-
-	/* Make sure the message inbound is at a debug level we're set at */
-	if (log_settings[log_category].log_to_console < debug_level)
-		return;

 	#ifdef _WINDOWS
 		HANDLE  console_handle;
@@ -273,12 +265,25 @@ void EQEmuLogSys::ProcessConsoleMessage(uint16 debug_level, uint16 log_category,

 void EQEmuLogSys::Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...)
 {
-	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;
-	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;

-	if (nothing_to_log) return;
+	bool log_to_console = true;
+	if (log_settings[log_category].log_to_console < debug_level) {
+		log_to_console = false;
+	}
+
+	bool log_to_file = true;
+	if (log_settings[log_category].log_to_file < debug_level) {
+		log_to_file = false;
+	}
+
+	bool log_to_gmsay = true;
+	if (log_settings[log_category].log_to_gmsay < debug_level) {
+		log_to_gmsay = false;
+	}
+
+	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
+	if (nothing_to_log)
+		return;

 	va_list args;
 	va_start(args, message);
@@ -1,3 +1,4 @@
+
 /*	EQEMu: Everquest Server Emulator
 	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)

@@ -19,11 +20,11 @@
 #ifndef EQEMU_LOGSYS_H
 #define EQEMU_LOGSYS_H

+#include <fmt/format.h>
 #include <iostream>
 #include <fstream>
 #include <stdio.h>
 #include <functional>
-
 #include "types.h"

 namespace Logs {
@@ -38,105 +39,123 @@ namespace Logs {
 		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,
-		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,
+	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"
-	};
+/* 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"
+};
 }

+#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__);\
+} 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__);\
+} while (0)
+
 class EQEmuLogSys {
 public:
 	EQEmuLogSys();
@@ -158,6 +177,13 @@ public:
 	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);
+	}
+
 	/*
 		LogSettings Struct

@@ -198,11 +224,11 @@ private:

 	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */

-	void ProcessConsoleMessage(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessConsoleMessage called via Log.Out */
-	void ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessGMSay called via Log.Out */
-	void ProcessLogWrite(uint16 debug_level, uint16 log_category, const std::string &message); /* ProcessLogWrite called via Log.Out */
+	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 */
 };

-extern EQEmuLogSys Log;
+extern EQEmuLogSys LogSys;

 #endif
@@ -0,0 +1,42 @@
+#pragma once
+#include <functional>
+#include "../any.h"
+#include "event_loop.h"
+
+namespace EQ {
+	class BackgroundTask
+	{
+	public:
+		typedef std::function<void(EQEmu::Any&)> BackgroundTaskFunction;
+		struct BackgroundTaskBaton
+		{
+			BackgroundTaskFunction fn;
+			BackgroundTaskFunction on_finish;
+			EQEmu::Any data;
+		};
+
+		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish, EQEmu::Any data) {
+			uv_work_t *m_work = new uv_work_t;
+			memset(m_work, 0, sizeof(uv_work_t));
+			BackgroundTaskBaton *baton = new BackgroundTaskBaton();
+			baton->fn = fn;
+			baton->on_finish = on_finish;
+			baton->data = data;
+		
+			m_work->data = baton;
+			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
+				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
+				baton->fn(baton->data);
+			}, [](uv_work_t* req, int status) {
+				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
+				baton->on_finish(baton->data);
+				delete baton;
+				delete req;
+			});
+		}
+
+		~BackgroundTask() {
+
+		}
+	};
+}
@@ -0,0 +1,37 @@
+#pragma once
+#include <functional>
+#include <uv.h>
+#include <cstring>
+
+namespace EQ
+{
+	class EventLoop
+	{
+	public:
+		static EventLoop &Get() {
+			static EventLoop inst;
+			return inst;
+		}
+
+		~EventLoop() {
+			uv_loop_close(&m_loop);
+		}
+
+		void Process() {
+			uv_run(&m_loop, UV_RUN_NOWAIT);
+		}
+
+		uv_loop_t* Handle() { return &m_loop; }
+
+	private:
+		EventLoop() {
+			memset(&m_loop, 0, sizeof(uv_loop_t));
+			uv_loop_init(&m_loop);
+		}
+		
+		EventLoop(const EventLoop&);
+		EventLoop& operator=(const EventLoop&);
+	
+		uv_loop_t m_loop;
+	};
+}
@@ -0,0 +1,67 @@
+#pragma once
+#include <functional>
+#include "event_loop.h"
+
+namespace EQ {
+	class Timer
+	{
+	public:
+		Timer(std::function<void(Timer *)> cb)
+		{
+			m_timer = nullptr;
+			m_cb = cb;
+		}
+
+		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
+		{
+			m_timer = nullptr;
+			m_cb = cb;
+			Start(duration_ms, repeats);
+		}
+	
+		~Timer()
+		{
+			Stop();
+		}
+
+		void Start(uint64_t duration_ms, bool repeats) {
+			auto loop = EventLoop::Get().Handle();
+			if (!m_timer) {
+				m_timer = new uv_timer_t;
+				memset(m_timer, 0, sizeof(uv_timer_t));
+				uv_timer_init(loop, m_timer);
+				m_timer->data = this;
+
+				if (repeats) {
+					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Execute();
+					}, duration_ms, duration_ms);
+				}
+				else {
+					uv_timer_start(m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Stop();
+						t->Execute();
+					}, duration_ms, 0);
+				}
+			}
+		}
+
+		void Stop() {
+			if (m_timer) {
+				uv_close((uv_handle_t*)m_timer, [](uv_handle_t* handle) {
+					delete handle;
+				});
+				m_timer = nullptr;
+			}
+		}
+	private:
+		void Execute() {
+			m_cb(this);
+		}
+	
+		uv_timer_t *m_timer;
+		std::function<void(Timer*)> m_cb;
+	};
+}
@@ -0,0 +1,22 @@
+#include "event_sub.h"
+#include <string.h>
+
+void EventSubscriptionWatcher::Subscribe(const std::string &event_name)
+{
+	m_subs[event_name] = 1;
+}
+
+void EventSubscriptionWatcher::Unsubscribe(const std::string &event_name)
+{
+	m_subs[event_name] = 0;
+}
+
+bool EventSubscriptionWatcher::IsSubscribed(const std::string &event_name) const
+{
+	auto iter = m_subs.find(event_name);
+	if (iter != m_subs.end()) {
+		return iter->second;
+	}
+
+	return false;
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <unordered_map>
+
+class EventSubscriptionWatcher
+{
+public:
+	~EventSubscriptionWatcher();
+	
+	void Subscribe(const std::string &event_name);
+	void Unsubscribe(const std::string &event_name);
+	bool IsSubscribed(const std::string &event_name) const;
+
+	static EventSubscriptionWatcher *Get() {
+		static EventSubscriptionWatcher* inst = nullptr;
+		if(!inst) {
+			inst = new EventSubscriptionWatcher();
+		}
+		
+		return inst;
+	}
+private:
+	EventSubscriptionWatcher() { }
+	EventSubscriptionWatcher(const EventSubscriptionWatcher&);
+	EventSubscriptionWatcher& operator=(const EventSubscriptionWatcher&);
+	
+	std::unordered_map<std::string, bool> m_subs;
+};
@@ -111,9 +111,6 @@ Zone extensions and features
 //path to where sql logs should be placed
 #define SQL_LOG_PATH "sql_logs/"

-//New aggro system to reduce overhead.
-#define REVERSE_AGGRO
-
 //The highest you can #setskill / #setallskill
 #define HIGHEST_CAN_SET_SKILL 400

@@ -157,13 +154,12 @@ enum {	//timer settings, all in milliseconds
 	AIscanarea_delay = 6000,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
-	AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
+	// 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
 	ClientProximity_interval = 150,
 	CombatEventTimer_expire = 12000,
 	Tribute_duration = 600000,
-	ZoneTimerResolution = 3,			//sleep time between zone main loop runs (milliseconds)
 	FeignMemoryDuration = 120000, // Duration player must feign death to clear zonewide agro.
 	EnragedTimer = 360000,
 	EnragedDurationTimer = 10000
@@ -235,6 +231,9 @@ enum {	//some random constants

 #define ZONE_CONTROLLER_NPC_ID 10

+// Timer to update aggrometer
+#define AGGRO_METER_UPDATE_MS 1000
+
 //Some hard coded statuses from commands and other places:
 enum {
 	minStatusToBeGM = 40,
@@ -1,6 +1,39 @@
-The MIT License
+================================================================================
+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.

-Copyright (c) 2005 - 2013 G-Truc Creation
+================================================================================
+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
@@ -1,9 +1,9 @@
-set(NAME glm_dummy)
-
 file(GLOB ROOT_SOURCE *.cpp)
 file(GLOB ROOT_INLINE *.inl)
 file(GLOB ROOT_HEADER *.hpp)
 file(GLOB ROOT_TEXT ../*.txt)
+file(GLOB ROOT_MD ../*.md)
+file(GLOB ROOT_NAT ../util/glm.natvis)

 file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
 file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
@@ -17,7 +17,11 @@ file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
 file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
 file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)

-source_group("Text Files" FILES ${ROOT_TEXT})
+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})
@@ -27,16 +31,37 @@ 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_TEST_ENABLE)
-	add_executable(${NAME} ${ROOT_TEXT}
+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})
-endif(GLM_TEST_ENABLE)
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
+		${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})

-#add_library(glm STATIC glm.cpp)
-#add_library(glm_shared SHARED glm.cpp)
+endif(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/common.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/_features.hpp
-/// @date 2013-02-20 / 2013-02-20
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -284,7 +255,7 @@
 #		define GLM_CXX11_STATIC_ASSERT
 #	endif

-#elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
 #	if(__has_feature(cxx_exceptions))
 #		define GLM_CXX98_EXCEPTIONS
 #	endif
@@ -425,4 +396,4 @@
 #		define GLM_CXX11_VARIADIC_TEMPLATES
 #	endif

-#endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/_fixes.hpp
-/// @date 2011-02-21 / 2011-11-22
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include <cmath>

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/_noise.hpp
-/// @date 2013-12-24 / 2013-12-24
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/_swizzle_func.hpp
-/// @date 2011-10-16 / 2011-10-16
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/_vectorize.hpp
-/// @date 2011-10-14 / 2011-10-14
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,40 +1,13 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/core/dummy.cpp
-/// @date 2011-01-19 / 2011-06-15
-/// @author Christophe Riccio
 ///
 /// GLM is a header only library. There is nothing to compile. 
 /// dummy.cpp exist only a wordaround for CMake file.
-///////////////////////////////////////////////////////////////////////////////////

+/*
 #define GLM_MESSAGES
-#include "../glm.hpp"
+#include <glm/glm.hpp>
+#include <glm/ext.hpp>
 #include <limits>

 struct material
@@ -148,6 +121,8 @@ struct intersection
 	glm::vec4 position;
 	glm::vec3 normal;
 };
+*/
+

 /*
 // Sample 4
@@ -190,7 +165,7 @@ glm::vec3 lighting
 }
 */

-
+/*
 template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
 T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
 {
@@ -210,13 +185,23 @@ 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::vec4 v(1);
-	float a = normalizeDotA(v, v);
-	float b = normalizeDotB(v, v);
-	float c = normalizeDotC(v, v);
+/*
+	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;
 }
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_common.hpp
-/// @date 2008-03-08 / 2010-01-26
-/// @author Christophe Riccio
 /// 
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 ///
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_common.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "func_vector_relational.hpp"
 #include "type_vec2.hpp"
@@ -37,142 +8,24 @@
 #include "_vectorize.hpp"
 #include <limits>

-namespace glm{
-namespace detail
+namespace glm
 {
-	template <typename genFIType, bool /*signed*/>
-	struct compute_abs
-	{};
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, true>
+	// min
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
 	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				std::numeric_limits<genFIType>::is_iec559 || std::numeric_limits<genFIType>::is_signed,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
+		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;
+	}

-			return x >= genFIType(0) ? x : -x;
-			// TODO, perf comp with: *(((int *) &x) + 1) &= 0x7fffffff;
-		}
-	};
-
-	template <typename genFIType>
-	struct compute_abs<genFIType, false>
+	// max
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
 	{
-		GLM_FUNC_QUALIFIER static genFIType call(genFIType x)
-		{
-			GLM_STATIC_ASSERT(
-				!std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer,
-				"'abs' only accept floating-point and integer scalar or vector inputs");
-			return x;
-		}
-	};
+		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");

-	template <typename T, typename U, precision P, template <class, precision> class vecType>
-	struct compute_mix_vector
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType>
-	struct compute_mix_vector<T, bool, P, vecType>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, vecType<bool, P> const & a)
-		{
-			vecType<T, P> Result(uninitialize);
-			for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
-				Result[i] = a[i] ? y[i] : x[i];
-			return Result;
-		}
-	};
-
-	template <typename T, typename U, precision P, template <class, precision> class vecType>
-	struct compute_mix_scalar
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return vecType<T, P>(vecType<U, P>(x) + a * vecType<U, P>(y - x));
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType>
-	struct compute_mix_scalar<T, bool, P, vecType>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, vecType<T, P> const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, typename U>
-	struct compute_mix
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, U const & a)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<U>::is_iec559, "'mix' only accept floating-point inputs for the interpolator a");
-
-			return static_cast<T>(static_cast<U>(x) + a * static_cast<U>(y - x));
-		}
-	};
-
-	template <typename T>
-	struct compute_mix<T, bool>
-	{
-		GLM_FUNC_QUALIFIER static T call(T const & x, T const & y, bool const & a)
-		{
-			return a ? y : x;
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true, bool isSigned = true>
-	struct compute_sign
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return vecType<T, P>(glm::lessThan(vecType<T, P>(0), x)) - vecType<T, P>(glm::lessThan(x, vecType<T, P>(0)));
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType>
-	struct compute_sign<T, P, vecType, false, false>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			return vecType<T, P>(glm::greaterThan(x , vecType<T, P>(0)));
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType>
-	struct compute_sign<T, P, vecType, false, true>
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x)
-		{
-			T const Shift(static_cast<T>(sizeof(T) * 8 - 1));
-			vecType<T, P> const y(vecType<typename make_unsigned<T>::type, P>(-x) >> typename make_unsigned<T>::type(Shift));
-
-			return (x >> Shift) | y;
-		}
-	};
-
-	template <typename T, precision P, template <class, precision> class vecType, typename genType, bool isFloat = true>
-	struct compute_mod
-	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & a, genType const & b)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'mod' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
-			return a - b * floor(a / b);
-		}
-	};
-}//namespace detail
+		return x > y ? x : y;
+	}

 	// abs
 	template <>
@@ -182,67 +35,6 @@ namespace detail
 		return (x ^ y) - y;
 	}

-	template <typename genFIType>
-	GLM_FUNC_QUALIFIER genFIType abs(genFIType x)
-	{
-		return detail::compute_abs<genFIType, std::numeric_limits<genFIType>::is_signed>::call(x);
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> abs(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(abs, x);
-	}
-
-	// sign
-	// fast and works for any type
-	template <typename genFIType> 
-	GLM_FUNC_QUALIFIER genFIType sign(genFIType x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<genFIType>::is_iec559 || (std::numeric_limits<genFIType>::is_signed && std::numeric_limits<genFIType>::is_integer),
-			"'sign' only accept signed inputs");
-		
-		return detail::compute_sign<genFIType, defaultp, tvec1, std::numeric_limits<genFIType>::is_iec559>::call(tvec1<genFIType>(x)).x;
-	}
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> sign(vecType<T, P> const & x)
-	{
-		GLM_STATIC_ASSERT(
-			std::numeric_limits<T>::is_iec559 || (std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_integer),
-			"'sign' only accept signed inputs");
-
-		return detail::compute_sign<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
-	}
-
-	// floor
-	using ::std::floor;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> floor(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(floor, x);
-	}
-
-	// trunc
-#	if GLM_HAS_CXX11_STL
-		using ::std::trunc;
-#	else
-		template <typename genType>
-		GLM_FUNC_QUALIFIER genType trunc(genType x)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'trunc' only accept floating-point inputs");
-
-			return x < static_cast<genType>(0) ? -floor(-x) : floor(x);
-		}
-#	endif
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> trunc(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(trunc, x);
-	}
-
 	// round
 #	if GLM_HAS_CXX11_STL
 		using ::std::round;
@@ -256,10 +48,318 @@ namespace detail
 		}
 #	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)
 	{
-		return detail::functor1<T, T, P, vecType>::call(round, 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);
 	}

 /*
@@ -308,6 +408,7 @@ namespace detail
 	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);
 	}

@@ -316,41 +417,47 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> ceil(vecType<T, P> const & x)
 	{
-		return detail::functor1<T, T, P, vecType>::call(ceil, x);
+		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)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fract' only accept floating-point inputs");
-
 		return fract(tvec1<genType>(x)).x;
 	}

 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> fract(vecType<T, P> const & x)
 	{
-		return x - floor(x);
+		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)
 	{
-		return mod(tvec1<genType>(x), y).x;
+#		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, T, std::numeric_limits<T>::is_iec559>::call(x, 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, vecType<T, P>, std::numeric_limits<T>::is_iec559>::call(x, y);
+		return detail::compute_mod<T, P, vecType, detail::is_aligned<P>::value>::call(x, y);
 	}

 	// modf
@@ -358,7 +465,6 @@ namespace detail
 	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);
 	}

@@ -405,70 +511,53 @@ namespace detail
 	//CHAR_BIT - 1)));

 	// min
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType min(genType x, genType y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'min' only accept floating-point or integer inputs");
-
-		return x < y ? x : y;
-	}
-
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> min(vecType<T, P> const & a, T b)
 	{
-		return detail::functor2_vec_sca<T, P, vecType>::call(min, a, b);
+		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::functor2<T, P, vecType>::call(min, a, b);
+		return detail::compute_min_vector<T, P, vecType, detail::is_aligned<P>::value>::call(a, b);
 	}

 	// max
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType max(genType x, genType y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer, "'max' only accept floating-point or integer inputs");
-
-		return x > y ? x : y;
-	}
-
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> max(vecType<T, P> const & a, T b)
 	{
-		return detail::functor2_vec_sca<T, P, vecType>::call(max, a, b);
+		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::functor2<T, P, vecType>::call(max, a, 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, "'clamp' only accept floating-point or integer inputs");
-		
+		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, "'clamp' only accept floating-point or integer inputs");
-
-		return min(max(x, minVal), 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, "'clamp' only accept floating-point or integer inputs");
-
-		return min(max(x, minVal), 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>
@@ -480,13 +569,13 @@ namespace detail
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a)
 	{
-		return detail::compute_mix_scalar<T, U, P, vecType>::call(x, y, a);
+		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>::call(x, y, a);
+		return detail::compute_mix_vector<T, U, P, vecType, detail::is_aligned<P>::value>::call(x, y, a);
 	}

 	// step
@@ -499,22 +588,20 @@ namespace detail
 	template <template <typename, precision> class vecType, typename T, precision P>
 	GLM_FUNC_QUALIFIER vecType<T, P> step(T edge, vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'step' only accept floating-point inputs");
-
-		return mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, vecType<T, P>(edge)));
+		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 mix(vecType<T, P>(1), vecType<T, P>(0), glm::lessThan(x, edge));
+		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, "'smoothstep' only accept floating-point inputs");
+		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);
@@ -523,19 +610,13 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
-
-		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
-		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+		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)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'smoothstep' only accept floating-point inputs");
-
-		vecType<T, P> const tmp(clamp((x - edge0) / (edge1 - edge0), static_cast<T>(0), static_cast<T>(1)));
-		return tmp * tmp * (static_cast<T>(3) - static_cast<T>(2) * tmp);
+		return detail::compute_smoothstep_vector<T, P, vecType, detail::is_aligned<P>::value>::call(edge0, edge1, x);
 	}

 #	if GLM_HAS_CXX11_STL
@@ -548,14 +629,16 @@ namespace detail

 #			if GLM_HAS_CXX11_STL
 				return std::isnan(x);
-#			elif GLM_COMPILER & (GLM_COMPILER_VC | GLM_COMPILER_INTEL)
+#			elif GLM_COMPILER & GLM_COMPILER_VC
 				return _isnan(x) != 0;
-#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
-#				if GLM_PLATFORM & GLM_PLATFORM_ANDROID && __cplusplus < 201103L
+#			elif GLM_COMPILER & GLM_COMPILER_INTEL
+#				if GLM_PLATFORM & GLM_PLATFORM_WINDOWS
 					return _isnan(x) != 0;
 #				else
-					return std::isnan(x);
+					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
@@ -583,8 +666,12 @@ namespace detail
 #			if GLM_HAS_CXX11_STL
 				return std::isinf(x);
 #			elif GLM_COMPILER & (GLM_COMPILER_INTEL | GLM_COMPILER_VC)
-				return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
-#			elif GLM_COMPILER & (GLM_COMPILER_GCC | (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
+#				if(GLM_PLATFORM & GLM_PLATFORM_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
@@ -660,23 +747,23 @@ namespace detail
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType frexp(genType x, int & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'frexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'frexp' only accept floating-point inputs");

-		return std::frexp(x, exp);
+		return std::frexp(x, &exp);
 	}

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> frexp(tvec1<T, P> const & x, tvec1<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+		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));
+		return tvec1<T, P>(std::frexp(x.x, &exp.x));
 	}

 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> frexp(tvec2<T, P> const & x, tvec2<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+		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),
@@ -686,7 +773,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> frexp(tvec3<T, P> const & x, tvec3<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+		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),
@@ -697,7 +784,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> frexp(tvec4<T, P> const & x, tvec4<int, P> & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'frexp' only accept floating-point inputs");
+		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),
@@ -706,10 +793,10 @@ namespace detail
 			frexp(x.w, exp.w));
 	}

-	template <typename genType, precision P>
+	template <typename genType>
 	GLM_FUNC_QUALIFIER genType ldexp(genType const & x, int const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'ldexp' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || GLM_UNRESTRICTED_GENTYPE, "'ldexp' only accept floating-point inputs");

 		return std::ldexp(x, exp);
 	}
@@ -717,7 +804,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec1<T, P> ldexp(tvec1<T, P> const & x, tvec1<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+		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));
@@ -726,7 +813,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec2<T, P> ldexp(tvec2<T, P> const & x, tvec2<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+		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),
@@ -736,7 +823,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P> ldexp(tvec3<T, P> const & x, tvec3<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+		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),
@@ -747,7 +834,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec4<T, P> ldexp(tvec4<T, P> const & x, tvec4<int, P> const & exp)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'ldexp' only accept floating-point inputs");
+		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),
@@ -756,3 +843,7 @@ namespace detail
 			ldexp(x.w, exp.w));
 	}
 }//namespace glm
+
+#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
+#	include "func_common_simd.inl"
+#endif
@@ -0,0 +1,231 @@
+/// @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
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_exponential.hpp
-/// @date 2008-08-08 / 2011-06-14
-/// @author Christophe Riccio
 /// 
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.2 Exponential Functions</a>
 ///
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_exponential.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"
@@ -49,7 +20,7 @@ namespace detail
 		}
 #	endif

-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
+	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)
@@ -58,7 +29,16 @@ namespace detail
 		}
 	};

-	template <template <class, precision> class vecType, typename T, precision P>
+	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)
@@ -67,8 +47,8 @@ namespace detail
 		}
 	};
 		
-	template <template <class, precision> class vecType>
-	struct compute_inversesqrt<vecType, float, lowp>
+	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)
 		{
@@ -133,7 +113,7 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
 	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559, detail::is_aligned<P>::value>::call(x);
 	}

 	// sqrt
@@ -142,7 +122,7 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
+		return detail::compute_sqrt<vecType, T, P, detail::is_aligned<P>::value>::call(x);
 	}

 	// inversesqrt
@@ -156,6 +136,11 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<vecType, T, P>::call(x);
+		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
+
@@ -0,0 +1,35 @@
+/// @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
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_geometric.hpp
-/// @date 2008-08-03 / 2011-06-14
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 /// 
@@ -35,7 +7,6 @@
 /// @ingroup core
 /// 
 /// These operate on vectors as vectors, not component-wise.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -104,11 +75,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType faceforward(
-		genType const & N,
-		genType const & I,
-		genType const & Nref);
+	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.
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_geometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "func_exponential.hpp"
 #include "func_common.hpp"
@@ -39,11 +10,29 @@
 namespace glm{
 namespace detail
 {
-	template <template <class, precision> class vecType, typename T, precision P>
+	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>
-	struct compute_dot<tvec1, T, P>
+	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)
 		{
@@ -51,8 +40,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_dot<tvec2, T, P>
+	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)
 		{
@@ -61,8 +50,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_dot<tvec3, T, P>
+	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)
 		{
@@ -71,8 +60,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_dot<tvec4, T, P>
+	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)
 		{
@@ -80,13 +69,69 @@ namespace detail
 			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' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");

 		return abs(x);
 	}
@@ -94,16 +139,16 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");

-		return sqrt(dot(v, v));
+		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' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");

 		return length(p1 - p0);
 	}
@@ -111,41 +156,36 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
 	{
-		return length(p1 - p0);
+		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' only accept floating-point inputs");
+		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' only accept floating-point inputs");
-		return detail::compute_dot<vecType, T, P>::call(x, 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)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
-
-		return tvec3<T, P>(
-			x.y * y.z - y.y * x.z,
-			x.z * y.x - y.z * x.x,
-			x.x * y.y - y.x * x.y);
+		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' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");

 		return x < genType(0) ? genType(-1) : genType(1);
 	}
@@ -153,9 +193,9 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");

-		return x * inversesqrt(dot(x, x));
+		return detail::compute_normalize<T, P, vecType, detail::is_aligned<P>::value>::call(x);
 	}

 	// faceforward
@@ -165,19 +205,30 @@ namespace detail
 		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) * static_cast<genType>(2);
+		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 const & eta)
+	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType eta)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
-
+		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));
@@ -186,10 +237,11 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
-
-		T const dotValue(dot(N, I));
-		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
+		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
@@ -0,0 +1,99 @@
+/// @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
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_integer.hpp
-/// @date 2010-03-17 / 2011-06-18
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 /// 
@@ -37,7 +9,6 @@
 /// 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

@@ -1,48 +1,26 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_integer.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
 #include "type_vec4.hpp"
 #include "type_int.hpp"
 #include "_vectorize.hpp"
-#if(GLM_ARCH != GLM_ARCH_PURE)
-#if(GLM_COMPILER & GLM_COMPILER_VC)
+#if(GLM_ARCH & GLM_ARCH_X86 && GLM_COMPILER & GLM_COMPILER_VC)
 #	include <intrin.h>
 #	pragma intrinsic(_BitScanReverse)
-#endif//(GLM_COMPILER & GLM_COMPILER_VC)
-#endif//(GLM_ARCH != GLM_ARCH_PURE)
+#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
 {
@@ -52,40 +30,36 @@ namespace detail
 		return Bits >= sizeof(T) * 8 ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
 	}

-	template <bool EXEC = false>
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned, bool EXEC>
 	struct compute_bitfieldReverseStep
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
 		{
 			return v;
 		}
 	};

-	template <>
-	struct compute_bitfieldReverseStep<true>
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned>
+	struct compute_bitfieldReverseStep<T, P, vecType, Aligned, true>
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
 		{
 			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
 		}
 	};

-	template <bool EXEC = false>
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned, bool EXEC>
 	struct compute_bitfieldBitCountStep
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
 		{
 			return v;
 		}
 	};

-	template <>
-	struct compute_bitfieldBitCountStep<true>
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, bool Aligned>
+	struct compute_bitfieldBitCountStep<T, P, vecType, Aligned, true>
 	{
-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
 		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
 		{
 			return (v & Mask) + ((v >> Shift) & Mask);
@@ -173,7 +147,7 @@ namespace detail
 			return IsNotNull ? int(Result) : -1;
 		}

-		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		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)
@@ -208,7 +182,7 @@ namespace detail
 	{
 		uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
 		uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-		Carry = Value64 > Max32 ? 1 : 0;
+		Carry = Value64 > Max32 ? 1u : 0u;
 		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}

@@ -248,10 +222,8 @@ namespace detail
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");

 		uint64 Value64 = static_cast<uint64>(x) * static_cast<uint64>(y);
-		uint32* PointerMSB = (reinterpret_cast<uint32*>(&Value64) + 1);
-		msb = *PointerMSB;
-		uint32* PointerLSB = (reinterpret_cast<uint32*>(&Value64) + 0);
-		lsb = *PointerLSB;
+		msb = static_cast<uint>(Value64 >> static_cast<uint64>(32));
+		lsb = static_cast<uint>(Value64);
 	}

 	template <precision P, template <typename, precision> class vecType>
@@ -270,10 +242,8 @@ namespace detail
 		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");

 		int64 Value64 = static_cast<int64>(x) * static_cast<int64>(y);
-		int32* PointerMSB = (reinterpret_cast<int32*>(&Value64) + 1);
-		msb = *PointerMSB;
-		int32* PointerLSB = (reinterpret_cast<int32*>(&Value64));
-		lsb = *PointerLSB;
+		msb = static_cast<int>(Value64 >> static_cast<int64>(32));
+		lsb = static_cast<int>(Value64);
 	}

 	template <precision P, template <typename, precision> class vecType>
@@ -328,12 +298,12 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
 	{
 		vecType<T, P> x(v);
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
+		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;
 	}

@@ -348,12 +318,12 @@ namespace detail
 	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
 	{
 		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
+		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);
 	}

@@ -391,3 +361,8 @@ namespace detail
 		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
+
@@ -0,0 +1,68 @@
+/// @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
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_matrix.hpp
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
 /// 
@@ -39,7 +11,6 @@
 /// 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

@@ -72,19 +43,19 @@ namespace detail
 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec2, tvec3>
 	{
-		typedef tmat2x3<T, P> type;
+		typedef tmat3x2<T, P> type;
 	};

 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec2, tvec4>
 	{
-		typedef tmat2x4<T, P> type;
+		typedef tmat4x2<T, P> type;
 	};

 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec3, tvec2>
 	{
-		typedef tmat3x2<T, P> type;
+		typedef tmat2x3<T, P> type;
 	};

 	template <typename T, precision P>
@@ -96,19 +67,19 @@ namespace detail
 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec3, tvec4>
 	{
-		typedef tmat3x4<T, P> type;
+		typedef tmat4x3<T, P> type;
 	};

 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec4, tvec2>
 	{
-		typedef tmat4x2<T, P> type;
+		typedef tmat2x4<T, P> type;
 	};

 	template <typename T, precision P>
 	struct outerProduct_trait<T, P, tvec4, tvec3>
 	{
-		typedef tmat4x3<T, P> type;
+		typedef tmat3x4<T, P> type;
 	};

 	template <typename T, precision P>
@@ -149,7 +120,7 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
+#	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
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_matrix.inl
-/// @date 2008-03-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "../geometric.hpp"
 #include <limits>
@@ -36,11 +7,23 @@
 namespace glm{
 namespace detail
 {
-	template <template <class, precision> class matType, typename T, precision P>
+	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>
-	struct compute_transpose<tmat2x2, T, P>
+	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)
 		{
@@ -53,8 +36,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat2x3, T, P>
+	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)
 		{
@@ -69,8 +52,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat2x4, T, P>
+	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)
 		{
@@ -87,8 +70,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat3x2, T, P>
+	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)
 		{
@@ -103,8 +86,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat3x3, T, P>
+	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)
 		{
@@ -124,8 +107,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat3x4, T, P>
+	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)
 		{
@@ -146,8 +129,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat4x2, T, P>
+	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)
 		{
@@ -164,8 +147,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat4x3, T, P>
+	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)
 		{
@@ -186,8 +169,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_transpose<tmat4x4, T, P>
+	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)
 		{
@@ -215,11 +198,11 @@ namespace detail
 		}
 	};

-	template <template <class, precision> class matType, typename T, precision P>
+	template <template <typename, precision> class matType, typename T, precision P, bool Aligned>
 	struct compute_determinant{};

-	template <typename T, precision P>
-	struct compute_determinant<tmat2x2, T, P>
+	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)
 		{
@@ -227,8 +210,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_determinant<tmat3x3, T, P>
+	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)
 		{
@@ -239,8 +222,8 @@ namespace detail
 		}
 	};

-	template <typename T, precision P>
-	struct compute_determinant<tmat4x4, T, P>
+	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)
 		{
@@ -262,26 +245,130 @@ namespace detail
 				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, "'matrixCompMult' only accept floating-point inputs");
-
-		matType<T, P> result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(result); ++i)
-			result[i] = x[i] * y[i];
-		return result;
+		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, "'outerProduct' only accept floating-point inputs");
+		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(detail::component_count_t i = 0; i < detail::component_count(m); ++i)
+		for(length_t i = 0; i < m.length(); ++i)
 			m[i] = c * r[i];
 		return m;
 	}
@@ -289,22 +376,26 @@ namespace detail
 	template <typename T, precision P, template <typename, precision> class matType>
 	GLM_FUNC_QUALIFIER typename matType<T, P>::transpose_type transpose(matType<T, P> const & m)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'transpose' only accept floating-point inputs");
-		return detail::compute_transpose<matType, T, P>::call(m);
+		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, "'determinant' only accept floating-point inputs");
-		return detail::compute_determinant<matType, T, P>::call(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, "'inverse' only accept floating-point inputs");
-		return detail::compute_inverse(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
+
@@ -0,0 +1,88 @@
+/// @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
@@ -1,93 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/func_noise.hpp
-/// @date 2008-08-01 / 2011-06-18
-/// @author Christophe Riccio
-///
-/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-/// 
-/// @defgroup core_func_noise Noise functions
-/// @ingroup core
-/// 
-/// Noise functions are stochastic functions that can be used to increase visual 
-/// complexity. Values returned by the following noise functions give the 
-/// appearance of randomness, but are not truly random.
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "setup.hpp"
-
-namespace glm
-{
-	/// @addtogroup core_func_noise
-	/// @{
-
-	/// Returns a 1D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL typename genType::value_type noise1(genType const & x);
-
-	/// Returns a 2D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
-
-	/// Returns a 3D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
-
-	/// Returns a 4D noise value based on the input value x.
-	///
-	/// @tparam genType Floating-point scalar or vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.13 Noise Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
-
-	/// @}
-}//namespace glm
-
-#include "func_noise.inl"
@@ -1,388 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/func_noise.inl
-/// @date 2008-08-01 / 2011-09-27
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#include "../detail/_noise.hpp"
-#include "./func_common.hpp"
-
-namespace glm{
-namespace detail
-{
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
-	{
-		tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
-		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
-		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
-		return tvec4<T, P>(pXYZ, pW);
-	}
-}//namespace detail
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T noise1(T const & x)
-	{
-		return noise1(tvec2<T, defaultp>(x, T(0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
-	{
-		return tvec2<T, defaultp>(
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
-	{
-		return tvec3<T, defaultp>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
-	{
-		return tvec4<T, defaultp>(
-			noise1(x - T(1.0)),
-			noise1(x + T(0.0)),
-			noise1(x + T(1.0)),
-			noise1(x + T(2.0)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
-	{
-		tvec4<T, P> const C = tvec4<T, P>(
-			T( 0.211324865405187),		// (3.0 -  sqrt(3.0)) / 6.0
-			T( 0.366025403784439),		//  0.5 * (sqrt(3.0)  - 1.0)
-			T(-0.577350269189626),		// -1.0 + 2.0 * C.x
-			T( 0.024390243902439));		//  1.0 / 41.0
-		
-		// First corner
-		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
-		tvec2<T, P> x0 = v -   i + dot(i, tvec2<T, P>(C[0]));
-		
-		// Other corners
-		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
-		//i1.y = 1.0 - i1.x;
-		tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
-
-		// x0 = x0 - 0.0 + 0.0 * C.xx ;
-		// x1 = x0 - i1 + 1.0 * C.xx ;
-		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
-		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
-		
-		// Permutations
-		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		tvec3<T, P> p = detail::permute(
-			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
-		
-		tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
-			dot(x0, x0),
-			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
-			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
-		
-		m = m * m;
-		m = m * m;
-		
-		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
-		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
-		
-		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
-		tvec3<T, P> h = abs(x) - T(0.5);
-		tvec3<T, P> ox = floor(x + T(0.5));
-		tvec3<T, P> a0 = x - ox;
-		
-		// Normalise gradients implicitly by scaling m
-		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
-		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
-		
-		// Compute final noise value at P
-		tvec3<T, P> g;
-		g.x  = a0.x  * x0.x  + h.x  * x0.y;
-		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-		g.y = a0.y * x12.x + h.y * x12.y;
-		g.z = a0.z * x12.z + h.z * x12.w;
-		return T(130) * dot(m, g);
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
-	{
-		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
-		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
-		
-		// First corner
-		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
-		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
-		
-		// Other corners
-		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
-		tvec3<T, P> l(T(1) - g);
-		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
-		tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
-		
-		// x0 = x0 - 0.0 + 0.0 * C.xxx;
-		// x1 = x0 - i1  + 1.0 * C.xxx;
-		// x2 = x0 - i2  + 2.0 * C.xxx;
-		// x3 = x0 - 1.0 + 3.0 * C.xxx;
-		tvec3<T, P> x1(x0 - i1 + C.x);
-		tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
-		tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
-		
-		// Permutations
-		i = mod289(i); 
-		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
-			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
-			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
-			i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
-		
-		// Gradients: 7x7 points over a square, mapped onto an octahedron.
-		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
-		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
-		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
-		
-		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
-		
-		tvec4<T, P> x_(floor(j * ns.z));
-		tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
-		
-		tvec4<T, P> x(x_ * ns.x + ns.y);
-		tvec4<T, P> y(y_ * ns.x + ns.y);
-		tvec4<T, P> h(T(1) - abs(x) - abs(y));
-		
-		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
-		tvec4<T, P> b1(x.z, x.w, y.z, y.w);
-		
-		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
-		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
-		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
-		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
-		
-		tvec4<T, P> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
-		tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
-		
-		tvec3<T, P> p0(a0.x, a0.y, h.x);
-		tvec3<T, P> p1(a0.z, a0.w, h.y);
-		tvec3<T, P> p2(a1.x, a1.y, h.z);
-		tvec3<T, P> p3(a1.z, a1.w, h.w);
-		
-		// Normalise gradients
-		tvec4<T, P> norm = taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		
-		// Mix final noise value
-		tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
-		m = m * m;
-		return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
-	{
-		tvec4<T, P> const C(
-			0.138196601125011,		// (5 - sqrt(5))/20  G4
-			0.276393202250021,		// 2 * G4
-			0.414589803375032,		// 3 * G4
-			-0.447213595499958);	// -1 + 4 * G4
-		
-		// (sqrt(5) - 1)/4 = F4, used once below
-		T const F4 = static_cast<T>(0.309016994374947451);
-		
-		// First corner
-		tvec4<T, P> i  = floor(v + dot(v, tvec4<T, P>(F4)));
-		tvec4<T, P> x0 = v -   i + dot(i, tvec4<T, P>(C.x));
-		
-		// Other corners
-		
-		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		tvec4<T, P> i0;
-		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
-		tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
-		
-		//  i0.x = dot(isX, vec3(1.0));
-		//i0.x = isX.x + isX.y + isX.z;
-		//i0.yzw = static_cast<T>(1) - isX;
-		i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
-		
-		//  i0.y += dot(isYZ.xy, vec2(1.0));
-		i0.y += isYZ.x + isYZ.y;
-		
-		//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
-		i0.z += static_cast<T>(1) - isYZ.x;
-		i0.w += static_cast<T>(1) - isYZ.y;
-		i0.z += isYZ.z;
-		i0.w += static_cast<T>(1) - isYZ.z;
-		
-		// i0 now contains the unique values 0,1,2,3 in each channel
-		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
-		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
-		tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
-		
-		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
-		//  x1 = x0 - i1  + 0.0 * C.xxxx
-		//  x2 = x0 - i2  + 0.0 * C.xxxx
-		//  x3 = x0 - i3  + 0.0 * C.xxxx
-		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		tvec4<T, P> x1 = x0 - i1 + C.x;
-		tvec4<T, P> x2 = x0 - i2 + C.y;
-		tvec4<T, P> x3 = x0 - i3 + C.z;
-		tvec4<T, P> x4 = x0 + C.w;
-		
-		// Permutations
-		i = mod(i, T(289));
-		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
-		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
-			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
-			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
-			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
-			i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
-		
-		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
-		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
-		
-		tvec4<T, P> p0 = detail::grad4(j0,   ip);
-		tvec4<T, P> p1 = detail::grad4(j1.x, ip);
-		tvec4<T, P> p2 = detail::grad4(j1.y, ip);
-		tvec4<T, P> p3 = detail::grad4(j1.z, ip);
-		tvec4<T, P> p4 = detail::grad4(j1.w, ip);
-		
-		// Normalise gradients
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		p4 *= taylorInvSqrt(dot(p4, p4));
-		
-		// Mix contributions from the five corners
-		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
-		m0 = m0 * m0;
-		m1 = m1 * m1;
-		
-		return T(49) * (
-			dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
-			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
-	{
-		return tvec2<T, P>(
-			noise1(x + tvec2<T, P>(0.0)),
-			noise1(tvec2<T, P>(0.0) - x));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
-	{
-		return tvec2<T, P>(
-			noise1(x + tvec3<T, P>(0.0)),
-			noise1(tvec3<T, P>(0.0) - x));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
-	{
-		return tvec2<T, P>(
-			noise1(x + tvec4<T, P>(0)),
-			noise1(tvec4<T, P>(0) - x));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
-	{
-		return tvec3<T, P>(
-			noise1(x - tvec2<T, P>(1.0)),
-			noise1(x + tvec2<T, P>(0.0)),
-			noise1(x + tvec2<T, P>(1.0)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
-	{
-		return tvec3<T, P>(
-			noise1(x - tvec3<T, P>(1.0)),
-			noise1(x + tvec3<T, P>(0.0)),
-			noise1(x + tvec3<T, P>(1.0)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
-	{
-		return tvec3<T, P>(
-			noise1(x - tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(0)),
-			noise1(x + tvec4<T, P>(1)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
-	{
-		return tvec4<T, P>(
-			noise1(x - tvec2<T, P>(1)),
-			noise1(x + tvec2<T, P>(0)),
-			noise1(x + tvec2<T, P>(1)),
-			noise1(x + tvec2<T, P>(2)));
-	}
-
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
-	{
-		return tvec4<T, P>(
-			noise1(x - tvec3<T, P>(1)),
-			noise1(x + tvec3<T, P>(0)),
-			noise1(x + tvec3<T, P>(1)),
-			noise1(x + tvec3<T, P>(2)));
-	}
-	
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
-	{
-		return tvec4<T, P>(
-			noise1(x - tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(0)),
-			noise1(x + tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(2)));
-	}
-	
-}//namespace glm
@@ -1,42 +1,13 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_packing.hpp
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
 /// @see gtc_packing
-/// 
+///
 /// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
 /// @ingroup core
-/// 
+///
 /// These functions do not operate component-wise, rather as described in each case.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -111,7 +82,7 @@ namespace glm
 	/// 
 	/// @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 const & p);
+	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.
@@ -124,7 +95,7 @@ namespace glm
 	/// 
 	/// @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 const & p);
+	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.
@@ -137,7 +108,7 @@ namespace glm
 	/// 
 	/// @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 const & p);
+	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.
@@ -150,7 +121,7 @@ namespace glm
 	/// 
 	/// @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 const & p);
+	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. 
@@ -169,7 +140,7 @@ namespace glm
 	/// 
 	/// @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 const & v);
+	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, 
@@ -189,7 +160,7 @@ namespace glm
 	/// 
 	/// @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 const & v);
+	GLM_FUNC_DECL vec2 unpackHalf2x16(uint v);
 	
 	/// @}
 }//namespace glm
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_packing.inl
-/// @date 2010-03-17 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "func_common.hpp"
 #include "type_half.hpp"
@@ -38,87 +9,182 @@ namespace glm
 {
 	GLM_FUNC_QUALIFIER uint packUnorm2x16(vec2 const & v)
 	{
-		u16vec2 Topack(round(clamp(v, 0.0f, 1.0f) * 65535.0f));
-		// return reinterpret_cast<uint&>(Topack);
-    uint* ptr(reinterpret_cast<uint*>(&Topack));
-    return *ptr;
+		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 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint p)
 	{
-		vec2 Unpack(reinterpret_cast<u16vec2 const &>(p));
-		return Unpack * float(1.5259021896696421759365224689097e-5); // 1.0 / 65535.0
+		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)
 	{
-		i16vec2 Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
-		// return reinterpret_cast<uint32&>(Topack);
-    uint* ptr(reinterpret_cast<uint*>(&Topack));
-    return *ptr;
+		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 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint p)
 	{
-		vec2 Unpack(reinterpret_cast<i16vec2 const &>(p));
-		return clamp(
-			Unpack * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f,
-			-1.0f, 1.0f);
+		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)
 	{
-		u8vec4 Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f));
-		return reinterpret_cast<uint&>(Topack);
+		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 const & p)
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint p)
 	{
-		vec4 Unpack(reinterpret_cast<u8vec4 const&>(p));
-		return Unpack * float(0.0039215686274509803921568627451); // 1 / 255
+		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)
 	{
-		i8vec4 Topack(round(clamp(v ,-1.0f, 1.0f) * 127.0f));
-		return reinterpret_cast<uint&>(Topack);
+		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 const & p)
+	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint p)
 	{
-		vec4 Unpack(reinterpret_cast<i8vec4 const &>(p));
-		return clamp(
-			Unpack * 0.0078740157480315f, // 1.0f / 127.0f
-			-1.0f, 1.0f);
+		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)
 	{
-		return reinterpret_cast<double 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 const & v)
+	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double v)
 	{
-		return reinterpret_cast<uvec2 const &>(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)
 	{
-		i16vec2 Unpack(
-			detail::toFloat16(v.x),
-			detail::toFloat16(v.y));
+		union
+		{
+			i16  in[2];
+			uint out;
+		} u;

-		uint * Result = reinterpret_cast<uint*>(&Unpack);
-		return *Result;
+		u.in[0] = detail::toFloat16(v.x);
+		u.in[1] = detail::toFloat16(v.y);
+
+		return u.out;
 	}

-	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint const & v)
+	GLM_FUNC_QUALIFIER vec2 unpackHalf2x16(uint v)
 	{
-		i16vec2 Unpack(reinterpret_cast<i16vec2 const &>(v));
-	
+		union
+		{
+			uint in;
+			i16  out[2];
+		} u;
+
+		u.in = v;
+
 		return vec2(
-			detail::toFloat32(Unpack.x), 
-			detail::toFloat32(Unpack.y));
+			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
+
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/detail/func_packing_simd.inl
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_trigonometric.hpp
-/// @date 2008-08-01 / 2011-06-15
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 /// 
@@ -39,7 +11,6 @@
 /// the divisor of a ratio is 0, then results will be undefined.
 /// 
 /// These all operate component-wise. The description is per component.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -58,7 +29,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> radians(vecType<T, P> const & degrees);
+	GLM_FUNC_DECL GLM_CONSTEXPR vecType<T, P> radians(vecType<T, P> const & degrees);

 	/// Converts radians to degrees and returns the result.
 	///
@@ -67,7 +38,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> degrees(vecType<T, P> const & radians);
+	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].
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_trigonometric.inl
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include "_vectorize.hpp"
 #include <cmath>
@@ -38,7 +9,7 @@ namespace glm
 {
 	// radians
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType radians(genType degrees)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType radians(genType degrees)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'radians' only accept floating-point input");

@@ -46,14 +17,14 @@ namespace glm
 	}

 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> radians(vecType<T, P> const & v)
+	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 genType degrees(genType radians)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR genType degrees(genType radians)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'degrees' only accept floating-point input");

@@ -61,7 +32,7 @@ namespace glm
 	}

 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> degrees(vecType<T, P> const & v)
+	GLM_FUNC_QUALIFIER GLM_CONSTEXPR vecType<T, P> degrees(vecType<T, P> const & v)
 	{
 		return detail::functor1<T, T, P, vecType>::call(degrees, v);
 	}
@@ -113,7 +84,7 @@ namespace glm

 	// atan
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType atan(genType const & y, genType const & x)
+	GLM_FUNC_QUALIFIER genType atan(genType y, genType x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atan' only accept floating-point input");

@@ -123,7 +94,7 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> atan(vecType<T, P> const & a, vecType<T, P> const & b)
 	{
-		return detail::functor2<T, P, vecType>::call(atan2, a, b);
+		return detail::functor2<T, P, vecType>::call(::std::atan2, a, b);
 	}

 	using std::atan;
@@ -165,12 +136,12 @@ namespace glm
 #	if GLM_HAS_CXX11_STL
 		using std::asinh;
 #	else
-		template <typename genType> 
-		GLM_FUNC_QUALIFIER genType asinh(genType const & x)
+		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(abs(x) + sqrt(static_cast<genType>(1) + x * x));
+			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

@@ -185,7 +156,7 @@ namespace glm
 		using std::acosh;
 #	else
 		template <typename genType> 
-		GLM_FUNC_QUALIFIER genType acosh(genType const & x)
+		GLM_FUNC_QUALIFIER genType acosh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'acosh' only accept floating-point input");

@@ -206,11 +177,11 @@ namespace glm
 		using std::atanh;
 #	else
 		template <typename genType>
-		GLM_FUNC_QUALIFIER genType atanh(genType const & x)
+		GLM_FUNC_QUALIFIER genType atanh(genType x)
 		{
 			GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'atanh' only accept floating-point input");
 		
-			if(abs(x) >= static_cast<genType>(1))
+			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));
 		}
@@ -222,3 +193,8 @@ namespace glm
 		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
+
@@ -1,33 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_vector_relational.hpp
-/// @date 2008-08-03 / 2011-06-15
-/// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 /// 
@@ -40,7 +12,6 @@
 /// 
 /// In all cases, the sizes of all the input and return vectors for any particular 
 /// call must match.
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/func_vector_relational.inl
-/// @date 2008-08-03 / 2011-09-09
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include <limits>

@@ -37,10 +8,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] < y[i];

 		return Result;
@@ -49,10 +20,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
@@ -60,10 +31,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
@@ -71,10 +42,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
@@ -82,10 +53,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
@@ -93,10 +64,10 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());

 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		for(length_t i = 0; i < x.length(); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;
 	}
@@ -105,7 +76,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
 	{
 		bool Result = false;
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		for(length_t i = 0; i < v.length(); ++i)
 			Result = Result || v[i];
 		return Result;
 	}
@@ -114,7 +85,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
 	{
 		bool Result = true;
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		for(length_t i = 0; i < v.length(); ++i)
 			Result = Result && v[i];
 		return Result;
 	}
@@ -123,9 +94,12 @@ namespace glm
 	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
 	{
 		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		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
@@ -0,0 +1,9 @@
+/// @ref core
+/// @file glm/detail/func_vector_relational_simd.inl
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/glm.cpp
-/// @date 2013-04-22 / 2013-04-22
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
@@ -1,87 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_common.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-	__m128 sse_abs_ps(__m128 x);
-
-	__m128 sse_sgn_ps(__m128 x);
-
-	//floor
-	__m128 sse_flr_ps(__m128 v);
-
-	//trunc
-	__m128 sse_trc_ps(__m128 v);
-
-	//round
-	__m128 sse_nd_ps(__m128 v);
-
-	//roundEven
-	__m128 sse_rde_ps(__m128 v);
-
-	__m128 sse_rnd_ps(__m128 x);
-
-	__m128 sse_ceil_ps(__m128 v);
-
-	__m128 sse_frc_ps(__m128 x);
-
-	__m128 sse_mod_ps(__m128 x, __m128 y);
-
-	__m128 sse_modf_ps(__m128 x, __m128i & i);
-
-	//GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
-
-	//GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
-
-	__m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
-
-	__m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
-
-	__m128 sse_stp_ps(__m128 edge, __m128 x);
-
-	__m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
-
-	__m128 sse_nan_ps(__m128 x);
-
-	__m128 sse_inf_ps(__m128 x);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_common.inl"
-
-#endif//GLM_ARCH
@@ -1,313 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_common.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#pragma warning(push)
-#pragma warning(disable : 4510 4512 4610)
-#endif
-
-	union ieee754_QNAN
-	{
-		const float f;
-		struct i
-		{
-			const unsigned int mantissa:23, exp:8, sign:1;
-		};
-
-		ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
-	};
-
-#if(GLM_COMPILER & GLM_COMPILER_VC)
-#pragma warning(pop)
-#endif
-
-	static const __m128 GLM_VAR_USED zero = _mm_setzero_ps();
-	static const __m128 GLM_VAR_USED one = _mm_set_ps1(1.0f);
-	static const __m128 GLM_VAR_USED minus_one = _mm_set_ps1(-1.0f);
-	static const __m128 GLM_VAR_USED two = _mm_set_ps1(2.0f);
-	static const __m128 GLM_VAR_USED three = _mm_set_ps1(3.0f);
-	static const __m128 GLM_VAR_USED pi = _mm_set_ps1(3.1415926535897932384626433832795f);
-	static const __m128 GLM_VAR_USED hundred_eighty = _mm_set_ps1(180.f);
-	static const __m128 GLM_VAR_USED pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
-	static const __m128 GLM_VAR_USED hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
-
-	static const ieee754_QNAN absMask;
-	static const __m128 GLM_VAR_USED abs4Mask = _mm_set_ps1(absMask.f);
-
-	static const __m128 GLM_VAR_USED _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(static_cast<int>(0x80000000)));
-	//static const __m128 GLM_VAR_USED _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
-	//static const __m128 GLM_VAR_USED _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
-	//static const __m128 GLM_VAR_USED _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
-	//static const __m128 GLM_VAR_USED _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
-	static const __m128 GLM_VAR_USED _epi32_0 = _mm_set_ps1(0);
-	static const __m128 GLM_VAR_USED _epi32_1 = _mm_set_ps1(1);
-	static const __m128 GLM_VAR_USED _epi32_2 = _mm_set_ps1(2);
-	static const __m128 GLM_VAR_USED _epi32_3 = _mm_set_ps1(3);
-	static const __m128 GLM_VAR_USED _epi32_4 = _mm_set_ps1(4);
-	static const __m128 GLM_VAR_USED _epi32_5 = _mm_set_ps1(5);
-	static const __m128 GLM_VAR_USED _epi32_6 = _mm_set_ps1(6);
-	static const __m128 GLM_VAR_USED _epi32_7 = _mm_set_ps1(7);
-	static const __m128 GLM_VAR_USED _epi32_8 = _mm_set_ps1(8);
-	static const __m128 GLM_VAR_USED _epi32_9 = _mm_set_ps1(9);
-	static const __m128 GLM_VAR_USED _epi32_127 = _mm_set_ps1(127);
-	//static const __m128 GLM_VAR_USED _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
-	//static const __m128 GLM_VAR_USED _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
-
-	static const __m128 GLM_VAR_USED _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
-	static const __m128 GLM_VAR_USED _ps_0p5 = _mm_set_ps1(0.5f);
-	static const __m128 GLM_VAR_USED _ps_1 = _mm_set_ps1(1.0f);
-	static const __m128 GLM_VAR_USED _ps_m1 = _mm_set_ps1(-1.0f);
-	static const __m128 GLM_VAR_USED _ps_2 = _mm_set_ps1(2.0f);
-	static const __m128 GLM_VAR_USED _ps_3 = _mm_set_ps1(3.0f);
-	static const __m128 GLM_VAR_USED _ps_127 = _mm_set_ps1(127.0f);
-	static const __m128 GLM_VAR_USED _ps_255 = _mm_set_ps1(255.0f);
-	static const __m128 GLM_VAR_USED _ps_2pow23 = _mm_set_ps1(8388608.0f);
-
-	static const __m128 GLM_VAR_USED _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
-	static const __m128 GLM_VAR_USED _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
-
-	static const __m128 GLM_VAR_USED _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
-	static const __m128 GLM_VAR_USED _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
-	static const __m128 GLM_VAR_USED _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
-	static const __m128 GLM_VAR_USED _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
-	static const __m128 GLM_VAR_USED _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
-	static const __m128 GLM_VAR_USED _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
-
-	static const __m128 GLM_VAR_USED _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
-	static const __m128 GLM_VAR_USED _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
-	static const __m128 GLM_VAR_USED _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
-	static const __m128 GLM_VAR_USED _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
-	static const __m128 GLM_VAR_USED _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
-	static const __m128 GLM_VAR_USED _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
-	static const __m128 GLM_VAR_USED _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
-	static const __m128 GLM_VAR_USED _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
-	static const __m128 GLM_VAR_USED _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
-	static const __m128 GLM_VAR_USED _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
-	static const __m128 GLM_VAR_USED _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
-	static const __m128 GLM_VAR_USED _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
-	static const __m128 GLM_VAR_USED _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
-
-	static const __m128 GLM_VAR_USED _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
-	static const __m128 GLM_VAR_USED _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
-	static const __m128 GLM_VAR_USED _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
-	static const __m128 GLM_VAR_USED _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
-	static const __m128 GLM_VAR_USED _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
-	static const __m128 GLM_VAR_USED _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
-	static const __m128 GLM_VAR_USED _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
-	static const __m128 GLM_VAR_USED _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
-	static const __m128 GLM_VAR_USED _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
-	static const __m128 GLM_VAR_USED _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
-	static const __m128 GLM_VAR_USED _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
-	static const __m128 GLM_VAR_USED _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
-	static const __m128 GLM_VAR_USED _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
-	static const __m128 GLM_VAR_USED _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
-	static const __m128 GLM_VAR_USED _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
-	static const __m128 GLM_VAR_USED _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
-	static const __m128 GLM_VAR_USED _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
-	static const __m128 GLM_VAR_USED _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
-	static const __m128 GLM_VAR_USED _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
-	static const __m128 GLM_VAR_USED _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
-	static const __m128 GLM_VAR_USED _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
-	static const __m128 GLM_VAR_USED _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
-	static const __m128 GLM_VAR_USED _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
-	static const __m128 GLM_VAR_USED _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
-
-GLM_FUNC_QUALIFIER __m128 sse_abs_ps(__m128 x)
-{
-	return _mm_and_ps(glm::detail::abs4Mask, x);
-} 
-
-GLM_FUNC_QUALIFIER __m128 sse_sgn_ps(__m128 x)
-{
-	__m128 Neg = _mm_set1_ps(-1.0f);
-	__m128 Pos = _mm_set1_ps(1.0f);
-
-	__m128 Cmp0 = _mm_cmplt_ps(x, zero);
-	__m128 Cmp1 = _mm_cmpgt_ps(x, zero);
-
-	__m128 And0 = _mm_and_ps(Cmp0, Neg);
-	__m128 And1 = _mm_and_ps(Cmp1, Pos);
-
-	return _mm_or_ps(And0, And1);
-}
-
-//floor
-GLM_FUNC_QUALIFIER __m128 sse_flr_ps(__m128 x)
-{
-	__m128 rnd0 = sse_rnd_ps(x);
-	__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
-	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
-	__m128 sub0 = _mm_sub_ps(rnd0, and0);
-	return sub0;
-}
-
-//trunc
-/*
-GLM_FUNC_QUALIFIER __m128 _mm_trc_ps(__m128 v)
-{
-	return __m128();
-}
-*/
-//round
-GLM_FUNC_QUALIFIER __m128 sse_rnd_ps(__m128 x)
-{
-	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
-	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
-	__m128 add0 = _mm_add_ps(x, or0);
-	__m128 sub0 = _mm_sub_ps(add0, or0);
-	return sub0;
-}
-
-//roundEven
-GLM_FUNC_QUALIFIER __m128 sse_rde_ps(__m128 x)
-{
-	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
-	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
-	__m128 add0 = _mm_add_ps(x, or0);
-	__m128 sub0 = _mm_sub_ps(add0, or0);
-	return sub0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_ceil_ps(__m128 x)
-{
-	__m128 rnd0 = sse_rnd_ps(x);
-	__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
-	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
-	__m128 add0 = _mm_add_ps(rnd0, and0);
-	return add0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_frc_ps(__m128 x)
-{
-	__m128 flr0 = sse_flr_ps(x);
-	__m128 sub0 = _mm_sub_ps(x, flr0);
-	return sub0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
-{
-	__m128 div0 = _mm_div_ps(x, y);
-	__m128 flr0 = sse_flr_ps(div0);
-	__m128 mul0 = _mm_mul_ps(y, flr0);
-	__m128 sub0 = _mm_sub_ps(x, mul0);
-	return sub0;
-}
-
-/// TODO
-/*
-GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
-{
-	__m128 empty;
-	return empty;
-}
-*/
-
-//GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
-
-//GLM_FUNC_QUALIFIER __m128 _mm_max_ps(__m128 x, __m128 y)
-
-GLM_FUNC_QUALIFIER __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
-{
-	__m128 min0 = _mm_min_ps(v, maxVal);
-	__m128 max0 = _mm_max_ps(min0, minVal);
-	return max0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a)
-{
-	__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
-	__m128 mul0 = _mm_mul_ps(v1, sub0);
-	__m128 mul1 = _mm_mul_ps(v2, a);
-	__m128 add0 = _mm_add_ps(mul0, mul1);
-	return add0;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_stp_ps(__m128 edge, __m128 x)
-{
-	__m128 cmp = _mm_cmple_ps(x, edge);
-	if(_mm_movemask_ps(cmp) == 0)
-		return glm::detail::one;
-	else
-		return glm::detail::zero;
-}
-
-GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
-{
-	__m128 sub0 = _mm_sub_ps(x, edge0);
-	__m128 sub1 = _mm_sub_ps(edge1, edge0);
-	__m128 div0 = _mm_sub_ps(sub0, sub1);
-	__m128 clp0 = sse_clp_ps(div0, glm::detail::zero, glm::detail::one);
-	__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
-	__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
-	__m128 mul1 = _mm_mul_ps(clp0, clp0);
-	__m128 mul2 = _mm_mul_ps(mul1, sub2);
-	return mul2;
-}
-
-/// \todo
-//GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
-//{
-//	__m128 empty;
-//	return empty;
-//}
-
-/// \todo
-//GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
-//{
-//	__m128 empty;
-//	return empty;
-//}
-
-// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
-// By Elan Ruskin, http://assemblyrequired.crashworks.org/
-GLM_FUNC_QUALIFIER __m128 sse_sqrt_wip_ss(__m128 const & x)
-{
-	__m128 recip = _mm_rsqrt_ss(x);  // "estimate" opcode
-	const static __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
-	const static __m128 half = {0.5,0.5,0.5,0.5};
-	__m128 halfrecip = _mm_mul_ss(half, recip);
-	__m128 threeminus_xrr = _mm_sub_ss(three, _mm_mul_ss(x, _mm_mul_ss (recip, recip)));
-	return _mm_mul_ss( halfrecip, threeminus_xrr);
-}
-
-}//namespace detail
-}//namespace glms
@@ -1,77 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_exponential.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-/*
-GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
-{
-	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
-	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
-	const static __m128 half = { 0.5,0.5,0.5,0.5 };
-	__m128 halfrecip = _mm_mul_ss( half, recip );
-	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
-	return _mm_mul_ss( halfrecip, threeminus_xrr );
-}
- 
-GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float * RESTRICT vIn )
-{
-        __m128 x = _mm_load_ss(&vIn[0]);
-        __m128 y = _mm_load_ss(&vIn[1]);
-        __m128 z = _mm_load_ss(&vIn[2]);
- 
-        const __m128 l =  // compute x*x + y*y + z*z
-                _mm_add_ss(
-                 _mm_add_ss( _mm_mul_ss(x,x),
-                             _mm_mul_ss(y,y)
-                            ),
-                 _mm_mul_ss( z, z )
-                );
- 
- 
-        const __m128 rsqt = _mm_rsqrt_nr_ss( l );
-        _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
-        _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
-        _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
- 
-        return _mm_mul_ss( l , rsqt );
-}
-*/
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_exponential.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
@@ -1,74 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_geometric.hpp
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-#include "intrinsic_common.hpp"
-
-namespace glm{
-namespace detail
-{
-	//length
-	__m128 sse_len_ps(__m128 x);
-
-	//distance
-	__m128 sse_dst_ps(__m128 p0, __m128 p1);
-
-	//dot
-	__m128 sse_dot_ps(__m128 v1, __m128 v2);
-
-	// SSE1
-	__m128 sse_dot_ss(__m128 v1, __m128 v2);
-
-	//cross
-	__m128 sse_xpd_ps(__m128 v1, __m128 v2);
-
-	//normalize
-	__m128 sse_nrm_ps(__m128 v);
-
-	//faceforward
-	__m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
-
-	//reflect
-	__m128 sse_rfe_ps(__m128 I, __m128 N);
-
-	//refract
-	__m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_geometric.inl"
-
-#endif//GLM_ARCH
@@ -1,147 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_geometric.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail{
-
-//length
-GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
-{
-	__m128 dot0 = sse_dot_ps(x, x);
-	__m128 sqt0 = _mm_sqrt_ps(dot0);
-	return sqt0;
-}
-
-//distance
-GLM_FUNC_QUALIFIER __m128 sse_dst_ps(__m128 p0, __m128 p1)
-{
-	__m128 sub0 = _mm_sub_ps(p0, p1);
-	__m128 len0 = sse_len_ps(sub0);
-	return len0;
-}
-
-//dot
-GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
-{
-
-#	if(GLM_ARCH & GLM_ARCH_AVX)
-		return _mm_dp_ps(v1, v2, 0xff);
-#	else
-		__m128 mul0 = _mm_mul_ps(v1, v2);
-		__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
-		__m128 add0 = _mm_add_ps(mul0, swp0);
-		__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
-		__m128 add1 = _mm_add_ps(add0, swp1);
-		return add1;
-#	endif
-}
-
-// SSE1
-GLM_FUNC_QUALIFIER __m128 sse_dot_ss(__m128 v1, __m128 v2)
-{
-	__m128 mul0 = _mm_mul_ps(v1, v2);
-	__m128 mov0 = _mm_movehl_ps(mul0, mul0);
-	__m128 add0 = _mm_add_ps(mov0, mul0);
-	__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
-	__m128 add1 = _mm_add_ss(add0, swp1);
-	return add1;
-}
-
-//cross
-GLM_FUNC_QUALIFIER __m128 sse_xpd_ps(__m128 v1, __m128 v2)
-{
-	__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
-	__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
-	__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
-	__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
-	__m128 mul0 = _mm_mul_ps(swp0, swp3);
-	__m128 mul1 = _mm_mul_ps(swp1, swp2);
-	__m128 sub0 = _mm_sub_ps(mul0, mul1);
-	return sub0;
-}
-
-//normalize
-GLM_FUNC_QUALIFIER __m128 sse_nrm_ps(__m128 v)
-{
-	__m128 dot0 = sse_dot_ps(v, v);
-	__m128 isr0 = _mm_rsqrt_ps(dot0);
-	__m128 mul0 = _mm_mul_ps(v, isr0);
-	return mul0;
-}
-
-//faceforward
-GLM_FUNC_QUALIFIER __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref)
-{
-	//__m128 dot0 = _mm_dot_ps(v, v);
-	//__m128 neg0 = _mm_neg_ps(N);
-	//__m128 sgn0 = _mm_sgn_ps(dot0);
-	//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
-	//return mix0;
-
-	__m128 dot0 = sse_dot_ps(Nref, I);
-	__m128 sgn0 = sse_sgn_ps(dot0);
-	__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
-	__m128 mul1 = _mm_mul_ps(N, mul0);
-	return mul1;
-}
-
-//reflect
-GLM_FUNC_QUALIFIER __m128 sse_rfe_ps(__m128 I, __m128 N)
-{
-	__m128 dot0 = sse_dot_ps(N, I);
-	__m128 mul0 = _mm_mul_ps(N, dot0);
-	__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
-	__m128 sub0 = _mm_sub_ps(I, mul1);
-	return sub0;
-}
-
-//refract
-GLM_FUNC_QUALIFIER __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta)
-{
-	__m128 dot0 = sse_dot_ps(N, I);
-	__m128 mul0 = _mm_mul_ps(eta, eta);
-	__m128 mul1 = _mm_mul_ps(dot0, dot0);
-	__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
-	__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
-	__m128 mul2 = _mm_mul_ps(sub0, sub1);
-	
-	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
-		return glm::detail::zero;
-
-	__m128 sqt0 = _mm_sqrt_ps(mul2);
-	__m128 mul3 = _mm_mul_ps(eta, dot0);
-	__m128 add0 = _mm_add_ps(mul3, sqt0);
-	__m128 mul4 = _mm_mul_ps(add0, N);
-	__m128 mul5 = _mm_mul_ps(eta, I);
-	__m128 sub2 = _mm_sub_ps(mul5, mul4);
-
-	return sub2;
-}
-
-}//namespace detail
-}//namespace glm
@@ -1,48 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_integer.hpp
-/// @date 2009-05-11 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "glm/glm.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-	__m128i _mm_bit_interleave_si128(__m128i x);
-	__m128i _mm_bit_interleave_si128(__m128i x, __m128i y);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_integer.inl"
-
-#endif//GLM_ARCH
@@ -1,139 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2012 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_integer.inl
-/// @date 2009-05-08 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-namespace glm{
-namespace detail
-{
-	inline __m128i _mm_bit_interleave_si128(__m128i x)
-	{
-		__m128i const Mask4 = _mm_set1_epi32(0x0000FFFF);
-		__m128i const Mask3 = _mm_set1_epi32(0x00FF00FF);
-		__m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
-		__m128i const Mask1 = _mm_set1_epi32(0x33333333);
-		__m128i const Mask0 = _mm_set1_epi32(0x55555555);
-
-		__m128i Reg1;
-		__m128i Reg2;
-
-		// REG1 = x;
-		// REG2 = y;
-		//Reg1 = _mm_unpacklo_epi64(x, y);
-		Reg1 = x;
-
-		//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
-		//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
-		Reg2 = _mm_slli_si128(Reg1, 2);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask4);
-
-		//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
-		//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
-		Reg2 = _mm_slli_si128(Reg1, 1);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask3);
-
-		//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
-		//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
-		Reg2 = _mm_slli_epi32(Reg1, 4);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask2);
-
-		//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
-		//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
-		Reg2 = _mm_slli_epi32(Reg1, 2);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask1);
-
-		//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
-		//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
-		Reg2 = _mm_slli_epi32(Reg1, 1);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask0);
-
-		//return REG1 | (REG2 << 1);
-		Reg2 = _mm_slli_epi32(Reg1, 1);
-		Reg2 = _mm_srli_si128(Reg2, 8);
-		Reg1 = _mm_or_si128(Reg1, Reg2);
-	
-		return Reg1;
-	}
-
-	inline __m128i _mm_bit_interleave_si128(__m128i x, __m128i y)
-	{
-		__m128i const Mask4 = _mm_set1_epi32(0x0000FFFF);
-		__m128i const Mask3 = _mm_set1_epi32(0x00FF00FF);
-		__m128i const Mask2 = _mm_set1_epi32(0x0F0F0F0F);
-		__m128i const Mask1 = _mm_set1_epi32(0x33333333);
-		__m128i const Mask0 = _mm_set1_epi32(0x55555555);
-
-		__m128i Reg1;
-		__m128i Reg2;
-
-		// REG1 = x;
-		// REG2 = y;
-		Reg1 = _mm_unpacklo_epi64(x, y);
-
-		//REG1 = ((REG1 << 16) | REG1) & glm::uint64(0x0000FFFF0000FFFF);
-		//REG2 = ((REG2 << 16) | REG2) & glm::uint64(0x0000FFFF0000FFFF);
-		Reg2 = _mm_slli_si128(Reg1, 2);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask4);
-
-		//REG1 = ((REG1 <<  8) | REG1) & glm::uint64(0x00FF00FF00FF00FF);
-		//REG2 = ((REG2 <<  8) | REG2) & glm::uint64(0x00FF00FF00FF00FF);
-		Reg2 = _mm_slli_si128(Reg1, 1);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask3);
-
-		//REG1 = ((REG1 <<  4) | REG1) & glm::uint64(0x0F0F0F0F0F0F0F0F);
-		//REG2 = ((REG2 <<  4) | REG2) & glm::uint64(0x0F0F0F0F0F0F0F0F);
-		Reg2 = _mm_slli_epi32(Reg1, 4);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask2);
-
-		//REG1 = ((REG1 <<  2) | REG1) & glm::uint64(0x3333333333333333);
-		//REG2 = ((REG2 <<  2) | REG2) & glm::uint64(0x3333333333333333);
-		Reg2 = _mm_slli_epi32(Reg1, 2);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask1);
-
-		//REG1 = ((REG1 <<  1) | REG1) & glm::uint64(0x5555555555555555);
-		//REG2 = ((REG2 <<  1) | REG2) & glm::uint64(0x5555555555555555);
-		Reg2 = _mm_slli_epi32(Reg1, 1);
-		Reg1 = _mm_or_si128(Reg2, Reg1);
-		Reg1 = _mm_and_si128(Reg1, Mask0);
-
-		//return REG1 | (REG2 << 1);
-		Reg2 = _mm_slli_epi32(Reg1, 1);
-		Reg2 = _mm_srli_si128(Reg2, 8);
-		Reg1 = _mm_or_si128(Reg1, Reg2);
-	
-		return Reg1;
-	}
-}//namespace detail
-}//namespace glms
@@ -1,67 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_common.hpp
-/// @date 2009-06-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-#include "intrinsic_geometric.hpp"
-
-namespace glm{
-namespace detail
-{
-	void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
-
-	void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
-
-	__m128 sse_mul_ps(__m128 m[4], __m128 v);
-
-	__m128 sse_mul_ps(__m128 v, __m128 m[4]);
-
-	void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
-
-	void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
-
-	void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
-
-	void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
-
-	__m128 sse_det_ps(__m128 const m[4]);
-
-	__m128 sse_slow_det_ps(__m128 const m[4]);
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_matrix.inl"
-
-#endif//GLM_ARCH
@@ -1,46 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_trigonometric.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_trigonometric.inl"
-
-#endif//GLM_ARCH
@@ -1,27 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_trigonometric.inl
-/// @date 2011-06-15 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
@@ -1,46 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_vector_relational.hpp
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-
-#pragma once
-
-#include "setup.hpp"
-
-#if(!(GLM_ARCH & GLM_ARCH_SSE2))
-#	error "SSE2 instructions not supported or enabled"
-#else
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm
-
-#include "intrinsic_vector_relational.inl"
-
-#endif//GLM_ARCH
@@ -1,366 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
-/// @ref core
-/// @file glm/detail/intrinsic_vector_relational.inl
-/// @date 2009-06-09 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////
-//
-//// lessThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//    return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
-//}
-//
-//// lessThanEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThanEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
-//}
-//
-//// greaterThan
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThan
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//	
-//	return typename tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
-//}
-//
-//// greaterThanEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThanEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint);
-//
-//	return typename tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
-//}
-//
-//// equal
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type equal
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
-//}
-//
-//// notEqual
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type notEqual
-//(
-//	tvec2<T, P> const & x, 
-//	tvec2<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
-//(
-//	tvec3<T, P> const & x, 
-//	tvec3<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
-//}
-//
-//template <typename valType>
-//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
-//(
-//	tvec4<T, P> const & x, 
-//	tvec4<T, P> const & y
-//)
-//{
-//	GLM_STATIC_ASSERT(
-//		detail::type<valType>::is_float || 
-//		detail::type<valType>::is_int || 
-//		detail::type<valType>::is_uint || 
-//		detail::type<valType>::is_bool);
-//
-//	return typename tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
-//}
-//
-//// any
-//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
-//{
-//	return x.x || x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
-//{
-//    return x.x || x.y || x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool any(tvec4<bool> const & x)
-//{
-//    return x.x || x.y || x.z || x.w;
-//}
-//
-//// all
-//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
-//{
-//    return x.x && x.y;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
-//{
-//    return x.x && x.y && x.z;
-//}
-//
-//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
-//{
-//    return x.x && x.y && x.z && x.w;
-//}
-//
-//// not
-//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
-//(
-//	tvec2<bool> const & v
-//)
-//{
-//    return tvec2<bool>::bool_type(!v.x, !v.y);
-//}
-//
-//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
-//(
-//	tvec3<bool> const & v
-//)
-//{
-//    return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
-//}
-//
-//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
-//(
-//	tvec4<bool> const & v
-//)
-//{
-//    return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
-//}
@@ -1,44 +1,63 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-///
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-///
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/precision.hpp
-/// @date 2013-04-01 / 2013-04-01
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

+#include "setup.hpp"
+
 namespace glm
 {
 	enum precision
 	{
-		highp,
-		mediump,
-		lowp,
-		defaultp = highp
+		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
@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/type_float.hpp
-/// @date 2008-08-22 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

@@ -1,34 +1,5 @@
-///////////////////////////////////////////////////////////////////////////////////
-/// OpenGL Mathematics (glm.g-truc.net)
-///
-/// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
-/// Permission is hereby granted, free of charge, to any person obtaining a copy
-/// of this software and associated documentation files (the "Software"), to deal
-/// in the Software without restriction, including without limitation the rights
-/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-/// copies of the Software, and to permit persons to whom the Software is
-/// furnished to do so, subject to the following conditions:
-/// 
-/// The above copyright notice and this permission notice shall be included in
-/// all copies or substantial portions of the Software.
-/// 
-/// Restrictions:
-///		By making use of the Software for military purposes, you choose to make
-///		a Bunny unhappy.
-/// 
-/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-/// THE SOFTWARE.
-///
 /// @ref core
 /// @file glm/detail/type_gentype.hpp
-/// @date 2008-10-05 / 2011-06-15
-/// @author Christophe Riccio
-///////////////////////////////////////////////////////////////////////////////////

 #pragma once

--- a/Show More
+++ b/Show More