Merge remote-tracking branch 'remotes/origin/master' into web_interface

Conflicts:
	CMakeLists.txt
	common/logtypes.h
	common/shareddb.cpp
	world/net.cpp
	zone/client_logs.cpp
	zone/corpse.cpp
	zone/mob.cpp
	zone/net.cpp

CMakeLists.txt

@@ -327,7 +327,7 @@ 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/glm" "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libwebsockets" "${CMAKE_CURRENT_SOURCE_DIR}/common/rapidjson")
+INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm" "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libwebsockets" "${CMAKE_CURRENT_SOURCE_DIR}/common/rapidjson")
 
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(common)

changelog.txt

@@ -1,5 +1,142 @@
 EQEMu Changelog (Started on Sept 24, 2003 15:50)
 -------------------------------------------------------
+
+== 02/02/2015 ==
+Akkadius: Implement Packet logs with dumps
+	- Category: 41: Packet: Server -> Client With Dump
+	- Category: 42: Packet: Server -> Client With Dump
+	See: http://wiki.eqemulator.org/p?Logging_System_Overhaul#packet-logging-levels
+
+== 02/01/2015 ==
+demonstar55: Add quest debugging to lua
+	eq.debug("Test debug level implicit 1")
+	eq.debug("Test debug level explicit 1", 1)
+	eq.debug("Test debug level explicit 2", 2)
+	eq.debug("Test debug level explicit 3", 3)
+Akkadius: Add Packet Logging Categories
+	- 5 - Packet: Client -> Server - Logs::Client_Server_Packet
+	- 39 - Packet: Server -> Client - Logs::Server_Client_Packet
+	- 40 - Packet: Client -> Server Unhandled - Logs::Client_Server_Packet_Unhandled
+	See: http://wiki.eqemulator.org/p?Logging_System_Overhaul#packet-logging
+	
+== 01/31/2015 ==
+Trevius: Fixed FindGroundZ() and GetGroundZ() to once again utilize the X and Y arguments that are passed to them.
+
+== 01/30/2015 ==
+Akkadius: Implemented event type "EVENT_ENVIRONMENTAL_DAMAGE"
+	- This event triggers when taking any sort of environmental damage. Example use: 
+	sub EVENT_ENVIRONMENTAL_DAMAGE{
+		quest::debug("EVENT_ENVIRONMENTAL_DAMAGE");
+		quest::debug("env_damage is " . $env_damage);
+		quest::debug("env_damage_type is " . $env_damage_type);
+		quest::debug("env_final_damage is " . $env_final_damage);
+	} 
+	Result: (Test falling in Velks): http://i.imgur.com/tPRL7yL.png
+	- Implemented LUA counterpart of this same implementation above
+Akkadius (Bobaski): Add PoK New Merchant sql/git/optional/2015_01_30_poknowledge_spell_vendors.sql
+
+== 01/29/2015 ==
+Trevius: Added more information to Mercenary Logging.
+Trevius: Added potential fix for Mercenaries that fail to unsuspend.
+Trevius: Added a new "statscale" field to the merc_stats table that can be used to quickly balance Mercenary Stats based on Level.
+Trevius: The new "statscale" field now combines with the Mercs::ScaleRate rule value (default 100 percent for both).
+
+== 01/28/2015 ==
+Akkadius: Added Logs::DebugQuest category per request from Trevius (Great idea)
+	- Exported quest::debug(log_message, [debug_level = 1)
+	- Example:
+		quest::debug("This is a test debug message, level 1 (default)");
+		quest::debug("This is a test debug message, level 1", 1);
+		quest::debug("This is a test debug message, level 2", 2);
+		quest::debug("This is a test debug message, level 3", 3);
+		
+		Result: http://i.imgur.com/6VoafGE.png
+	- Uses traditional logging system to output this category
+	- Required MySQL Source in Database version 9070
+
+== 01/27/2015 ==
+Trevius: Removed "Mercenary Debug:" from the Mercenary Log entries.
+Trevius: Resolved duplicate "You have no Mercenaries" messages when zoning without owning a Mercenary.
+Trevius: Mercenaries should now always be able to unsuspend if the timer is up.
+Trevius: More work on Mercenaries and Grouping to reduce bugs and redundant queries.
+Uleat: Finished ClientVersion update to include patch file and namespace updates - don't forget to copy the renamed 'patch_UF.conf' into your eqemu directory.)
+
+== 01/26/2015 ==
+Uleat: Changed Corpse::MoveItemToCorpse() to allow 'by address' passing of removed item slot list. Fixed a bug that kept soul-bound items inside of bags from attuning properly
+
+== 01/25/2015 ==
+Trevius: Fixed an issue where Mercenaries were causing several DB queries per second while suspended.
+Trevius: Added Logs::Mercenaries to the new Logging System.  Logging of Mercenary information is off by default with the required SQL.
+
+== 01/24/2015 ==
+Uleat: Added equipment light source functionality to all mob derived classes (may still need tweaking...)
+Notes:
+	- In addition to equipment light sources, innate npc_type light sources have already been activated
+	- Valid light source values are 0 thru 15 (values are bitmask checked and limited to 0x0F)
+	- Not all classes handle equipment light sources the same way due to their equipment/loot list configurations
+	- Spell (casting?) light sources may be implemented at some point..more information is needed
+	- Currently, loot list (general inventory) light sources are limited to ItemTypeMisc and ItemTypeLight to avoid issues with worn-specific light sources emitting
+	- Augment light sources are not recognized by the client and, therefore, not implemented in the server code
+
+== 01/22/2015 ==
+Akkadius: Massive Log System overhaul, see: http://wiki.eqemulator.org/p?Logging_System_Overhaul&frm=Main
+	
+== 01/21/2015 ==
+Uleat: Added `light` field to npc_types load query (all six clients tested positive for functionality.)
+Note: This only affects 'innate' light. Equipment (other) light is still in-work.
+Optional SQL: utils/sql/git/optional/2015_01_21_NPC_Types_Light_Field_Primer.sql
+
+== 01/20/2015 ==
+Uleat: Fix for Inventory::_HasItemByUse(bucket) using the parent container when searching for bag container items.
+
+== 01/19/2015 ==
+Uleat: Changed 'enum EQClientVersion' to 'enum class ClientVersion.' Other light modifications were made to accommodate this namespace. Added 'RoF2' to the lua client version enumeration.
+
+== 01/15/2015 ==
+Uleat: Attempted fix for elusive inventory bug:
+  - Removed 'iter_queue' typedef and converted lcast to explicit or auto defines
+  - Reworked several functions that manipulate the cursor queue
+  - Found/corrected one occurrence of post-processing iterator incrementing in an ItemInstQueue handler
+  - Added many scope declarations in code that handles inventory manipulation (loose macros are bad...)
+Uleat: Added Item_Struct pointer checks to ItemInst methods that did not have them
+Uleat: Changed IsEquippable(race,class) to use bit-wise 'and' (&) over '(x%2)==1' in conditional check.
+Uleat: Changed DyeArmor() assignment of 'armor_color' to use bit-wise 'or' and bit-shifting (|,<<) over multiplication and addition (*,+).
+
+== 01/13/2015 ==
+Uleat: Placed an upper limit on the cursor queue save loop.
+Trevius: (RoF2) Guild invites now add new members as members instead of recruits, and /guild chat works properly.
+Trevius: (RoF2) Guild Promote is now functional.
+
+== 01/12/2015 ==
+Uleat: Fix for OP_FormattedMessage text link server crashes
+Uleat: Added text link translators for OP_TaskDescription (RoF+ -- all clients current)
+Uleat: Fix for load_bots.sql using '\\' as a delimiter (Changed to '$$')
+
+== 01/11/2015 ==
+Uleat: Added text link translators for OP_TaskDescription (Ti thru UF..RoF+ in-work)
+
+== 01/10/2015 ==
+Uleat: Added text link translators for OP_Emote
+
+== 01/09/2015 ==
+Uleat: Added text link translators for OP_FormattedMessage
+
+== 01/08/2015 ==
+Trevius: Added some extra checks and clean-up related to Groups and Mercenaries. 
+
+== 01/07/2015 ==
+Uleat: Excluded text link body from message scrambling in Client::GarbleMessage()
+Trevius: Mercenaries now load directly from tables only.  The vwMercNpcTypes view is no longer required and can be deleted.
+Trevius: Query fix for group_leaders table.  This may resolve some crashes/bugs related to Mercs/Bots and Groups.
+
+== 01/06/2015 ==
+Trevius: Changed the pet command #defines to be based on RoF2 list of pet commands and added decodes to Titanium, SoF and SoD.
+Trevius: (RoF+) The /pet focus on/off and /pet hold on/off commands are now functional.
+Trevius: Added defines for all remaining pet commands and some support for them as well.
+
+== 01/05/2015 ==
+Uleat: Fixed (added translators for) item/text links. Only 'OP_ChannelMessage' and 'OP_SpecialMesg' are currently handled..more text channels will be added as the need arises.
+
 == 01/03/2015 ==
 Trevius: (RoF2) /shield (shielding) and /key (key ring) are both now functional after opcode updates.
 

client_files/export/main.cpp

@@ -17,7 +17,9 @@
 */
 
 #include <stdio.h>
-#include "../../common/debug.h"
+
+#include "../../common/eqemu_logsys.h"
+#include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
@@ -25,47 +27,53 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
+EQEmuLogSys Log;
+
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	LogFile->write(EQEMuLog::Status, "Client Files Export Utility");
+	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	const EQEmuConfig *config = EQEmuConfig::get();
-	if(!load_log_settings(config->LogSettingsFile.c_str())) {
-		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
-	}
 
 	SharedDatabase database;
-	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	Log.Out(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)) {
-		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+		Log.Out(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();
+
 	ExportSpells(&database);
 	ExportSkillCaps(&database);
 	ExportBaseData(&database);
 
+	Log.CloseFileLogs();
+
 	return 0;
 }
 
 void ExportSpells(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Spells...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}
 
@@ -89,7 +97,6 @@ void ExportSpells(SharedDatabase *db) {
 			fprintf(f, "%s\n", line.c_str());
 		}
 	} else {
-		LogFile->write(EQEMuLog::Error, "Error in ExportSpells query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
 	}
 
 	fclose(f);
@@ -103,7 +110,6 @@ bool SkillUsable(SharedDatabase *db, int skill_id, int class_id) {
                                     class_id, skill_id);
 	auto results = db->QueryDatabase(query);
 	if(!results.Success()) {
-        LogFile->write(EQEMuLog::Error, "Error in skill_usable query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
         return false;
     }
 
@@ -123,7 +129,6 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
                                     class_id, skill_id, level);
     auto results = db->QueryDatabase(query);
     if (!results.Success()) {
-        LogFile->write(EQEMuLog::Error, "Error in get_skill query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
         return 0;
     }
 
@@ -135,11 +140,11 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
 }
 
 void ExportSkillCaps(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
@@ -164,11 +169,11 @@ void ExportSkillCaps(SharedDatabase *db) {
 }
 
 void ExportBaseData(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Exporting Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}
 
@@ -190,7 +195,6 @@ void ExportBaseData(SharedDatabase *db) {
 			fprintf(f, "%s\n", line.c_str());
 		}
 	} else {
-		LogFile->write(EQEMuLog::Error, "Error in ExportBaseData query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
 	}
 
 	fclose(f);

client_files/import/main.cpp

@@ -16,7 +16,8 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "../../common/debug.h"
+#include "../../common/eqemu_logsys.h"
+#include "../../common/global_define.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
@@ -24,38 +25,43 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
+EQEmuLogSys Log;
+
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
+	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	LogFile->write(EQEMuLog::Status, "Client Files Import Utility");
+	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		LogFile->write(EQEMuLog::Error, "Unable to load configuration file.");
+		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
 		return 1;
 	}
 
 	const EQEmuConfig *config = EQEmuConfig::get();
-	if(!load_log_settings(config->LogSettingsFile.c_str())) {
-		LogFile->write(EQEMuLog::Error, "Warning: unable to read %s.", config->LogSettingsFile.c_str());
-	}
 
 	SharedDatabase database;
-	LogFile->write(EQEMuLog::Status, "Connecting to database...");
+	Log.Out(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)) {
-		LogFile->write(EQEMuLog::Error, "Unable to connect to the database, cannot continue without a "
+		Log.Out(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();
+
 	ImportSpells(&database);
 	ImportSkillCaps(&database);
 	ImportBaseData(&database);
 
+	Log.CloseFileLogs();
+	
 	return 0;
 }
 
@@ -64,7 +70,6 @@ int GetSpellColumns(SharedDatabase *db) {
 	const std::string query = "DESCRIBE spells_new";
 	auto results = db->QueryDatabase(query);
 	if(!results.Success()) {
-        LogFile->write(EQEMuLog::Error, "Error in GetSpellColumns query '%s' %s", query.c_str(), results.ErrorMessage().c_str());
         return 0;
     }
 
@@ -72,10 +77,10 @@ int GetSpellColumns(SharedDatabase *db) {
 }
 
 void ImportSpells(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Spells...");
+	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
@@ -138,23 +143,23 @@ void ImportSpells(SharedDatabase *db) {
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
+		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Skill Caps...");
+	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
@@ -186,11 +191,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	LogFile->write(EQEMuLog::Status, "Importing Base Data...");
+	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		LogFile->write(EQEMuLog::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 

common/CMakeLists.txt

@@ -8,8 +8,9 @@ SET(common_sources
 	crc16.cpp
 	crc32.cpp
 	database.cpp
+	database_conversions.cpp
+	database_instances.cpp
 	dbcore.cpp
-	debug.cpp
 	emu_opcodes.cpp
 	emu_tcp_connection.cpp
 	emu_tcp_server.cpp
@@ -18,7 +19,7 @@ SET(common_sources
 	eqdb_res.cpp
 	eqemu_exception.cpp
 	eqemu_config.cpp
-	eqemu_error.cpp
+	eqemu_logsys.cpp
 	eq_packet.cpp
 	eq_stream.cpp
 	eq_stream_factory.cpp
@@ -31,13 +32,10 @@ SET(common_sources
 	guilds.cpp
 	ipc_mutex.cpp
 	item.cpp
-	logsys.cpp
-	logsys_eqemu.cpp
 	md5.cpp
 	memory_mapped_file.cpp
 	misc.cpp
 	misc_functions.cpp
-	moremath.cpp
 	mutex.cpp
 	mysql_request_result.cpp
 	mysql_request_row.cpp
@@ -75,7 +73,7 @@ SET(common_sources
 	patches/rof.cpp
 	patches/rof2.cpp
 	patches/titanium.cpp
-	patches/underfoot.cpp
+	patches/uf.cpp
 	SocketLib/Base64.cpp
 	SocketLib/File.cpp
 	SocketLib/HttpdCookies.cpp
@@ -99,7 +97,6 @@ SET(common_headers
 	base_packet.h
 	base_data.h
 	bodytypes.h
-	breakdowns.h
 	classes.h
 	condition.h
 	crash.h
@@ -108,7 +105,6 @@ SET(common_headers
 	data_verification.h
 	database.h
 	dbcore.h
-	debug.h
 	deity.h
 	emu_opcodes.h
 	emu_oplist.h
@@ -122,7 +118,7 @@ SET(common_headers
 	eqemu_exception.h
 	eqemu_config.h
 	eqemu_config_elements.h
-	eqemu_error.h
+	eqemu_logsys.h
 	eq_packet.h
 	eq_stream.h
 	eq_stream_factory.h
@@ -138,6 +134,7 @@ SET(common_headers
 	features.h
 	fixed_memory_hash_set.h
 	fixed_memory_variable_hash_set.h
+	global_define.h
 	guild_base.h
 	guilds.h
 	ipc_mutex.h
@@ -146,15 +143,12 @@ SET(common_headers
 	item_struct.h
 	languages.h
 	linked_list.h
-	logsys.h
-	logtypes.h
 	loottable.h
 	mail_oplist.h
 	md5.h
 	memory_mapped_file.h
 	misc.h
 	misc_functions.h
-	moremath.h
 	mutex.h
 	mysql_request_result.h
 	mysql_request_row.h
@@ -226,11 +220,11 @@ SET(common_headers
 	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
-	patches/underfoot.h
+	patches/uf.h
-	patches/underfoot_constants.h
+	patches/uf_constants.h
-	patches/underfoot_itemfields.h
+	patches/uf_itemfields.h
-	patches/underfoot_ops.h
+	patches/uf_ops.h
-	patches/underfoot_structs.h
+	patches/uf_structs.h
 	SocketLib/Base64.h
 	SocketLib/File.h
 	SocketLib/HttpdCookies.h
@@ -279,18 +273,18 @@ SOURCE_GROUP(Patches FILES
 	patches/titanium_ops.h
 	patches/titanium_constants.h
 	patches/titanium_structs.h
-	patches/underfoot.h
+	patches/uf.h
-	patches/underfoot_itemfields.h
+	patches/uf_itemfields.h
-	patches/underfoot_ops.h
+	patches/uf_ops.h
-	patches/underfoot_constants.h
+	patches/uf_constants.h
-	patches/underfoot_structs.h
+	patches/uf_structs.h
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sof.cpp
 	patches/rof.cpp
 	patches/rof2.cpp
 	patches/titanium.cpp
-	patches/underfoot.cpp
+	patches/uf.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES
@@ -340,7 +334,7 @@ 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/underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
+	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)
 
 

common/SocketLib/HTTPSocket.cpp

@@ -40,7 +40,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif
-#include "../debug.h"
+#include "../global_define.h"
 #include <stdio.h>
 #include <string>
 #include <stdarg.h>

common/SocketLib/HttpdCookies.cpp

@@ -26,7 +26,7 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
-#include "../debug.h"
+#include "../global_define.h"
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif

common/SocketLib/HttpdSocket.cpp

@@ -28,7 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifdef _WIN32
 #pragma warning(disable:4786)
 #endif
-#include "../debug.h"
+#include "../global_define.h"
 #include "Utility.h"
 #include "HttpdCookies.h"
 #include "HttpdForm.h"
@@ -194,7 +194,6 @@ void HttpdSocket::OnHeaderComplete()
 
 void HttpdSocket::OnData(const char *p,size_t l)
 {
-//printf("Got %d bytes: %.*s\n", l, l, p);
 	if (m_file)
 	{
 		m_file -> fwrite(p,1,l);

common/SocketLib/MemFile.cpp

@@ -110,7 +110,6 @@ size_t MemFile::fread(char *ptr, size_t size, size_t nmemb)
 	size_t sz = size * nmemb;
 	if (p + sz < BLOCKSIZE)
 	{
-//printf("Read @ %d(%d). %d bytes. (%c)\n", m_read_ptr, p, sz, *(m_current_read -> data + p));
 		memcpy(ptr, m_current_read -> data + p, sz);
 		m_read_ptr += sz;
 	}
@@ -142,7 +141,6 @@ size_t MemFile::fwrite(const char *ptr, size_t size, size_t nmemb)
 	size_t sz = size * nmemb;
 	if (p + sz < BLOCKSIZE)
 	{
-//printf("Write @ %d(%d). %d bytes.\n", m_write_ptr, p, sz);
 		memcpy(m_current_write -> data + p, ptr, sz);
 		m_write_ptr += sz;
 	}

common/StackWalker/StackWalker.cpp

@@ -1128,7 +1128,6 @@ BOOL __stdcall StackWalker::myReadProcMem(
     SIZE_T st;
     BOOL bRet = ReadProcessMemory(hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, &st);
     *lpNumberOfBytesRead = (DWORD) st;
-    //printf("ReadMemory: hProcess: %p, baseAddr: %p, buffer: %p, size: %d, read: %d, result: %d\n", hProcess, (LPVOID) qwBaseAddress, lpBuffer, nSize, (DWORD) st, (DWORD) bRet);
     return bRet;
   }
   else

common/base_packet.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
 #include "base_packet.h"
 #include "misc.h"
 #include "packet_dump.h"

common/breakdowns.h

@@ -1,134 +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
-*/
-#ifndef BREAKDOWNS_H_
-#define BREAKDOWNS_H_
-
-#include "types.h"
-
-
-#pragma pack(1)
-struct uint16_breakdown {
-	union {
-		uint16 all;
-		struct {
-			uint8 b1;
-			uint8 b2;
-		} bytes;
-	};
-	inline uint16&	operator=(const uint16& val) { return (all=val); }
-	inline uint16*	operator&() { return &all; }
-	inline operator	uint16&() { return all; }
-	inline uint8&	b1()	{ return bytes.b1; }
-	inline uint8&	b2()	{ return bytes.b2; }
-};
-
-struct uint32_breakdown {
-	union {
-		uint32 all;
-		struct {
-			uint16 w1;
-			uint16 w2;
-		} words;
-		struct {
-			uint8 b1;
-			union {
-				struct {
-					uint8 b2;
-					uint8 b3;
-				} middle;
-				uint16 w2_3; // word bytes 2 to 3
-			};
-			uint8 b4;
-		} bytes;
-	};
-	inline uint32&	operator=(const uint32& val) { return (all=val); }
-	inline uint32*	operator&() { return &all; }
-	inline operator	uint32&() { return all; }
-
-	inline uint16&	w1()	{ return words.w1; }
-	inline uint16&	w2()	{ return words.w2; }
-	inline uint16&	w2_3()	{ return bytes.w2_3; }
-	inline uint8&	b1()	{ return bytes.b1; }
-	inline uint8&	b2()	{ return bytes.middle.b2; }
-	inline uint8&	b3()	{ return bytes.middle.b3; }
-	inline uint8&	b4()	{ return bytes.b4; }
-};
-/*
-struct uint64_breakdown {
-	union {
-		uint64	all;
-		struct {
-			uint16	w1;	// 1 2
-			uint16	w2;	// 3 4
-			uint16	w3; // 5 6
-			uint16	w4; // 7 8
-		};
-		struct {
-			uint32	dw1; // 1 4
-			uint32	dw2; // 5 6
-		};
-		struct {
-			uint8	b1;
-			union {
-				struct {
-					uint16	w2_3;
-					uint16	w4_5;
-					uint16	w6_7;
-				};
-				uint32	dw2_5;
-				struct {
-					uint8	b2;
-					union {
-						uint32	dw3_6;
-						struct {
-							uint8	b3;
-							union {
-								uint32	dw4_7;
-								struct {
-									uint8	b4;
-									uint8	b5;
-									uint8	b6;
-									uint8	b7;
-								};
-							};
-						};
-					};
-				};
-			};
-		};
-	};
-	inline uint64* operator&() { return &all; }
-	inline operator uint64&() { return all; }
-};
-*/
-#pragma pack()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-#endif /*BREAKDOWNS_H_*/

common/classes.cpp

@@ -15,7 +15,7 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 	*/
-#include "../common/debug.h"
+#include "../common/global_define.h"
 #include "../common/classes.h"
 
 const char* GetEQClassName(uint8 class_, uint8 level) {

common/clientversions.h

@@ -1,75 +1,76 @@
 #ifndef CLIENTVERSIONS_H
 #define CLIENTVERSIONS_H
 
+#include "types.h"
+
 static const uint32 BIT_Client62	= 1;
 static const uint32 BIT_Titanium	= 2;
 static const uint32 BIT_SoF			= 4;
 static const uint32 BIT_SoD			= 8;
-static const uint32 BIT_Underfoot	= 16;
+static const uint32 BIT_UF			= 16;
 static const uint32 BIT_RoF			= 32;
 static const uint32 BIT_RoF2		= 64;
 
 static const uint32 BIT_TitaniumAndEarlier	= 0x00000003;
 static const uint32 BIT_SoFAndLater			= 0xFFFFFFFC;
 static const uint32 BIT_SoDAndLater			= 0xFFFFFFF8;
-static const uint32 BIT_UnderfootAndLater	= 0xFFFFFFF0;
+static const uint32 BIT_UFAndLater			= 0xFFFFFFF0;
 static const uint32 BIT_RoFAndLater			= 0xFFFFFFE0;
 static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0;
 static const uint32 BIT_AllClients			= 0xFFFFFFFF;
 
-typedef enum
+enum class ClientVersion
 {
-	EQClientUnknown = 0,
+	Unknown = 0,
-	EQClient62,				// Build: 'Aug  4 2005 15:40:59'
+	Client62,	// Build: 'Aug  4 2005 15:40:59'
-	EQClientTitanium,		// Build: 'Oct 31 2005 10:33:37'
+	Titanium,	// Build: 'Oct 31 2005 10:33:37'
-	EQClientSoF,			// Build: 'Sep  7 2007 09:11:49'
+	SoF,		// Build: 'Sep  7 2007 09:11:49'
-	EQClientSoD,			// Build: 'Dec 19 2008 15:22:49'
+	SoD,		// Build: 'Dec 19 2008 15:22:49'
-	EQClientUnderfoot,		// Build: 'Jun  8 2010 16:44:32'
+	UF,			// Build: 'Jun  8 2010 16:44:32'
-	EQClientRoF,			// Build: 'Dec 10 2012 17:35:44'
+	RoF,		// Build: 'Dec 10 2012 17:35:44'
-	EQClientRoF2,			// Build: 'May 10 2013 23:30:08'
+	RoF2,		// Build: 'May 10 2013 23:30:08'
 
-	_EQClientCount,			// place new clients before this point (preferably, in release/attribute order)
+	MobNPC,
+	MobMerc,
+	MobBot,
+	MobPet,
+};
 
-	// Values below are not implemented, as yet...
+#define CLIENT_VERSION_COUNT 12
+#define LAST_PC_CLIENT ClientVersion::RoF2
+#define LAST_NPC_CLIENT ClientVersion::MobPet
 
-	EmuNPC = _EQClientCount,
-	EmuMerc,
-	EmuBot,
-	EmuPet,
 
-	_EmuClientCount			// array size for EQLimits
+static const char* ClientVersionName(ClientVersion version)
-} EQClientVersion;
-
-static const char* EQClientVersionName(EQClientVersion version)
 {
 	switch (version)
 	{
-	case EQClientUnknown:
+	case ClientVersion::Unknown:
-		return "EQClientUnknown";
+		return "ClientVersion::Unknown";
-	case EQClient62:
+	case ClientVersion::Client62:
-		return "EQClient62";
+		return "ClientVersion::Client62";
-	case EQClientTitanium:
+	case ClientVersion::Titanium:
-		return "EQClientTitanium";
+		return "ClientVersion::Titanium";
-	case EQClientSoF:
+	case ClientVersion::SoF:
-		return "EQClientSoF";
+		return "ClientVersion::SoF";
-	case EQClientSoD:
+	case ClientVersion::SoD:
-		return "EQClientSoD";
+		return "ClientVersion::SoD";
-	case EQClientUnderfoot:
+	case ClientVersion::UF:
-		return "EQClientUnderfoot";
+		return "ClientVersion::UF";
-	case EQClientRoF:
+	case ClientVersion::RoF:
-		return "EQClientRoF";
+		return "ClientVersion::RoF";
-	case EQClientRoF2:
+	case ClientVersion::RoF2:
-		return "EQClientRoF2";
+		return "ClientVersion::RoF2";
-	case EmuNPC:
+	case ClientVersion::MobNPC:
-		return "EmuNPC";
+		return "ClientVersion::MobNPC";
-	case EmuMerc:
+	case ClientVersion::MobMerc:
-		return "EmuMerc";
+		return "ClientVersion::MobMerc";
-	case EmuBot:
+	case ClientVersion::MobBot:
-		return "EmuBot";
+		return "ClientVersion::MobBot";
-	case EmuPet:
+	case ClientVersion::MobPet:
-		return "EmuPet";
+		return "ClientVersion::MobPet";
 	default:
-		return "ERROR: Invalid EQClientVersion";
+		return "<ERROR> Invalid ClientVersion";
 	};
 }
 

common/condition.h

@@ -18,7 +18,8 @@
 #ifndef __CONDITION_H
 #define __CONDITION_H
 
-#include "debug.h"
+#include "global_define.h"
+#include "mutex.h"
 #ifndef WIN32
 #include <pthread.h>
 #endif

common/crash.cpp

@@ -1,4 +1,5 @@
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "crash.h"
 
 #if defined(_WINDOWS) && defined(CRASH_LOGGING)
@@ -24,7 +25,7 @@ public:
 			}
 		}
 
-		LogFile->write(EQEMuLog::Crash, buffer);
+		Log.Out(Logs::General, Logs::Crash, buffer);
 		StackWalker::OnOutput(szText);
 	}
 };
@@ -34,67 +35,67 @@ LONG WINAPI windows_exception_handler(EXCEPTION_POINTERS *ExceptionInfo)
 	switch(ExceptionInfo->ExceptionRecord->ExceptionCode)
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ACCESS_VIOLATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ACCESS_VIOLATION");
 			break;
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ARRAY_BOUNDS_EXCEEDED");
 			break;
 		case EXCEPTION_BREAKPOINT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_BREAKPOINT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_BREAKPOINT");
 			break;
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_DATATYPE_MISALIGNMENT");
 			break;
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DENORMAL_OPERAND");
 			break;
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_FLT_INEXACT_RESULT:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INEXACT_RESULT");
 			break;
 		case EXCEPTION_FLT_INVALID_OPERATION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_INVALID_OPERATION");
 			break;
 		case EXCEPTION_FLT_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_OVERFLOW");
 			break;
 		case EXCEPTION_FLT_STACK_CHECK:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_STACK_CHECK");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_STACK_CHECK");
 			break;
 		case EXCEPTION_FLT_UNDERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_FLT_UNDERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_FLT_UNDERFLOW");
 			break;
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_ILLEGAL_INSTRUCTION");
 			break;
 		case EXCEPTION_IN_PAGE_ERROR:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_IN_PAGE_ERROR");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_IN_PAGE_ERROR");
 			break;
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_DIVIDE_BY_ZERO");
 			break;
 		case EXCEPTION_INT_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INT_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INT_OVERFLOW");
 			break;
 		case EXCEPTION_INVALID_DISPOSITION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_INVALID_DISPOSITION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_INVALID_DISPOSITION");
 			break;
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_NONCONTINUABLE_EXCEPTION");
 			break;
 		case EXCEPTION_PRIV_INSTRUCTION:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_PRIV_INSTRUCTION");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_PRIV_INSTRUCTION");
 			break;
 		case EXCEPTION_SINGLE_STEP:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_SINGLE_STEP");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_SINGLE_STEP");
 			break;
 		case EXCEPTION_STACK_OVERFLOW:
-			LogFile->write(EQEMuLog::Crash, "EXCEPTION_STACK_OVERFLOW");
+			Log.Out(Logs::General, Logs::Crash, "EXCEPTION_STACK_OVERFLOW");
 			break;
 		default:
-			LogFile->write(EQEMuLog::Crash, "Unknown Exception");
+			Log.Out(Logs::General, Logs::Crash, "Unknown Exception");
 			break;
 	}
 

common/database.h

@@ -21,7 +21,8 @@
 #define AUTHENTICATION_TIMEOUT	60
 #define INVALID_ID				0xFFFFFFFF
 
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
@@ -52,9 +53,9 @@ struct EventLogDetails_Struct {
 };
 
 struct CharacterEventLog_Struct {
-uint32	count;
+	uint32	count;
-uint8	eventid;
+	uint8	eventid;
-EventLogDetails_Struct eld[255];
+	EventLogDetails_Struct eld[255];
 };
 
 struct npcDecayTimes_Struct {
@@ -71,412 +72,16 @@ struct VarCache_Struct {
 
 class PTimerList;
 
-#pragma pack(1)
+#ifdef _WINDOWS
-
+#if _MSC_VER > 1700 // greater than 2012 (2013+)
-/* Conversion Structs */
+#	define _ISNAN_(a) std::isnan(a)
-
+#else
-namespace Convert {
+#	include <float.h>
-	struct BindStruct {
+#	define _ISNAN_(a) _isnan(a)
-		/*000*/ uint32 zoneId;
+#endif
-		/*004*/ float x;
+#else
-		/*008*/ float y;
+#	define _ISNAN_(a) std::isnan(a)
-		/*012*/ float z;
+#endif
-		/*016*/ float heading;
-	};
-	struct Color_Struct
-	{
-		union
-		{
-			struct
-			{
-				uint8	blue;
-				uint8	green;
-				uint8	red;
-				uint8	use_tint;	// if there's a tint this is FF
-			} rgb;
-			uint32 color;
-		};
-	};
-	struct AA_Array
-	{
-		uint32 AA;
-		uint32 value;
-	};
-	struct SpellBuff_Struct
-	{
-		/*000*/	uint8	slotid;		//badly named... seems to be 2 for a real buff, 0 otherwise
-		/*001*/ uint8	level;
-		/*002*/	uint8	bard_modifier;
-		/*003*/	uint8	effect;			//not real
-		/*004*/	uint32	spellid;
-		/*008*/ uint32	duration;
-		/*012*/	uint32	counters;
-		/*016*/	uint32	player_id;	//'global' ID of the caster, for wearoff messages
-		/*020*/
-	};
-	struct Tribute_Struct {
-		uint32 tribute;
-		uint32 tier;
-	};
-	struct Disciplines_Struct {
-		uint32 values[MAX_PP_DISCIPLINES];
-	};
-	struct GroupLeadershipAA_Struct {
-		union {
-			struct {
-				uint32 groupAAMarkNPC;
-				uint32 groupAANPCHealth;
-				uint32 groupAADelegateMainAssist;
-				uint32 groupAADelegateMarkNPC;
-				uint32 groupAA4;
-				uint32 groupAA5;
-				uint32 groupAAInspectBuffs;
-				uint32 groupAA7;
-				uint32 groupAASpellAwareness;
-				uint32 groupAAOffenseEnhancement;
-				uint32 groupAAManaEnhancement;
-				uint32 groupAAHealthEnhancement;
-				uint32 groupAAHealthRegeneration;
-				uint32 groupAAFindPathToPC;
-				uint32 groupAAHealthOfTargetsTarget;
-				uint32 groupAA15;
-			};
-			uint32 ranks[MAX_GROUP_LEADERSHIP_AA_ARRAY];
-		};
-	};
-
-	struct RaidLeadershipAA_Struct {
-		union {
-			struct {
-				uint32 raidAAMarkNPC;
-				uint32 raidAANPCHealth;
-				uint32 raidAADelegateMainAssist;
-				uint32 raidAADelegateMarkNPC;
-				uint32 raidAA4;
-				uint32 raidAA5;
-				uint32 raidAA6;
-				uint32 raidAASpellAwareness;
-				uint32 raidAAOffenseEnhancement;
-				uint32 raidAAManaEnhancement;
-				uint32 raidAAHealthEnhancement;
-				uint32 raidAAHealthRegeneration;
-				uint32 raidAAFindPathToPC;
-				uint32 raidAAHealthOfTargetsTarget;
-				uint32 raidAA14;
-				uint32 raidAA15;
-			};
-			uint32 ranks[MAX_RAID_LEADERSHIP_AA_ARRAY];
-		};
-	};
-
-	struct LeadershipAA_Struct {
-		union {
-			struct {
-				Convert::GroupLeadershipAA_Struct group;
-				Convert::RaidLeadershipAA_Struct raid;
-			};
-			uint32 ranks[MAX_LEADERSHIP_AA_ARRAY];
-		};
-	};
-	typedef struct
-	{
-		/*00*/ char Name[64];
-		/*64*/ uint32 Level;
-		/*68*/ uint32 Race;
-		/*72*/ uint32 Class;
-		/*76*/ uint32 Zone;
-		/*80*/ uint32 Time;
-		/*84*/ uint32 Points;
-		/*88*/
-	} PVPStatsEntry_Struct;
-	struct BandolierItem_Struct {
-		uint32 item_id;
-		uint32 icon;
-		char item_name[64];
-	};
-	struct Bandolier_Struct {
-		char name[32];
-		Convert::BandolierItem_Struct items[EmuConstants::BANDOLIER_SIZE];
-	};
-	struct PotionBelt_Struct {
-		Convert::BandolierItem_Struct items[EmuConstants::POTION_BELT_SIZE];
-	};
-	struct SuspendedMinion_Struct
-	{
-		/*000*/	uint16 SpellID;
-		/*002*/	uint32 HP;
-		/*006*/	uint32 Mana;
-		/*010*/	Convert::SpellBuff_Struct Buffs[BUFF_COUNT];
-		/*510*/	uint32 Items[_MaterialCount];
-		/*546*/	char Name[64];
-		/*610*/
-	};
-
-	struct PlayerProfile_Struct {
-		/*0000*/	uint32							checksum;			// Checksum from CRC32::SetEQChecksum
-		/*0004*/	char							name[64];			// Name of player sizes not right
-		/*0068*/	char							last_name[32];		// Last name of player sizes not right
-		/*0100*/	uint32							gender;				// Player Gender - 0 Male, 1 Female
-		/*0104*/	uint32							race;				// Player race
-		/*0108*/	uint32							class_;				// Player class
-		/*0112*/	uint32							unknown0112;		//
-		/*0116*/	uint32							level;				// Level of player (might be one byte)
-		/*0120*/	Convert::BindStruct				binds[5];			// Bind points (primary is first, home city is fifth)
-		/*0220*/	uint32							deity;				// deity
-		/*0224*/	uint32							guild_id;
-		/*0228*/	uint32							birthday;			// characters bday
-		/*0232*/	uint32							lastlogin;			// last login or zone time
-		/*0236*/	uint32							timePlayedMin;		// in minutes
-		/*0240*/	uint8							pvp;
-		/*0241*/	uint8							level2;				//no idea why this is here, but thats how it is on live
-		/*0242*/	uint8							anon;				// 2=roleplay, 1=anon, 0=not anon
-		/*0243*/	uint8							gm;
-		/*0244*/	uint8							guildrank;
-		/*0245*/	uint8							guildbanker;
-		/*0246*/	uint8							unknown0246[6];		//
-		/*0252*/	uint32							intoxication;
-		/*0256*/	uint32							spellSlotRefresh[MAX_PP_REF_MEMSPELL];	//in ms
-		/*0292*/	uint32							abilitySlotRefresh;
-		/*0296*/	uint8							haircolor;			// Player hair color
-		/*0297*/	uint8							beardcolor;			// Player beard color
-		/*0298*/	uint8							eyecolor1;			// Player left eye color
-		/*0299*/	uint8							eyecolor2;			// Player right eye color
-		/*0300*/	uint8							hairstyle;			// Player hair style
-		/*0301*/	uint8							beard;				// Beard type
-		/*0302*/	uint8							ability_time_seconds;	//The following four spots are unknown right now.....
-		/*0303*/	uint8							ability_number;		//ability used
-		/*0304*/	uint8							ability_time_minutes;
-		/*0305*/	uint8							ability_time_hours;	//place holder
-		/*0306*/	uint8							unknown0306[6];		// @bp Spacer/Flag?
-		/*0312*/	uint32							item_material[_MaterialCount];	// Item texture/material of worn/held items
-		/*0348*/	uint8							unknown0348[44];
-		/*0392*/	Convert::Color_Struct			item_tint[_MaterialCount];
-		/*0428*/	Convert::AA_Array				aa_array[MAX_PP_AA_ARRAY];
-		/*2348*/	float							unknown2384;		//seen ~128, ~47
-		/*2352*/	char							servername[32];		// length probably not right
-		/*2384*/	char							title[32];			// length might be wrong
-		/*2416*/	char							suffix[32];			// length might be wrong
-		/*2448*/	uint32							guildid2;			//
-		/*2452*/	uint32							exp;				// Current Experience
-		/*2456*/	uint32							unknown2492;
-		/*2460*/	uint32							points;				// Unspent Practice points
-		/*2464*/	uint32							mana;				// current mana
-		/*2468*/	uint32							cur_hp;				// current hp
-		/*2472*/	uint32							unknown2508;		// 0x05
-		/*2476*/	uint32							STR;				// Strength
-		/*2480*/	uint32							STA;				// Stamina
-		/*2484*/	uint32							CHA;				// Charisma
-		/*2488*/	uint32							DEX;				// Dexterity
-		/*2492*/	uint32							INT;				// Intelligence
-		/*2496*/	uint32							AGI;				// Agility
-		/*2500*/	uint32							WIS;				// Wisdom
-		/*2504*/	uint8							face;				// Player face
-		/*2505*/	uint8							unknown2541[47];	// ?
-		/*2552*/	uint8							languages[MAX_PP_LANGUAGE];
-		/*2580*/	uint8							unknown2616[4];
-		/*2584*/	uint32							spell_book[MAX_PP_REF_SPELLBOOK];
-		/*4504*/	uint8							unknown4540[128];	// Was [428] all 0xff
-		/*4632*/	uint32							mem_spells[MAX_PP_REF_MEMSPELL];
-		/*4668*/	uint8							unknown4704[32];	//
-		/*4700*/	float							y;					// Player y position
-		/*4704*/	float							x;					// Player x position
-		/*4708*/	float							z;					// Player z position
-		/*4712*/	float							heading;			// Direction player is facing
-		/*4716*/	uint8							unknown4752[4];		//
-		/*4720*/	int32							platinum;			// Platinum Pieces on player
-		/*4724*/	int32							gold;				// Gold Pieces on player
-		/*4728*/	int32							silver;				// Silver Pieces on player
-		/*4732*/	int32							copper;				// Copper Pieces on player
-		/*4736*/	int32							platinum_bank;		// Platinum Pieces in Bank
-		/*4740*/	int32							gold_bank;			// Gold Pieces in Bank
-		/*4744*/	int32							silver_bank;		// Silver Pieces in Bank
-		/*4748*/	int32							copper_bank;		// Copper Pieces in Bank
-		/*4752*/	int32							platinum_cursor;	// Platinum on cursor
-		/*4756*/	int32							gold_cursor;		// Gold on cursor
-		/*4760*/	int32							silver_cursor;		// Silver on cursor
-		/*4764*/	int32							copper_cursor;		// Copper on cursor
-		/*4768*/	int32							platinum_shared;	// Platinum shared between characters
-		/*4772*/	uint8							unknown4808[24];
-		/*4796*/	uint32							skills[MAX_PP_SKILL];	// [400] List of skills	// 100 dword buffer
-		/*5196*/	uint8							unknown5132[184];
-		/*5380*/	uint32							pvp2;				//
-		/*5384*/	uint32							unknown5420;		//
-		/*5388*/	uint32							pvptype;			//
-		/*5392*/	uint32							unknown5428;		//
-		/*5396*/	uint32							ability_down;		// Guessing
-		/*5400*/	uint8							unknown5436[8];		//
-		/*5408*/	uint32							autosplit;			//not used right now
-		/*5412*/	uint8							unknown5448[8];
-		/*5420*/	uint32							zone_change_count;	// Number of times user has zoned in their career (guessing)
-		/*5424*/	uint8							unknown5460[16];	//
-		/*5440*/	uint32							drakkin_heritage;	//
-		/*5444*/	uint32							drakkin_tattoo;		//
-		/*5448*/	uint32							drakkin_details;	//
-		/*5452*/	uint32							expansions;			// expansion setting, bit field of expansions avaliable
-		/*5456*/	int32							toxicity;			//from drinking potions, seems to increase by 3 each time you drink
-		/*5460*/	char							unknown5496[16];	//
-		/*5476*/	int32							hunger_level;
-		/*5480*/	int32							thirst_level;
-		/*5484*/	uint32							ability_up;
-		/*5488*/	char							unknown5524[16];
-		/*5504*/	uint16							zone_id;			// Current zone of the player
-		/*5506*/	uint16							zoneInstance;		// Instance ID
-		/*5508*/	Convert::SpellBuff_Struct		buffs[BUFF_COUNT];	// Buffs currently on the player
-		/*6008*/	char							groupMembers[6][64];//
-		/*6392*/	char							unknown6428[656];
-		/*7048*/	uint32							entityid;
-		/*7052*/	uint32							leadAAActive;
-		/*7056*/	uint32							unknown7092;
-		/*7060*/	int32							ldon_points_guk;	//client uses these as signed
-		/*7064*/	int32							ldon_points_mir;
-		/*7068*/	int32							ldon_points_mmc;
-		/*7072*/	int32							ldon_points_ruj;
-		/*7076*/	int32							ldon_points_tak;
-		/*7080*/	int32							ldon_points_available;
-		/*7084*/	int32							ldon_wins_guk;
-		/*7088*/	int32							ldon_wins_mir;
-		/*7092*/	int32							ldon_wins_mmc;
-		/*7096*/	int32							ldon_wins_ruj;
-		/*7100*/	int32							ldon_wins_tak;
-		/*7104*/	int32							ldon_losses_guk;
-		/*7108*/	int32							ldon_losses_mir;
-		/*7112*/	int32							ldon_losses_mmc;
-		/*7116*/	int32							ldon_losses_ruj;
-		/*7120*/	int32							ldon_losses_tak;
-		/*7124*/	uint8							unknown7160[72];
-		/*7196*/	uint32							tribute_time_remaining;	//in miliseconds
-		/*7200*/	uint32							showhelm;
-		/*7204*/	uint32							career_tribute_points;
-		/*7208*/	uint32							unknown7244;
-		/*7212*/	uint32							tribute_points;
-		/*7216*/	uint32							unknown7252;
-		/*7220*/	uint32							tribute_active;		//1=active
-		/*7224*/	Convert::Tribute_Struct			tributes[EmuConstants::TRIBUTE_SIZE];
-		/*7264*/	Convert::Disciplines_Struct		disciplines;
-		/*7664*/	uint32							recastTimers[MAX_RECAST_TYPES];	// Timers (GMT of last use)
-		/*7744*/	char							unknown7780[160];
-		/*7904*/	uint32							endurance;
-		/*7908*/	uint32							group_leadership_exp;	//0-1000
-		/*7912*/	uint32							raid_leadership_exp;	//0-2000
-		/*7916*/	uint32							group_leadership_points;
-		/*7920*/	uint32							raid_leadership_points;
-		/*7924*/	Convert::LeadershipAA_Struct	leader_abilities;
-		/*8052*/	uint8							unknown8088[132];
-		/*8184*/	uint32							air_remaining;
-		/*8188*/	uint32							PVPKills;
-		/*8192*/	uint32							PVPDeaths;
-		/*8196*/	uint32							PVPCurrentPoints;
-		/*8200*/	uint32							PVPCareerPoints;
-		/*8204*/	uint32							PVPBestKillStreak;
-		/*8208*/	uint32							PVPWorstDeathStreak;
-		/*8212*/	uint32							PVPCurrentKillStreak;
-		/*8216*/	Convert::PVPStatsEntry_Struct	PVPLastKill;
-		/*8304*/	Convert::PVPStatsEntry_Struct	PVPLastDeath;
-		/*8392*/	uint32							PVPNumberOfKillsInLast24Hours;
-		/*8396*/	Convert::PVPStatsEntry_Struct	PVPRecentKills[50];
-		/*12796*/	uint32							aapoints_spent;
-		/*12800*/	uint32							expAA;
-		/*12804*/	uint32							aapoints;			//avaliable, unspent
-		/*12808*/	uint8							unknown12844[36];
-		/*12844*/	Convert::Bandolier_Struct		bandoliers[EmuConstants::BANDOLIERS_COUNT];
-		/*14124*/	uint8							unknown14160[4506];
-		/*18630*/	Convert::SuspendedMinion_Struct	SuspendedMinion; // No longer in use
-		/*19240*/	uint32							timeentitledonaccount;
-		/*19244*/	Convert::PotionBelt_Struct		potionbelt;			//there should be 3 more of these
-		/*19532*/	uint8							unknown19568[8];
-		/*19540*/	uint32							currentRadCrystals; // Current count of radiant crystals
-		/*19544*/	uint32							careerRadCrystals;	// Total count of radiant crystals ever
-		/*19548*/	uint32							currentEbonCrystals;// Current count of ebon crystals
-		/*19552*/	uint32							careerEbonCrystals;	// Total count of ebon crystals ever
-		/*19556*/	uint8							groupAutoconsent;	// 0=off, 1=on
-		/*19557*/	uint8							raidAutoconsent;	// 0=off, 1=on
-		/*19558*/	uint8							guildAutoconsent;	// 0=off, 1=on
-		/*19559*/	uint8							unknown19595[5];	// ***Placeholder (6/29/2005)
-		/*19564*/	uint32							RestTimer;
-		/*19568*/
-	};
-	
-
-	namespace player_lootitem_temp
-	{
-		struct ServerLootItem_Struct_temp {
-			uint32	item_id;
-			int16	equipSlot;
-			uint8	charges;
-			uint16	lootslot;
-			uint32 aug1;
-			uint32 aug2;
-			uint32 aug3;
-			uint32 aug4;
-			uint32 aug5;
-			uint32 aug6;
-			uint8 attuned;
-		};
-	}
-
-	struct DBPlayerCorpse_Struct_temp {
-		uint32	crc;
-		bool	locked;
-		uint32	itemcount;
-		uint32	exp;
-		float	size;
-		uint8	level;
-		uint8	race;
-		uint8	gender;
-		uint8	class_;
-		uint8	deity;
-		uint8	texture;
-		uint8	helmtexture;
-		uint32	copper;
-		uint32	silver;
-		uint32	gold;
-		uint32	plat;
-		Color_Struct item_tint[9];
-		uint8 haircolor;
-		uint8 beardcolor;
-		uint8 eyecolor1;
-		uint8 eyecolor2;
-		uint8 hairstyle;
-		uint8 face;
-		uint8 beard;
-		uint32 drakkin_heritage;
-		uint32 drakkin_tattoo;
-		uint32 drakkin_details;
-		player_lootitem_temp::ServerLootItem_Struct_temp	items[0];
-	};
-
-	namespace classic_db_temp {
-		struct DBPlayerCorpse_Struct_temp {
-			uint32	crc;
-			bool	locked;
-			uint32	itemcount;
-			uint32	exp;
-			float	size;
-			uint8	level;
-			uint8	race;
-			uint8	gender;
-			uint8	class_;
-			uint8	deity;
-			uint8	texture;
-			uint8	helmtexture;
-			uint32	copper;
-			uint32	silver;
-			uint32	gold;
-			uint32	plat;
-			Color_Struct item_tint[9];
-			uint8 haircolor;
-			uint8 beardcolor;
-			uint8 eyecolor1;
-			uint8 eyecolor2;
-			uint8 hairstyle;
-			uint8 face;
-			uint8 beard;
-			player_lootitem_temp::ServerLootItem_Struct_temp	items[0];
-		};
-	}
-}
-
-#pragma pack()
 
 class Database : public DBcore {
 public:
@@ -485,164 +90,166 @@ public:
 	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
 
-
-	/*
-	* General Character Related Stuff
-	*/
-
 	/* Character Creation */
-	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
 
+	bool	AddToNameFilter(const char* name);
+	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
+	bool	DeleteCharacter(char* name);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename);
 	bool	MoveCharacterToZone(const char* charname, const char* zonename,uint32 zoneid);
 	bool	MoveCharacterToZone(uint32 iCharID, const char* iZonename);
-	bool	UpdateName(const char* oldname, const char* newname);
+	bool	ReserveName(uint32 account_id, char* name);
+	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
 	bool	SetHackerFlag(const char* accountname, const char* charactername, const char* hacked);
 	bool	SetMQDetectionFlag(const char* accountname, const char* charactername, const char* hacked, const char* zone);
-	bool	AddToNameFilter(const char* name);
-	bool	ReserveName(uint32 account_id, char* name);
-	bool	CreateCharacter(uint32 account_id, char* name, uint16 gender, uint16 race, uint16 class_, uint8 str, uint8 sta, uint8 cha, uint8 dex, uint8 int_, uint8 agi, uint8 wis, uint8 face);
 	bool	StoreCharacter(uint32 account_id, PlayerProfile_Struct* pp, Inventory* inv);
-	bool	DeleteCharacter(char* name);
+	bool	UpdateName(const char* oldname, const char* newname);
 
-	/*
+	/* General Information Queries */
-	* General Information Getting Queries
+
-	*/
+	bool	AddBannedIP(char* bannedIP, const char* notes); //Add IP address to the Banned_IPs table.
+	bool	AddGMIP(char* ip_address, char* name);
+	bool	CheckBannedIPs(const char* loginIP); //Check incoming connection against banned IP table.
+	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
 	bool	CheckNameFilter(const char* name, bool surname = false);
 	bool	CheckUsedName(const char* name);
+
 	uint32	GetAccountIDByChar(const char* charname, uint32* oCharID = 0);
 	uint32	GetAccountIDByChar(uint32 char_id);
 	uint32	GetAccountIDByName(const char* accname, int16* status = 0, uint32* lsid = 0);
+	uint32	GetCharacterID(const char *name);
+	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0, float* oX = 0, float* oY = 0, float* oZ = 0);
 	uint32	GetGuildIDByCharID(uint32 char_id);
+
 	void	GetAccountName(uint32 accountid, char* name, uint32* oLSAccountID = 0);
 	void	GetCharName(uint32 char_id, char* name);
-	uint32	GetCharacterInfo(const char* iName, uint32* oAccID = 0, uint32* oZoneID = 0, uint32* oInstanceID = 0,float* oX = 0, float* oY = 0, float* oZ = 0);
-	uint32	GetCharacterID(const char *name);
-	bool	CheckBannedIPs(const char* loginIP); //Lieka Edit: Check incomming connection against banned IP table.
-	bool	AddBannedIP(char* bannedIP, const char* notes); //Lieka Edit: Add IP address to the Banned_IPs table.
-	bool	CheckGMIPs(const char* loginIP, uint32 account_id);
-	bool	AddGMIP(char* ip_address, char* name);
 	void	LoginIP(uint32 AccountID, const char* LoginIP);
 
-	/*
+	/* Instancing */
-	* Instancing Stuff
+
-	*/
-	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
-	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
-	bool CharacterInInstanceGroup(uint16 instance_id, uint32 char_id);
-	void DeleteInstance(uint16 instance_id);
-	bool CheckInstanceExpired(uint16 instance_id);
-	uint32 ZoneIDFromInstanceID(uint16 instance_id);
-	uint32 VersionFromInstanceID(uint16 instance_id);
-	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
-	bool GetUnusedInstanceID(uint16 &instance_id);
-	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
-	void PurgeExpiredInstances();
 	bool AddClientToInstance(uint16 instance_id, uint32 char_id);
+	bool CharacterInInstanceGroup(uint16 instance_id, uint32 char_id);
+	bool CheckInstanceExists(uint16 instance_id);
+	bool CheckInstanceExpired(uint16 instance_id);
+	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
+	bool GetUnusedInstanceID(uint16 &instance_id);
+	bool GlobalInstance(uint16 instance_id);
 	bool RemoveClientFromInstance(uint16 instance_id, uint32 char_id);
 	bool RemoveClientsFromInstance(uint16 instance_id);
-	bool CheckInstanceExists(uint16 instance_id);
+	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
-	void BuryCorpsesInInstance(uint16 instance_id);
+	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
-	uint16 GetInstanceVersion(uint16 instance_id);
+
 	uint16 GetInstanceID(const char* zone, uint32 charid, int16 version);
 	uint16 GetInstanceID(uint32 zone, uint32 charid, int16 version);
-	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
+	uint16 GetInstanceVersion(uint16 instance_id);
+	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
+	uint32 VersionFromInstanceID(uint16 instance_id);
+	uint32 ZoneIDFromInstanceID(uint16 instance_id);
+
 	void AssignGroupToInstance(uint32 gid, uint32 instance_id);
 	void AssignRaidToInstance(uint32 rid, uint32 instance_id);
+	void BuryCorpsesInInstance(uint16 instance_id);
+	void DeleteInstance(uint16 instance_id);
 	void FlagInstanceByGroupLeader(uint32 zone, int16 version, uint32 charid, uint32 gid);
 	void FlagInstanceByRaidLeader(uint32 zone, int16 version, uint32 charid, uint32 rid);
+	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
+	void PurgeExpiredInstances();
 	void SetInstanceDuration(uint16 instance_id, uint32 new_duration);
-	bool GlobalInstance(uint16 instance_id);
 
-	/*
+	/* Adventure related. */
-	* Adventure related.
+
-	*/
 	void UpdateAdventureStatsEntry(uint32 char_id, uint8 theme, bool win);
 	bool GetAdventureStats(uint32 char_id, AdventureStats_Struct *as);
 
-	/*
+	/* Account Related */
-	* Account Related
+
-	*/
-	uint32	GetMiniLoginAccount(char* ip);
-	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
-	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
-	int16	CheckStatus(uint32 account_id);
-	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
 	bool	DeleteAccount(const char* name);
+	bool	GetLiveChar(uint32 account_id, char* cname);
 	bool	SetAccountStatus(const char* name, int16 status);
 	bool	SetLocalPassword(uint32 accid, const char* password);
+	bool	UpdateLiveChar(char* charname, uint32 lsaccount_id);
+
+	int16	CheckStatus(uint32 account_id);
+
+	uint32	CheckLogin(const char* name, const char* password, int16* oStatus = 0);
+	uint32	CreateAccount(const char* name, const char* password, int16 status, uint32 lsaccount_id = 0);
 	uint32	GetAccountIDFromLSID(uint32 iLSID, char* oAccountName = 0, int16* oStatus = 0);
-	bool	UpdateLiveChar(char* charname,uint32 lsaccount_id);
+	uint32	GetMiniLoginAccount(char* ip);
-	bool	GetLiveChar(uint32 account_id, char* cname);
 	uint8	GetAgreementFlag(uint32 acctid);
+
+	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
 
-	/*
-	* Groups
-	*/
-	uint32	GetGroupID(const char* name);
-	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
-	void	ClearGroup(uint32 gid = 0);
-	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
 
-	void	SetGroupLeaderName(uint32 gid, const char* name);
+	/* Groups */
-	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
-						char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
-	void	ClearGroupLeader(uint32 gid = 0);
 	
+	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
+	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
+	
+	uint32	GetGroupID(const char* name);
+	
+	void	ClearGroup(uint32 gid = 0);
+	void	ClearGroupLeader(uint32 gid = 0);
+	void	SetGroupID(const char* name, uint32 id, uint32 charid, uint32 ismerc = false);
+	void	SetGroupLeaderName(uint32 gid, const char* name);
+
+	/* Raids */
+
+	const char *GetRaidLeaderName(uint32 rid);
+
+	uint32	GetRaidID(const char* name);
 
-	/*
-	* Raids
-	*/
 	void	ClearRaid(uint32 rid = 0);
 	void	ClearRaidDetails(uint32 rid = 0);
-	uint32	GetRaidID(const char* name);
-	const char *GetRaidLeaderName(uint32 rid);
-	void	GetGroupLeadershipInfo(uint32 gid, uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
-			char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
-	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
-			RaidLeadershipAA_Struct* RLAA = nullptr);
-	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
 	void	ClearRaidLeader(uint32 gid = 0xFFFFFFFF, uint32 rid = 0);
+	void	GetGroupLeadershipInfo(uint32 gid, uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, char *mentoree = nullptr, int *mentor_percent = nullptr, GroupLeadershipAA_Struct* GLAA = nullptr);
+	void	GetRaidLeadershipInfo(uint32 rid, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr, RaidLeadershipAA_Struct* RLAA = nullptr);
+	void	SetRaidGroupLeaderInfo(uint32 gid, uint32 rid);
+
+	/* Database Conversions 'database_conversions.cpp' */
 
-	/* Database Conversions*/
 	bool	CheckDatabaseConversions();
-	bool	CheckDatabaseConvertPPDeblob();
-	bool	CheckDatabaseConvertCorpseDeblob();
 	bool	CheckDatabaseConvertBotsPostPPDeblob();
+	bool	CheckDatabaseConvertCorpseDeblob();
+	bool	CheckDatabaseConvertPPDeblob();
+
+	/* Database Variables */
 
-	/*
-	* Database Variables
-	*/
 	bool	GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
 	bool	SetVariable(const char* varname, const char* varvalue);
 	bool	LoadVariables();
 	uint32	LoadVariables_MQ(char** query);
 	bool	LoadVariables_result(MySQLRequestResult results);
 
-	/*
+	/* General Queries */
-	* General Queries
+
-	*/
-	bool	LoadZoneNames();
-	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
-	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
-	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
-	uint32	GetZoneID(const char* zonename);
-	uint8	GetPEQZone(uint32 zoneID, uint32 version);
-	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
-	uint8	GetServerType();
 	bool	GetSafePoints(const char* short_name, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr);
 	bool	GetSafePoints(uint32 zoneID, uint32 version, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, int16* minstatus = 0, uint8* minlevel = 0, char *flag_needed = nullptr) { return GetSafePoints(GetZoneName(zoneID), version, safe_x, safe_y, safe_z, minstatus, minlevel, flag_needed); }
-	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
+	bool	GetZoneGraveyard(const uint32 graveyard_id, uint32* graveyard_zoneid = 0, float* graveyard_x = 0, float* graveyard_y = 0, float* graveyard_z = 0, float* graveyard_heading = 0);
-	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	bool	GetZoneLongName(const char* short_name, char** long_name, char* file_name = 0, float* safe_x = 0, float* safe_y = 0, float* safe_z = 0, uint32* graveyard_id = 0, uint32* maxclients = 0);
 	bool	LoadPTimers(uint32 charid, PTimerList &into);
-	void	ClearPTimers(uint32 charid);
+	bool	LoadZoneNames();
-	void	ClearMerchantTemp();
+
-	void	SetLFP(uint32 CharID, bool LFP);
+	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
-	void	SetLFG(uint32 CharID, bool LFG);
+
-	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
+	uint32	GetZoneGraveyardID(uint32 zone_id, uint32 version);
-	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
+	uint32	GetZoneID(const char* zonename);
+
+	uint8	GetPEQZone(uint32 zoneID, uint32 version);
+	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	uint8	GetServerType();
+	uint8	GetSkillCap(uint8 skillid, uint8 in_race, uint8 in_class, uint16 in_level);
+
 	void	AddReport(std::string who, std::string against, std::string lines);
+	void	ClearMerchantTemp();
+	void	ClearPTimers(uint32 charid);
+	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
+	void	SetLFG(uint32 CharID, bool LFG);
+	void	SetLFP(uint32 CharID, bool LFP);
+	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
+
+	/* EQEmuLogSys */
+	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
 
 private:
 	void DBInitVars();
@@ -654,17 +261,11 @@ private:
 	VarCache_Struct**	varcache_array;
 	uint32				varcache_lastupdate;
 
-
+	/* Groups, utility methods. */
-	/*
-	* Groups, utility methods.
-	*/
 	void    ClearAllGroupLeaders();
 	void    ClearAllGroups();
 
-
+	/* Raid, utility methods. */
-	/*
-	* Raid, utility methods.
-	*/
 	void ClearAllRaids();
 	void ClearAllRaidDetails();
 	void ClearAllRaidLeaders();

common/database_instances.cpp

@@ -0,0 +1,562 @@
+/*	EQEMu: Everquest Server Emulator
+Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 of the License.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY except by those people which sell it, which
+are required to give you total support for your newly bought product;
+without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "../common/global_define.h"
+#include "../common/rulesys.h"
+#include "../common/string_util.h"
+#include "../common/timer.h"
+
+#include "database.h"
+
+#include <iomanip>
+#include <iostream>
+
+// Disgrace: for windows compile
+#ifdef _WINDOWS
+#include <windows.h>
+#define snprintf	_snprintf
+#define strncasecmp	_strnicmp
+#define strcasecmp	_stricmp
+#else
+#include "unix.h"
+#include <netinet/in.h>
+#include <sys/time.h>
+#endif
+
+bool Database::AddClientToInstance(uint16 instance_id, uint32 char_id)
+{
+	std::string query = StringFormat(
+		"REPLACE INTO `instance_list_player` (id, charid) "
+		"VALUES "
+		"(%lu, %lu)",
+		(unsigned long)instance_id,
+		(unsigned long)char_id
+		);
+	auto results = QueryDatabase(query);
+	return results.Success();
+}
+
+bool Database::CharacterInInstanceGroup(uint16 instance_id, uint32 char_id)
+{
+
+	std::string query = StringFormat("SELECT charid FROM instance_list_player where id=%u AND charid=%u", instance_id, char_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() != 1)
+		return false;
+
+	return true;
+}
+
+bool Database::CheckInstanceExists(uint16 instance_id) {
+	std::string query = StringFormat(
+		"SELECT "
+		"`id`  "
+		"FROM  "
+		"`instance_list`  "
+		"WHERE  "
+		"`id` = %u",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	return true;
+}
+
+bool Database::CheckInstanceExpired(uint16 instance_id)
+{
+
+	int32 start_time = 0;
+	int32 duration = 0;
+	uint32 never_expires = 0;
+
+	std::string query = StringFormat("SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return true;
+
+	if (results.RowCount() == 0)
+		return true;
+
+	auto row = results.begin();
+
+	start_time = atoi(row[0]);
+	duration = atoi(row[1]);
+	never_expires = atoi(row[2]);
+
+	if (never_expires == 1)
+		return false;
+
+	timeval tv;
+	gettimeofday(&tv, nullptr);
+
+	if ((start_time + duration) <= tv.tv_sec)
+		return true;
+
+	return false;
+}
+
+bool Database::CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration)
+{
+	std::string query = StringFormat("INSERT INTO instance_list (id, zone, version, start_time, duration)"
+		" values(%lu, %lu, %lu, UNIX_TIMESTAMP(), %lu)",
+		(unsigned long)instance_id, (unsigned long)zone_id, (unsigned long)version, (unsigned long)duration);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+bool Database::GetUnusedInstanceID(uint16 &instance_id)
+{
+	uint32 count = RuleI(Zone, ReservedInstances);
+	uint32 max = 65535;
+
+	std::string query = StringFormat("SELECT IFNULL(MAX(id),%u)+1 FROM instance_list  WHERE id > %u", count, count);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	auto row = results.begin();
+
+	if (atoi(row[0]) <= max)
+	{
+		instance_id = atoi(row[0]);
+		return true;
+	}
+
+	query = StringFormat("SELECT id FROM instance_list where id > %u ORDER BY id", count);
+	results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		instance_id = 0;
+		return false;
+	}
+
+	count++;
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		if (count < atoi(row[0]))
+		{
+			instance_id = count;
+			return true;
+		}
+
+		if (count > max)
+		{
+			instance_id = 0;
+			return false;
+		}
+
+		count++;
+	}
+
+	instance_id = count;
+	return true;
+}
+
+bool Database::GlobalInstance(uint16 instance_id)
+{
+	std::string query = StringFormat(
+		"SELECT "
+		"is_global "
+		"FROM "
+		"instance_list "
+		"WHERE "
+		"id = %u "
+		"LIMIT 1 ",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	auto row = results.begin();
+
+	return (atoi(row[0]) == 1) ? true : false;
+}
+
+bool Database::RemoveClientFromInstance(uint16 instance_id, uint32 char_id)
+{
+	std::string query = StringFormat("DELETE FROM instance_list_player WHERE id=%lu AND charid=%lu",
+		(unsigned long)instance_id, (unsigned long)char_id);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+
+bool Database::RemoveClientsFromInstance(uint16 instance_id)
+{
+	std::string query = StringFormat("DELETE FROM instance_list_player WHERE id=%lu", (unsigned long)instance_id);
+	auto results = QueryDatabase(query);
+
+	return results.Success();
+}
+
+bool Database::VerifyInstanceAlive(uint16 instance_id, uint32 char_id)
+{
+	//we are not saved to this instance so set our instance to 0
+	if (!GlobalInstance(instance_id) && !CharacterInInstanceGroup(instance_id, char_id))
+		return false;
+
+	if (CheckInstanceExpired(instance_id))
+	{
+		DeleteInstance(instance_id);
+		return false;
+	}
+
+	return true;
+}
+
+bool Database::VerifyZoneInstance(uint32 zone_id, uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT id FROM instance_list where id=%u AND zone=%u", instance_id, zone_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return false;
+
+	if (results.RowCount() == 0)
+		return false;
+
+	return true;
+}
+
+uint16 Database::GetInstanceID(const char* zone, uint32 character_id, int16 version) {
+
+	std::string query = StringFormat(
+		"SELECT "
+		"instance_list.id "
+		"FROM "
+		"instance_list, "
+		"instance_list_player "
+		"WHERE "
+		"instance_list.zone = %u "
+		"AND instance_list.version = %u "
+		"AND instance_list.id = instance_list_player.id "
+		"AND instance_list_player.charid = %u "
+		"LIMIT 1 ",
+		GetZoneID(zone),
+		version,
+		character_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+	return atoi(row[0]);
+}
+
+uint16 Database::GetInstanceID(uint32 zone, uint32 character_id, int16 version)
+{
+	if (!zone)
+		return 0;
+
+	std::string query = StringFormat(
+		"SELECT "
+		"instance_list.id "
+		"FROM "
+		"instance_list, "
+		"instance_list_player "
+		"WHERE "
+		"instance_list.zone = %u "
+		"AND instance_list.version = %u "
+		"AND instance_list.id = instance_list_player.id "
+		"AND instance_list_player.charid = %u "
+		"LIMIT 1; ",
+		zone,
+		version,
+		character_id
+		);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+uint16 Database::GetInstanceVersion(uint16 instance_id) {
+	if (instance_id == 0)
+		return 0;
+
+	std::string query = StringFormat("SELECT version FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+	return atoi(row[0]);
+}
+
+uint32 Database::GetTimeRemainingInstance(uint16 instance_id, bool &is_perma)
+{
+	uint32 start_time = 0;
+	uint32 duration = 0;
+	uint32 never_expires = 0;
+
+	std::string query = StringFormat("SELECT start_time, duration, never_expires FROM instance_list WHERE id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+	{
+		is_perma = false;
+		return 0;
+	}
+
+	if (results.RowCount() == 0)
+	{
+		is_perma = false;
+		return 0;
+	}
+
+	auto row = results.begin();
+
+	start_time = atoi(row[0]);
+	duration = atoi(row[1]);
+	never_expires = atoi(row[2]);
+
+	if (never_expires == 1)
+	{
+		is_perma = true;
+		return 0;
+	}
+
+	is_perma = false;
+
+	timeval tv;
+	gettimeofday(&tv, nullptr);
+	return ((start_time + duration) - tv.tv_sec);
+}
+
+uint32 Database::VersionFromInstanceID(uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT version FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+uint32 Database::ZoneIDFromInstanceID(uint16 instance_id)
+{
+
+	std::string query = StringFormat("SELECT zone FROM instance_list where id=%u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return 0;
+
+	if (results.RowCount() == 0)
+		return 0;
+
+	auto row = results.begin();
+
+	return atoi(row[0]);
+}
+
+void Database::AssignGroupToInstance(uint32 group_id, uint32 instance_id)
+{
+
+	uint32 zone_id = ZoneIDFromInstanceID(instance_id);
+	uint16 version = VersionFromInstanceID(instance_id);
+
+	std::string query = StringFormat("SELECT `charid` FROM `group_id` WHERE `groupid` = %u", group_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		uint32 charid = atoi(row[0]);
+		if (GetInstanceID(zone_id, charid, version) == 0)
+			AddClientToInstance(instance_id, charid);
+	}
+}
+
+void Database::AssignRaidToInstance(uint32 raid_id, uint32 instance_id)
+{
+
+	uint32 zone_id = ZoneIDFromInstanceID(instance_id);
+	uint16 version = VersionFromInstanceID(instance_id);
+
+	std::string query = StringFormat("SELECT `charid` FROM `raid_members` WHERE `raidid` = %u", raid_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+	{
+		uint32 charid = atoi(row[0]);
+		if (GetInstanceID(zone_id, charid, version) == 0)
+			AddClientToInstance(instance_id, charid);
+	}
+}
+
+void Database::BuryCorpsesInInstance(uint16 instance_id) {
+	std::string query = StringFormat(
+		"UPDATE `character_corpses` "
+		"SET `is_buried` = 1, "
+		"`instance_id` = 0 "
+		"WHERE "
+		"`instance_id` = %u ",
+		instance_id
+		);
+	auto results = QueryDatabase(query);
+}
+
+void Database::DeleteInstance(uint16 instance_id)
+{
+
+	std::string query = StringFormat("DELETE FROM instance_list WHERE id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM instance_list_player WHERE id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM respawn_times WHERE instance_id=%u", instance_id);
+	QueryDatabase(query);
+
+	query = StringFormat("DELETE FROM spawn_condition_values WHERE instance_id=%u", instance_id);
+	QueryDatabase(query);
+
+	BuryCorpsesInInstance(instance_id);
+}
+
+void Database::FlagInstanceByGroupLeader(uint32 zone, int16 version, uint32 charid, uint32 gid)
+{
+	uint16 id = GetInstanceID(zone, charid, version);
+	if (id != 0)
+		return;
+
+	char ln[128];
+	memset(ln, 0, 128);
+	strcpy(ln, GetGroupLeadershipInfo(gid, ln));
+	uint32 l_charid = GetCharacterID((const char*)ln);
+	uint16 l_id = GetInstanceID(zone, l_charid, version);
+
+	if (l_id == 0)
+		return;
+
+	AddClientToInstance(l_id, charid);
+}
+
+void Database::FlagInstanceByRaidLeader(uint32 zone, int16 version, uint32 charid, uint32 rid)
+{
+	uint16 id = GetInstanceID(zone, charid, version);
+	if (id != 0)
+		return;
+
+	uint32 l_charid = GetCharacterID(GetRaidLeaderName(rid));
+	uint16 l_id = GetInstanceID(zone, l_charid, version);
+
+	if (l_id == 0)
+		return;
+
+	AddClientToInstance(l_id, charid);
+}
+
+void Database::GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list) {
+
+	std::string query = StringFormat("SELECT `charid` FROM `instance_list_player` WHERE `id` = %u", instance_id);
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+		charid_list.push_back(atoi(row[0]));
+}
+
+void Database::PurgeExpiredInstances()
+{
+	std::string query("SELECT id FROM instance_list where (start_time+duration) <= UNIX_TIMESTAMP() and never_expires = 0");
+	auto results = QueryDatabase(query);
+
+	if (!results.Success())
+		return;
+
+	if (results.RowCount() == 0)
+		return;
+
+	for (auto row = results.begin(); row != results.end(); ++row)
+		DeleteInstance(atoi(row[0]));
+}
+
+void Database::SetInstanceDuration(uint16 instance_id, uint32 new_duration)
+{
+	std::string query = StringFormat("UPDATE `instance_list` SET start_time=UNIX_TIMESTAMP(), "
+		"duration=%u WHERE id=%u", new_duration, instance_id);
+	auto results = QueryDatabase(query);
+}

common/dbcore.cpp

@@ -3,6 +3,7 @@
 #endif
 
 #include "../common/misc_functions.h"
+#include "../common/eqemu_logsys.h"
 
 #include "dbcore.h"
 
@@ -101,25 +102,16 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
 
 			snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
-			std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
-
 			return MySQLRequestResult(nullptr, 0, 0, 0, 0, (uint32)mysql_errno(&mysql), errorBuffer);
 		}
 
 		char *errorBuffer = new char[MYSQL_ERRMSG_SIZE];
 		snprintf(errorBuffer, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
 
-#ifdef _EQDEBUG
-		std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
-#endif
-
 		/* Implement Logging at the Root */
 		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			std::cout << "\n[MYSQL ERR] " << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << " [Query]: \n" << query << "\n" << std::endl;
+			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
-			/* Write to log file */
+				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
-			std::ofstream log("eqemu_query_error_log.txt", std::ios_base::app | std::ios_base::out);
-			log << "[MYSQL ERR] " << mysql_error(&mysql) << "\n" << query << "\n";
-			log.close();
 		}
 
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
@@ -134,21 +126,9 @@ MySQLRequestResult DBcore::QueryDatabase(const char* query, uint32 querylen, boo
         rowCount = (uint32)mysql_num_rows(res);
 
 	MySQLRequestResult requestResult(res, (uint32)mysql_affected_rows(&mysql), rowCount, (uint32)mysql_field_count(&mysql), (uint32)mysql_insert_id(&mysql));
-
+	
-#if DEBUG_MYSQL_QUERIES >= 1
+	if (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
-	if (requestResult.Success())
+		Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u rows returned)", query, rowCount, requestResult.RowCount());
-	{
-		std::cout << "query successful";
-		if (requestResult.Result())
-			std::cout << ", " << (int) mysql_num_rows(requestResult.Result()) << " rows returned";
-
-		std::cout << ", " << requestResult.RowCount() << " rows affected";
-		std::cout<< std::endl;
-	}
-	else {
-		std::cout << "QUERY: query FAILED" << std::endl;
-	}
-#endif
 
 	return requestResult;
 }

common/dbmemshare.cpp

@@ -1,126 +0,0 @@
-// Doors
-#ifdef SHAREMEM
-int32 Database::GetDoorsCount(uint32* oMaxID) {
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	query = new char[256];
-	strcpy(query, "SELECT MAX(id), count(*) FROM doors");
-	if (RunQuery(query, strlen(query), errbuf, &result)) {
-		safe_delete(query);
-		row = mysql_fetch_row(result);
-		if (row && row[1]) {
-			int32 ret = atoi(row[1]);
-			if (oMaxID) {
-				if (row[0])
-					*oMaxID = atoi(row[0]);
-				else
-					*oMaxID = 0;
-			}
-			mysql_free_result(result);
-			return ret;
-		}
-	}
-	else {
-		cerr << "Error in GetDoorsCount query '" << query << "' " << errbuf << endl;
-		delete[] query;
-		return -1;
-	}
-
-	return -1;
-}
-
-extern "C" bool extDBLoadDoors(uint32 iDoorCount, uint32 iMaxDoorID) { return database.DBLoadDoors(iDoorCount, iMaxDoorID); }
-const Door* Database::GetDoor(uint8 door_id, const char* zone_name) {
-	for(uint32 i=0; i<max_door_type; i++) {
-		const Door* door = GetDoorDBID(i);
-		if(door && door->door_id == door_id && strcasecmp(door->zone_name, zone_name) == 0)
-			return door;
-	}
-	return 0;
-}
-
-const Door* Database::GetDoorDBID(uint32 db_id) {
-	return EMuShareMemDLL.Doors.GetDoor(db_id);
-}
-
-bool Database::LoadDoors() {
-	if (!EMuShareMemDLL.Load())
-		return false;
-	int32 tmp_max_door_type = -1;
-	uint32 tmp = 0;
-	tmp_max_door_type = GetDoorsCount(&tmp);
-	if (tmp_max_door_type < 0) {
-		cout << "Error: Database::LoadDoors-ShareMem: GetDoorsCount() returned < 0" << endl;
-		return false;
-	}
-	max_door_type = tmp_max_door_type;
-	bool ret = EMuShareMemDLL.Doors.DLLLoadDoors(&extDBLoadDoors, sizeof(Door), max_door_type, tmp);
-	return ret;
-}
-
-bool Database::DBLoadDoors(uint32 iDoorCount, uint32 iMaxDoorID) {
-	cout << "Loading Doors from database..." << endl;
-	char errbuf[MYSQL_ERRMSG_SIZE];
-	char *query = 0;
-	MYSQL_RES *result;
-	MYSQL_ROW row;
-	query = new char[256];
-	strcpy(query, "SELECT MAX(id), Count(*) FROM doors");
-	if (RunQuery(query, strlen(query), errbuf, &result))
-	{
-		safe_delete(query);
-		row = mysql_fetch_row(result);
-		if (row && row[0]) {
-			if (atoi(row[0]) > iMaxDoorID) {
-				cout << "Error: Insufficient shared memory to load doors." << endl;
-				cout << "Max(id): " << atoi(row[0]) << ", iMaxDoorID: " << iMaxDoorID << endl;
-				cout << "Fix this by increasing the MMF_MAX_Door_ID define statement" << endl;
-				return false;
-			}
-			if (atoi(row[1]) != iDoorCount) {
-				cout << "Error: Insufficient shared memory to load doors." << endl;
-				cout << "Count(*): " << atoi(row[1]) << ", iDoorCount: " << iDoorCount << endl;
-				return false;
-			}
-			max_door_type = atoi(row[0]);
-			mysql_free_result(result);
-			Door tmpDoor;
-				MakeAnyLenString(&query, "SELECT id,doorid,zone,name,pos_x,pos_y,pos_z,heading,opentype,guild,lockpick,keyitem,triggerdoor,triggertype from doors");//WHERE zone='%s'", zone_name
-				if (RunQuery(query, strlen(query), errbuf, &result))
-				{
-					safe_delete(query);
-					while((row = mysql_fetch_row(result))) {
-						memset(&tmpDoor, 0, sizeof(Door));
-						tmpDoor.db_id = atoi(row[0]);
-						tmpDoor.door_id = atoi(row[1]);
-						strn0cpy(tmpDoor.zone_name,row[2],32);
-						strn0cpy(tmpDoor.door_name,row[3],32);
-						tmpDoor.pos_x = (float)atof(row[4]);
-						tmpDoor.pos_y = (float)atof(row[5]);
-						tmpDoor.pos_z = (float)atof(row[6]);
-						tmpDoor.heading = atoi(row[7]);
-						tmpDoor.opentype = atoi(row[8]);
-						tmpDoor.guild_id = atoi(row[9]);
-						tmpDoor.lockpick = atoi(row[10]);
-						tmpDoor.keyitem = atoi(row[11]);
-						tmpDoor.trigger_door = atoi(row[12]);
-						tmpDoor.trigger_type = atoi(row[13]);
-						EMuShareMemDLL.Doors.cbAddDoor(tmpDoor.db_id, &tmpDoor);
-						Sleep(0);
-					}
-					mysql_free_result(result);
-				}
-				else
-				{
-					cerr << "Error in DBLoadDoors query '" << query << "' " << errbuf << endl;
-					delete[] query;
-					return false;
-				}
-			}
-		}
-	return true;
-}
-#endif
-

common/debug.cpp

@@ -1,454 +0,0 @@
-#include <iostream>
-#include <string>
-
-#ifdef _WINDOWS
-	#include <process.h>
-
-	#define snprintf	_snprintf
-	#define vsnprintf	_vsnprintf
-	#define strncasecmp	_strnicmp
-	#define strcasecmp	_stricmp
-
-#else
-
-	#include <sys/types.h>
-	#include <unistd.h>
-
-#endif
-
-#include "debug.h"
-#include "misc_functions.h"
-#include "platform.h"
-
-#ifndef va_copy
-	#define va_copy(d,s) ((d) = (s))
-#endif
-
-static volatile bool logFileValid = false;
-static EQEMuLog realLogFile;
-EQEMuLog *LogFile = &realLogFile;
-
-static const char* FileNames[EQEMuLog::MaxLogID] = { "logs/eqemu", "logs/eqemu", "logs/eqemu_error", "logs/eqemu_debug", "logs/eqemu_quest", "logs/eqemu_commands", "logs/crash" };
-static const char* LogNames[EQEMuLog::MaxLogID] = { "Status", "Normal", "Error", "Debug", "Quest", "Command", "Crash" };
-
-EQEMuLog::EQEMuLog()
-{
-	for (int i = 0; i < MaxLogID; i++) {
-		fp[i] = 0;
-		logCallbackFmt[i] = nullptr;
-		logCallbackBuf[i] = nullptr;
-		logCallbackPva[i] = nullptr;
-	}
-	pLogStatus[EQEMuLog::LogIDs::Status] = LOG_LEVEL_STATUS;
-	pLogStatus[EQEMuLog::LogIDs::Normal] = LOG_LEVEL_NORMAL;
-	pLogStatus[EQEMuLog::LogIDs::Error] = LOG_LEVEL_ERROR;
-	pLogStatus[EQEMuLog::LogIDs::Debug] = LOG_LEVEL_DEBUG;
-	pLogStatus[EQEMuLog::LogIDs::Quest] = LOG_LEVEL_QUEST;
-	pLogStatus[EQEMuLog::LogIDs::Commands] = LOG_LEVEL_COMMANDS;
-	pLogStatus[EQEMuLog::LogIDs::Crash] = LOG_LEVEL_CRASH;
-	logFileValid = true;
-}
-
-EQEMuLog::~EQEMuLog()
-{
-	logFileValid = false;
-	for (int i = 0; i < MaxLogID; i++) {
-		LockMutex lock(&MLog[i]);	//to prevent termination race
-		if (fp[i]) {
-			fclose(fp[i]);
-		}
-	}
-}
-
-bool EQEMuLog::open(LogIDs id)
-{
-	if (!logFileValid) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	LockMutex lock(&MOpen);
-	if (pLogStatus[id] & 4) {
-		return false;
-	}
-	if (fp[id]) {
-		//cerr<<"Warning: LogFile already open"<<endl;
-		return true;
-	}
-	char exename[200] = "";
-	const EQEmuExePlatform &platform = GetExecutablePlatform();
-	if (platform == ExePlatformWorld) {
-		snprintf(exename, sizeof(exename), "_world");
-	} else if (platform == ExePlatformZone) {
-		snprintf(exename, sizeof(exename), "_zone");
-	} else if (platform == ExePlatformLaunch) {
-		snprintf(exename, sizeof(exename), "_launch");
-	} else if (platform == ExePlatformUCS) {
-		snprintf(exename, sizeof(exename), "_ucs");
-	} else if (platform == ExePlatformQueryServ) {
-		snprintf(exename, sizeof(exename), "_queryserv");
-	} else if (platform == ExePlatformSharedMemory) {
-		snprintf(exename, sizeof(exename), "_shared_memory");
-	} else if (platform == ExePlatformClientImport) {
-		snprintf(exename, sizeof(exename), "_import");
-	} else if (platform == ExePlatformClientExport) {
-		snprintf(exename, sizeof(exename), "_export");
-	}
-	char filename[200];
-	#ifndef NO_PIDLOG
-	snprintf(filename, sizeof(filename), "%s%s_%04i.log", FileNames[id], exename, getpid());
-	#else
-	snprintf(filename, sizeof(filename), "%s%s.log", FileNames[id], exename);
-	#endif
-	fp[id] = fopen(filename, "a");
-	if (!fp[id]) {
-		std::cerr << "Failed to open log file: " << filename << std::endl;
-		pLogStatus[id] |= 4; // set file state to error
-		return false;
-	}
-	fputs("---------------------------------------------\n", fp[id]);
-	write(id, "Starting Log: %s", filename);
-	return true;
-}
-
-bool EQEMuLog::write(LogIDs id, const char *fmt, ...)
-{
-	if (!logFileValid) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	bool dofile = false;
-	if (pLogStatus[id] & 1) {
-		dofile = open(id);
-	}
-	if (!(dofile || pLogStatus[id] & 2)) {
-		return false;
-	}
-	LockMutex lock(&MLog[id]);
-	if (!logFileValid) {
-		return false;    //check again for threading race reasons (to avoid two mutexes)
-	}
-	time_t aclock;
-	struct tm *newtime;
-	time( &aclock ); /* Get time in seconds */
-	newtime = localtime( &aclock ); /* Convert time to struct */
-	if (dofile)
-	#ifndef NO_PIDLOG
-		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
-	#else
-		fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
-	#endif
-	va_list argptr, tmpargptr;
-	va_start(argptr, fmt);
-	if (dofile) {
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if (logCallbackFmt[id]) {
-		msgCallbackFmt p = logCallbackFmt[id];
-		va_copy(tmpargptr, argptr);
-		p(id, fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "[%s] ", LogNames[id]);
-			vfprintf( stderr, fmt, argptr );
-		} else {
-			fprintf(stdout, "[%s] ", LogNames[id]);
-			vfprintf( stdout, fmt, argptr );
-		}
-	}
-	va_end(argptr);
-	if (dofile) {
-		fprintf(fp[id], "\n");
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "\n");
-			fflush(stderr);
-		} else {
-			fprintf(stdout, "\n");
-			fflush(stdout);
-		}
-	}
-	if (dofile) {
-		fflush(fp[id]);
-	}
-	return true;
-}
-
-//write with Prefix and a VA_list
-bool EQEMuLog::writePVA(LogIDs id, const char *prefix, const char *fmt, va_list argptr)
-{
-	if (!logFileValid) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	bool dofile = false;
-	if (pLogStatus[id] & 1) {
-		dofile = open(id);
-	}
-	if (!(dofile || pLogStatus[id] & 2)) {
-		return false;
-	}
-	LockMutex lock(&MLog[id]);
-	if (!logFileValid) {
-		return false;    //check again for threading race reasons (to avoid two mutexes)
-	}
-	time_t aclock;
-	struct tm *newtime;
-	time( &aclock ); /* Get time in seconds */
-	newtime = localtime( &aclock ); /* Convert time to struct */
-	va_list tmpargptr;
-	if (dofile) {
-		#ifndef NO_PIDLOG
-		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] %s", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
-		#else
-		fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] %s", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec, prefix);
-		#endif
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if (logCallbackPva[id]) {
-		msgCallbackPva p = logCallbackPva[id];
-		va_copy(tmpargptr, argptr);
-		p(id, prefix, fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "[%s] %s", LogNames[id], prefix);
-			vfprintf( stderr, fmt, argptr );
-		} else {
-			fprintf(stdout, "[%s] %s", LogNames[id], prefix);
-			vfprintf( stdout, fmt, argptr );
-		}
-	}
-	va_end(argptr);
-	if (dofile) {
-		fprintf(fp[id], "\n");
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "\n");
-		} else {
-			fprintf(stdout, "\n");
-		}
-	}
-	if (dofile) {
-		fflush(fp[id]);
-	}
-	return true;
-}
-
-bool EQEMuLog::writebuf(LogIDs id, const char *buf, uint8 size, uint32 count)
-{
-	if (!logFileValid) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	bool dofile = false;
-	if (pLogStatus[id] & 1) {
-		dofile = open(id);
-	}
-	if (!(dofile || pLogStatus[id] & 2)) {
-		return false;
-	}
-	LockMutex lock(&MLog[id]);
-	if (!logFileValid) {
-		return false;    //check again for threading race reasons (to avoid two mutexes)
-	}
-	time_t aclock;
-	struct tm *newtime;
-	time( &aclock ); /* Get time in seconds */
-	newtime = localtime( &aclock ); /* Convert time to struct */
-	if (dofile)
-	#ifndef NO_PIDLOG
-		fprintf(fp[id], "[%02d.%02d. - %02d:%02d:%02d] ", newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
-	#else
-		fprintf(fp[id], "%04i [%02d.%02d. - %02d:%02d:%02d] ", getpid(), newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
-	#endif
-	if (dofile) {
-		fwrite(buf, size, count, fp[id]);
-		fprintf(fp[id], "\n");
-	}
-	if (logCallbackBuf[id]) {
-		msgCallbackBuf p = logCallbackBuf[id];
-		p(id, buf, size, count);
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			fprintf(stderr, "[%s] ", LogNames[id]);
-			fwrite(buf, size, count, stderr);
-			fprintf(stderr, "\n");
-		} else {
-			fprintf(stdout, "[%s] ", LogNames[id]);
-			fwrite(buf, size, count, stdout);
-			fprintf(stdout, "\n");
-		}
-	}
-	if (dofile) {
-		fflush(fp[id]);
-	}
-	return true;
-}
-
-bool EQEMuLog::writeNTS(LogIDs id, bool dofile, const char *fmt, ...)
-{
-	va_list argptr, tmpargptr;
-	va_start(argptr, fmt);
-	if (dofile) {
-		va_copy(tmpargptr, argptr);
-		vfprintf( fp[id], fmt, tmpargptr );
-	}
-	if (pLogStatus[id] & 2) {
-		if (pLogStatus[id] & 8) {
-			vfprintf( stderr, fmt, argptr );
-		} else {
-			vfprintf( stdout, fmt, argptr );
-		}
-	}
-	va_end(argptr);
-	return true;
-};
-
-bool EQEMuLog::Dump(LogIDs id, uint8* data, uint32 size, uint32 cols, uint32 skip)
-{
-	if (!logFileValid) {
-		#if EQDEBUG >= 10
-		std::cerr << "Error: Dump() from null pointer" << std::endl;
-		#endif
-		return false;
-	}
-	if (size == 0) {
-		return true;
-	}
-	if (!LogFile) {
-		return false;
-	}
-	if (id >= MaxLogID) {
-		return false;
-	}
-	bool dofile = false;
-	if (pLogStatus[id] & 1) {
-		dofile = open(id);
-	}
-	if (!(dofile || pLogStatus[id] & 2)) {
-		return false;
-	}
-	LockMutex lock(&MLog[id]);
-	if (!logFileValid) {
-		return false;    //check again for threading race reasons (to avoid two mutexes)
-	}
-	write(id, "Dumping Packet: %i", size);
-	// Output as HEX
-	int beginningOfLineOffset = 0;
-	uint32 indexInData;
-	std::string asciiOutput;
-	for (indexInData = skip; indexInData < size; indexInData++) {
-		if ((indexInData - skip) % cols == 0) {
-			if (indexInData != skip) {
-				writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
-			}
-			writeNTS(id, dofile, "%4i: ", indexInData - skip);
-			asciiOutput.clear();
-			beginningOfLineOffset = 0;
-		} else if ((indexInData - skip) % (cols / 2) == 0) {
-			writeNTS(id, dofile, "- ");
-		}
-		writeNTS(id, dofile, "%02X ", (unsigned char)data[indexInData]);
-		if (data[indexInData] >= 32 && data[indexInData] < 127) {
-			// According to http://msdn.microsoft.com/en-us/library/vstudio/ee404875(v=vs.100).aspx
-			// Visual Studio 2010 doesn't have std::to_string(int) but it does have the long long
-			// version.
-			asciiOutput.append(std::to_string((long long)data[indexInData]));
-		} else {
-			asciiOutput.append(".");
-		}
-	}
-	uint32 k = ((indexInData - skip) - 1) % cols;
-	if (k < 8) {
-		writeNTS(id, dofile, "  ");
-	}
-	for (uint32 h = k + 1; h < cols; h++) {
-		writeNTS(id, dofile, "   ");
-	}
-	writeNTS(id, dofile, " | %s\n", asciiOutput.c_str());
-	if (dofile) {
-		fflush(fp[id]);
-	}
-	return true;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackFmt proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackFmt[id] = proc;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackBuf proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackBuf[id] = proc;
-}
-
-void EQEMuLog::SetCallback(LogIDs id, msgCallbackPva proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	if (id >= MaxLogID) {
-		return;
-	}
-	logCallbackPva[id] = proc;
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackFmt proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	int r;
-	for (r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackBuf proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	int r;
-	for (r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-
-void EQEMuLog::SetAllCallbacks(msgCallbackPva proc)
-{
-	if (!logFileValid) {
-		return;
-	}
-	int r;
-	for (r = Status; r < MaxLogID; r++) {
-		SetCallback((LogIDs)r, proc);
-	}
-}
-

common/debug.h

@@ -1,149 +0,0 @@
-/*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2002 EQEMu Development Team (http://eqemu.org)
-
-	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
-*/
-
-// Debug Levels
-#ifndef EQDEBUG
-#define EQDEBUG 1
-#else
-////// File/Console options
-// 0 <= Quiet mode Errors to file Status and Normal ignored
-// 1 >= Status and Normal to console, Errors to file
-// 2 >= Status, Normal, and Error to console and logfile
-// 3 >= Lite debug
-// 4 >= Medium debug
-// 5 >= Debug release (Anything higher is not recommended for regular use)
-// 6 == (Reserved for special builds) Login opcode debug All packets dumped
-// 7 == (Reserved for special builds) Chat Opcode debug All packets dumped
-// 8 == (Reserved for special builds) World opcode debug All packets dumped
-// 9 == (Reserved for special builds) Zone Opcode debug All packets dumped
-// 10 >= More than you ever wanted to know
-//
-/////
-// Add more below to reserve for file's functions ect.
-/////
-// Any setup code based on defines should go here
-//
-#endif
-
-
-#if defined(_DEBUG) && defined(WIN32)
-	#ifndef _CRTDBG_MAP_ALLOC
-		#include <stdlib.h>
-		#include <crtdbg.h>
-	#endif
-#endif
-
-#ifndef EQDEBUG_H
-#define EQDEBUG_H
-
-#ifndef _WINDOWS
-	#define DebugBreak()			if(0) {}
-#endif
-
-#define _WINSOCKAPI_	//stupid windows, trying to fix the winsock2 vs. winsock issues
-#if defined(WIN32) && ( defined(PACKETCOLLECTOR) || defined(COLLECTOR) )
-	// Packet Collector on win32 requires winsock.h due to latest pcap.h
-	// winsock.h must come before windows.h
-	#include <winsock.h>
-#endif
-
-#ifdef _WINDOWS
-	#include <windows.h>
-	#include <winsock2.h>
-#endif
-
-#include "logsys.h"
-
-#include "../common/mutex.h"
-#include <stdio.h>
-#include <stdarg.h>
-
-
-class EQEMuLog {
-public:
-	EQEMuLog();
-	~EQEMuLog();
-
-	enum LogIDs {
-		Status = 0,	 /* This must stay the first entry in this list */
-		Normal,		 /* Normal Logs */
-		Error,		 /* Error Logs */
-		Debug,		 /* Debug Logs */
-		Quest,		 /* Quest Logs */
-		Commands,	 /* Issued Comamnds */
-		Crash,		 /* Crash Logs */
-		Save,		 /* Client Saves */
-		MaxLogID	 /* Max, used in functions to get the max log ID */
-	};
-
-	//these are callbacks called for each
-	typedef void (* msgCallbackBuf)(LogIDs id, const char *buf, uint8 size, uint32 count);
-	typedef void (* msgCallbackFmt)(LogIDs id, const char *fmt, va_list ap);
-	typedef void (* msgCallbackPva)(LogIDs id, const char *prefix, const char *fmt, va_list ap);
-
-	void SetAllCallbacks(msgCallbackFmt proc);
-	void SetAllCallbacks(msgCallbackBuf proc);
-	void SetAllCallbacks(msgCallbackPva proc);
-	void SetCallback(LogIDs id, msgCallbackFmt proc);
-	void SetCallback(LogIDs id, msgCallbackBuf proc);
-	void SetCallback(LogIDs id, msgCallbackPva proc);
-
-	bool writebuf(LogIDs id, const char *buf, uint8 size, uint32 count);
-	bool write(LogIDs id, const char *fmt, ...);
-	bool writePVA(LogIDs id, const char *prefix, const char *fmt, va_list args);
-	bool Dump(LogIDs id, uint8* data, uint32 size, uint32 cols=16, uint32 skip=0);
-private:
-	bool open(LogIDs id);
-	bool writeNTS(LogIDs id, bool dofile, const char *fmt, ...); // no error checking, assumes is open, no locking, no timestamp, no newline
-
-	Mutex	MOpen;
-	Mutex	MLog[MaxLogID];
-	FILE*	fp[MaxLogID];
-
-/* LogStatus: bitwise variable
-	1 = output to file
-	2 = output to stdout
-	4 = fopen error, dont retry
-	8 = use stderr instead (2 must be set)
-*/
-	uint8	pLogStatus[MaxLogID];
-
-	msgCallbackFmt logCallbackFmt[MaxLogID];
-	msgCallbackBuf logCallbackBuf[MaxLogID];
-	msgCallbackPva logCallbackPva[MaxLogID];
-};
-
-extern EQEMuLog* LogFile;
-
-#ifdef _EQDEBUG
-class PerformanceMonitor {
-public:
-	PerformanceMonitor(int64* ip) {
-		p = ip;
-		QueryPerformanceCounter(&tmp);
-	}
-	~PerformanceMonitor() {
-		LARGE_INTEGER tmp2;
-		QueryPerformanceCounter(&tmp2);
-		*p += tmp2.QuadPart - tmp.QuadPart;
-	}
-	LARGE_INTEGER tmp;
-	int64* p;
-};
-#endif
-#endif

common/emu_opcodes.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 04111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
 #include "emu_opcodes.h"
 
 const char *OpcodeNames[_maxEmuOpcode+1] = {

common/emu_tcp_connection.cpp

@@ -23,7 +23,7 @@ crap into its own subclass of this object, it will clean things up
 tremendously.
 */
 
-#include "../common/debug.h"
+#include "../common/global_define.h"
 
 #include <iostream>
 #include <string.h>
@@ -104,7 +104,7 @@ EmuTCPConnection::EmuTCPConnection(uint32 ID, EmuTCPServer* iServer, EmuTCPConne
 	RelayCount = 0;
 	RemoteID = iRemoteID;
 	pOldFormat = false;
-	ConnectionType = Incomming;
+	ConnectionType = Incoming;
 	TCPMode = modePacket;
 	PacketMode = packetModeZone;
 #if TCPN_DEBUG_Memory >= 7
@@ -737,7 +737,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("Switch to RelayServer mode by a Relay Client");
 				break;
 			}
-			if (ConnectionType != Incomming) {
+			if (ConnectionType != Incoming) {
 				SendNetErrorPacket("Switch to RelayServer mode on outgoing connection");
 				break;
 			}
@@ -758,7 +758,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 				SendNetErrorPacket("New RelayClient: wrong size, expected 11");
 				break;
 			}
-			if (ConnectionType != Incomming) {
+			if (ConnectionType != Incoming) {
 				SendNetErrorPacket("New RelayClient: illegal on outgoing connection");
 				break;
 			}
@@ -778,7 +778,7 @@ void EmuTCPConnection::ProcessNetworkLayerPacket(ServerPacket* pack) {
 			}
 			EmuTCPConnection* con = Server->FindConnection(*((uint32*)data));
 			if (con) {
-				if (ConnectionType == Incomming) {
+				if (ConnectionType == Incoming) {
 					if (con->GetRelayLink() != this) {
 						SendNetErrorPacket("Delete RelayClient: RelayLink != this");
 						break;

common/emu_tcp_server.cpp

@@ -1,4 +1,4 @@
-#include "debug.h"
+#include "global_define.h"
 #include "emu_tcp_server.h"
 #include "emu_tcp_connection.h"
 

common/eq_constants.h

@@ -19,6 +19,7 @@
 #define EQ_CONSTANTS_H
 
 #include "skills.h"
+#include "types.h"
 
 /*
 **	Item attributes
@@ -367,7 +368,7 @@ enum {
 #define AT_DamageState	44	// The damage state of a destructible object (0 through 4)
 //#define AT_Trader		300	// Bazzar Trader Mode
 
-// solar: animations for AT_Anim
+// animations for AT_Anim
 #define ANIM_FREEZE	102
 #define	ANIM_STAND		0x64
 #define	ANIM_SIT		0x6e

common/eq_dictionary.cpp

@@ -25,8 +25,8 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 //
 // class EmuConstants
 //
-uint16 EmuConstants::InventoryMapSize(int16 map) {
+uint16 EmuConstants::InventoryMapSize(int16 indexMap) {
-	switch (map) {
+	switch (indexMap) {
 	case MapPossessions:
 		return MAP_POSSESSIONS_SIZE;
 	case MapBank:
@@ -91,8 +91,8 @@ std::string EmuConstants::InventoryLocationName(Location_Struct location) {
 }
 */
 
-std::string EmuConstants::InventoryMapName(int16 map) {
+std::string EmuConstants::InventoryMapName(int16 indexMap) {
-	switch (map) {
+	switch (indexMap) {
 	case INVALID_INDEX:
 		return "Invalid Map";
 	case MapPossessions:
@@ -150,8 +150,8 @@ std::string EmuConstants::InventoryMapName(int16 map) {
 	}
 }
 
-std::string EmuConstants::InventoryMainName(int16 main) {
+std::string EmuConstants::InventoryMainName(int16 indexMain) {
-	switch (main) {
+	switch (indexMain) {
 	case INVALID_INDEX:
 		return "Invalid Main";
 	case MainCharm:
@@ -229,293 +229,83 @@ std::string EmuConstants::InventoryMainName(int16 main) {
 	}
 }
 
-std::string EmuConstants::InventorySubName(int16 sub) {
+std::string EmuConstants::InventorySubName(int16 indexSub) {
-	if (sub == INVALID_INDEX)
+	if (indexSub == INVALID_INDEX)
 		return "Invalid Sub";
 
-	if ((uint16)sub >= ITEM_CONTAINER_SIZE)
+	if ((uint16)indexSub >= ITEM_CONTAINER_SIZE)
 		return "Unknown Sub";
 
 	std::string ret_str;
-	ret_str = StringFormat("Container %i", (sub + 1)); // zero-based index..but, count starts at one
+	ret_str = StringFormat("Container %i", (indexSub + 1)); // zero-based index..but, count starts at one
 
 	return ret_str;
 }
 
-std::string EmuConstants::InventoryAugName(int16 aug) {
+std::string EmuConstants::InventoryAugName(int16 indexAug) {
-	if (aug == INVALID_INDEX)
+	if (indexAug == INVALID_INDEX)
 		return "Invalid Aug";
 
-	if ((uint16)aug >= ITEM_COMMON_SIZE)
+	if ((uint16)indexAug >= ITEM_COMMON_SIZE)
 		return "Unknown Aug";
 
 	std::string ret_str;
-	ret_str = StringFormat("Augment %i", (aug + 1)); // zero-based index..but, count starts at one
+	ret_str = StringFormat("Augment %i", (indexAug + 1)); // zero-based index..but, count starts at one
 
 	return ret_str;
 }
 
-// legacy-related functions
-//
-// these should work for the first-stage coversions..but, once the new system is up and going..conversions will be incompatible
-// without limiting server functions and other aspects, such as augment control, bag size, etc. A complete remapping will be
-// required when bag sizes over 10 and direct manipulation of augments are implemented, due to the massive increase in range usage.
-//
-// (current personal/cursor bag range {251..340}, or 90 slots ... conversion translated range would be {10000..12804}, or 2805 slots...
-// these would have to be hard-coded into all perl code to allow access to full range of the new system - actual limits would be
-// less, based on bag size..but, the range must be full and consistent to avoid translation issues -- similar changes to other ranges
-// (240 versus 6120 slots for bank bags, for example...))
-/*
-int EmuConstants::ServerToPerlSlot(int server_slot) { // set r/s
-	switch (server_slot) {
-	case legacy::SLOT_CURSOR_END:
-		return legacy::SLOT_CURSOR_END;
-	case INVALID_INDEX:
-		return legacy::SLOT_INVALID;
-	case MainPowerSource:
-		return legacy::SLOT_POWER_SOURCE;
-	case MainAmmo:
-		return legacy::SLOT_AMMO;
-	case MainCursor:
-		return legacy::SLOT_CURSOR;
-	case legacy::SLOT_TRADESKILL:
-		return legacy::SLOT_TRADESKILL;
-	case legacy::SLOT_AUGMENT:
-		return legacy::SLOT_AUGMENT;
-	default:
-		int perl_slot = legacy::SLOT_INVALID;
-
-		// activate the internal checks as needed
-		if (server_slot >= EmuConstants::EQUIPMENT_BEGIN && server_slot <= MainWaist) {
-			perl_slot = server_slot;
-		}
-		else if (server_slot >= EmuConstants::GENERAL_BEGIN && server_slot <= EmuConstants::GENERAL_END) {
-			perl_slot = server_slot;// + legacy::SLOT_PERSONAL_BEGIN - EmuConstants::GENERAL_BEGIN;
-			//if (perl_slot < legacy::SLOT_PERSONAL_BEGIN || perl_slot > legacy::SLOT_PERSONAL_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::GENERAL_BAGS_BEGIN && server_slot <= EmuConstants::GENERAL_BAGS_END) {
-			perl_slot = server_slot;// + legacy::SLOT_PERSONAL_BAGS_BEGIN - EmuConstants::GENERAL_BAGS_BEGIN;
-			//if (perl_slot < legacy::SLOT_PERSONAL_BAGS_BEGIN || perl_slot > legacy::SLOT_PERSONAL_BAGS_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::CURSOR_BAG_BEGIN && server_slot <= EmuConstants::CURSOR_BAG_END) {
-			perl_slot = server_slot;// + legacy::SLOT_CURSOR_BAG_BEGIN - EmuConstants::CURSOR_BAG_BEGIN;
-			//if (perl_slot < legacy::SLOT_CURSOR_BAG_BEGIN || perl_slot > legacy::SLOT_CURSOR_BAG_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::TRIBUTE_BEGIN && server_slot <= EmuConstants::TRIBUTE_END) {
-			perl_slot = server_slot;// + legacy::SLOT_TRIBUTE_BEGIN - EmuConstants::TRADE_BEGIN;
-			//if (perl_slot < legacy::SLOT_TRIBUTE_BEGIN || perl_slot > legacy::SLOT_TRIBUTE_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::BANK_BEGIN && server_slot <= EmuConstants::BANK_END) {
-			perl_slot = server_slot;// + legacy::SLOT_BANK_BEGIN - EmuConstants::BANK_BEGIN;
-			//if (perl_slot < legacy::SLOT_BANK_BEGIN || perl_slot > legacy::SLOT_BANK_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::BANK_BAGS_BEGIN && server_slot <= EmuConstants::BANK_BAGS_END) {
-			perl_slot = server_slot;// + legacy::SLOT_BANK_BAGS_BEGIN - EmuConstants::BANK_BAGS_BEGIN;
-			//if (perl_slot < legacy::SLOT_BANK_BAGS_BEGIN || perl_slot > legacy::SLOT_BANK_BAGS_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::SHARED_BANK_BEGIN && server_slot <= EmuConstants::SHARED_BANK_END) {
-			perl_slot = server_slot;// + legacy::SLOT_SHARED_BANK_BEGIN - EmuConstants::SHARED_BANK_BEGIN;
-			//if (perl_slot < legacy::SLOT_SHARED_BANK_BEGIN || perl_slot > legacy::SLOT_SHARED_BANK_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::SHARED_BANK_BAGS_BEGIN && server_slot <= EmuConstants::SHARED_BANK_BAGS_END) {
-			perl_slot = server_slot;// + legacy::SLOT_SHARED_BANK_BAGS_BEGIN - EmuConstants::SHARED_BANK_BAGS_BEGIN;
-			//if (perl_slot < legacy::SLOT_SHARED_BANK_BAGS_BEGIN || perl_slot > legacy::SLOT_SHARED_BANK_BAGS_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::TRADE_BEGIN && server_slot <= EmuConstants::TRADE_END) {
-			perl_slot = server_slot;// + legacy::SLOT_TRADE_BEGIN - EmuConstants::TRADE_BEGIN;
-			//if (perl_slot < legacy::SLOT_TRADE_BEGIN || perl_slot > legacy::SLOT_TRADE_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::TRADE_BAGS_BEGIN && server_slot <= EmuConstants::TRADE_BAGS_END) {
-			perl_slot = server_slot;// + legacy::SLOT_TRADE_BAGS_BEGIN - EmuConstants::TRADE_BAGS_BEGIN;
-			//if (perl_slot < legacy::SLOT_TRADE_BAGS_BEGIN || perl_slot > legacy::SLOT_TRADE_BAGS_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= EmuConstants::WORLD_BEGIN && server_slot <= EmuConstants::WORLD_END) {
-			perl_slot = server_slot;// + legacy::SLOT_WORLD_BEGIN - EmuConstants::WORLD_BEGIN;
-			//if (perl_slot < legacy::SLOT_WORLD_BEGIN || perl_slot > legacy::SLOT_WORLD_END)
-			//	perl_slot = legacy::SLOT_INVALID;
-		}
-		else if (server_slot >= 8000 && server_slot <= 8999) { // this range may be limited to 36 in the future (client size)
-			perl_slot = server_slot;
-		}
-
-		return perl_slot;
-	}
-}
-*/
-/*
-int EmuConstants::PerlToServerSlot(int perl_slot) { // set r/s
-	switch (perl_slot) {
-	case legacy::SLOT_CURSOR_END:
-		return legacy::SLOT_CURSOR_END;
-	case legacy::SLOT_INVALID:
-		return INVALID_INDEX;
-	case legacy::SLOT_POWER_SOURCE:
-		return MainPowerSource;
-	case legacy::SLOT_AMMO:
-		return MainAmmo;
-	case legacy::SLOT_CURSOR:
-		return MainCursor;
-	case legacy::SLOT_TRADESKILL:
-		return legacy::SLOT_TRADESKILL;
-	case legacy::SLOT_AUGMENT:
-		return legacy::SLOT_AUGMENT;
-	default:
-		int server_slot = INVALID_INDEX;
-
-		// activate the internal checks as needed
-		if (perl_slot >= legacy::SLOT_EQUIPMENT_BEGIN && perl_slot <= legacy::SLOT_WAIST) {
-			server_slot = perl_slot;
-		}
-		else if (perl_slot >= legacy::SLOT_PERSONAL_BEGIN && perl_slot <= legacy::SLOT_PERSONAL_END) {
-			server_slot = perl_slot;// + EmuConstants::GENERAL_BEGIN - legacy::SLOT_PERSONAL_BEGIN;
-			//if (server_slot < EmuConstants::GENERAL_BEGIN || server_slot > EmuConstants::GENERAL_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_PERSONAL_BAGS_BEGIN && perl_slot <= legacy::SLOT_PERSONAL_BAGS_END) {
-			server_slot = perl_slot;// + EmuConstants::GENERAL_BAGS_BEGIN - legacy::SLOT_PERSONAL_BAGS_BEGIN;
-			//if (server_slot < EmuConstants::GENERAL_BAGS_BEGIN || server_slot > EmuConstants::GENERAL_BAGS_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_CURSOR_BAG_BEGIN && perl_slot <= legacy::SLOT_CURSOR_BAG_END) {
-			server_slot = perl_slot;// + EmuConstants::CURSOR_BAG_BEGIN - legacy::SLOT_CURSOR_BAG_BEGIN;
-			//if (server_slot < EmuConstants::CURSOR_BAG_BEGIN || server_slot > EmuConstants::CURSOR_BAG_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_TRIBUTE_BEGIN && perl_slot <= legacy::SLOT_TRIBUTE_END) {
-			server_slot = perl_slot;// + EmuConstants::TRIBUTE_BEGIN - legacy::SLOT_TRIBUTE_BEGIN;
-			//if (server_slot < EmuConstants::TRIBUTE_BEGIN || server_slot > EmuConstants::TRIBUTE_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_BANK_BEGIN && perl_slot <= legacy::SLOT_BANK_END) {
-			server_slot = perl_slot;// + EmuConstants::BANK_BEGIN - legacy::SLOT_BANK_BEGIN;
-			//if (server_slot < EmuConstants::BANK_BEGIN || server_slot > EmuConstants::BANK_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_BANK_BAGS_BEGIN && perl_slot <= legacy::SLOT_BANK_BAGS_END) {
-			server_slot = perl_slot;// + EmuConstants::BANK_BAGS_BEGIN - legacy::SLOT_BANK_BAGS_BEGIN;
-			//if (server_slot < EmuConstants::BANK_BAGS_BEGIN || server_slot > EmuConstants::BANK_BAGS_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_SHARED_BANK_BEGIN && perl_slot <= legacy::SLOT_SHARED_BANK_END) {
-			server_slot = perl_slot;// + EmuConstants::SHARED_BANK_BEGIN - legacy::SLOT_SHARED_BANK_BEGIN;
-			//if (server_slot < EmuConstants::SHARED_BANK_BEGIN || server_slot > EmuConstants::SHARED_BANK_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_SHARED_BANK_BAGS_BEGIN && perl_slot <= legacy::SLOT_SHARED_BANK_BAGS_END) {
-			server_slot = perl_slot;// + EmuConstants::SHARED_BANK_BAGS_BEGIN - legacy::SLOT_SHARED_BANK_BAGS_END;
-			//if (server_slot < EmuConstants::SHARED_BANK_BAGS_BEGIN || server_slot > EmuConstants::SHARED_BANK_BAGS_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_TRADE_BEGIN && perl_slot <= legacy::SLOT_TRADE_END) {
-			server_slot = perl_slot;// + EmuConstants::TRADE_BEGIN - legacy::SLOT_TRADE_BEGIN;
-			//if (server_slot < EmuConstants::TRADE_BEGIN || server_slot > EmuConstants::TRADE_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_TRADE_BAGS_BEGIN && perl_slot <= legacy::SLOT_TRADE_BAGS_END) {
-			server_slot = perl_slot;// + EmuConstants::TRADE_BAGS_BEGIN - legacy::SLOT_TRADE_BAGS_BEGIN;
-			//if (server_slot < EmuConstants::TRADE_BAGS_BEGIN || server_slot > EmuConstants::TRADE_BAGS_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= legacy::SLOT_WORLD_BEGIN && perl_slot <= legacy::SLOT_WORLD_END) {
-			server_slot = perl_slot;// + EmuConstants::WORLD_BEGIN - legacy::SLOT_WORLD_BEGIN;
-			//if (server_slot < EmuConstants::WORLD_BEGIN || server_slot > EmuConstants::WORLD_END)
-			//	server_slot = INVALID_INDEX;
-		}
-		else if (perl_slot >= 8000 && perl_slot <= 8999) { // this range may be limited to 36 in the future (client size)
-			server_slot = perl_slot;
-		}
-
-		return server_slot;
-	}
-}
-*/
 
 // 
 // class EQLimits
 //
 // client validation
-bool EQLimits::IsValidClientVersion(uint32 version) {
+bool EQLimits::IsValidPCClientVersion(ClientVersion clientVersion) {
-	if (version < _EQClientCount)
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
 		return true;
 
 	return false;
 }
 
-uint32 EQLimits::ValidateClientVersion(uint32 version) {
+ClientVersion EQLimits::ValidatePCClientVersion(ClientVersion clientVersion) {
-	if (version < _EQClientCount)
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_PC_CLIENT)
-		return version;
+		return clientVersion;
 
-	return EQClientUnknown;
+	return ClientVersion::Unknown;
-}
-
-EQClientVersion EQLimits::ValidateClientVersion(EQClientVersion version) {
-	if (version >= EQClientUnknown)
-		if (version < _EQClientCount)
-			return version;
-
-	return EQClientUnknown;
 }
 
 // npc validation
-bool EQLimits::IsValidNPCVersion(uint32 version) {
+bool EQLimits::IsValidNPCClientVersion(ClientVersion clientVersion) {
-	if (version >= _EQClientCount)
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
-		if (version < _EmuClientCount)
-			return true;
-
-	return false;
-}
-
-uint32 EQLimits::ValidateNPCVersion(uint32 version) {
-	if (version >= _EQClientCount)
-		if (version < _EmuClientCount)
-			return version;
-
-	return EQClientUnknown;
-}
-
-EQClientVersion EQLimits::ValidateNPCVersion(EQClientVersion version) {
-	if (version >= _EQClientCount)
-		if (version < _EmuClientCount)
-			return version;
-
-	return EQClientUnknown;
-}
-
-// mob validation
-bool EQLimits::IsValidMobVersion(uint32 version) {
-	if (version < _EmuClientCount)
 		return true;
 
 	return false;
 }
 
-uint32 EQLimits::ValidateMobVersion(uint32 version) {
+ClientVersion EQLimits::ValidateNPCClientVersion(ClientVersion clientVersion) {
-	if (version < _EmuClientCount)
+	if (clientVersion > LAST_PC_CLIENT && clientVersion <= LAST_NPC_CLIENT)
-		return version;
+		return clientVersion;
 
-	return EQClientUnknown;
+	return ClientVersion::Unknown;
 }
 
-EQClientVersion EQLimits::ValidateMobVersion(EQClientVersion version) {
+// mob validation
-	if (version >= EQClientUnknown)
+bool EQLimits::IsValidMobClientVersion(ClientVersion clientVersion) {
-		if (version < _EmuClientCount)
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
-			return version;
+		return true;
 
-	return EQClientUnknown;
+	return false;
+}
+
+ClientVersion EQLimits::ValidateMobClientVersion(ClientVersion clientVersion) {
+	if (clientVersion > ClientVersion::Unknown && clientVersion <= LAST_NPC_CLIENT)
+		return clientVersion;
+
+	return ClientVersion::Unknown;
 }
 
 // inventory
-uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
+uint16 EQLimits::InventoryMapSize(int16 indexMap, ClientVersion clientVersion) {
 	// not all maps will have an instantiated container..some are references for queue generators (i.e., bazaar, mail, etc...)
 	// a zero '0' indicates a needed value..otherwise, change to '_NOTUSED' for a null value so indices requiring research can be identified
 	// ALL of these values need to be verified before pushing to live
@@ -527,7 +317,7 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
 	//
 	// when setting NPC-based values, try to adhere to an EmuConstants::<property> or NOT_USED value to avoid unnecessary issues
 
-	static const uint16 local[_MapCount][_EmuClientCount] = {
+	static const uint16 local[_MapCount][CLIENT_VERSION_COUNT] = {
 		// server and database are sync'd to current MapPossessions's client as set in 'using namespace RoF::slots;' and
 		// 'EmuConstants::MAP_POSSESSIONS_SIZE' - use/update EquipmentBitmask(), GeneralBitmask() and CursorBitmask()
 		// for partial range validation checks and 'EmuConstants::MAP_POSSESSIONS_SIZE' for full range iterations
@@ -702,7 +492,7 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
 /*Titanium*/	Titanium::consts::MAP_CORPSE_SIZE,
 /*SoF*/			SoF::consts::MAP_CORPSE_SIZE,
 /*SoD*/			SoD::consts::MAP_CORPSE_SIZE,
-/*Underfoot*/	Underfoot::consts::MAP_CORPSE_SIZE,
+/*Underfoot*/	UF::consts::MAP_CORPSE_SIZE,
 /*RoF*/			RoF::consts::MAP_CORPSE_SIZE,
 /*RoF2*/		RoF2::consts::MAP_CORPSE_SIZE,
 
@@ -732,7 +522,7 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
 /*Titanium*/	Titanium::consts::MAP_INSPECT_SIZE,
 /*SoF*/			SoF::consts::MAP_INSPECT_SIZE,
 /*SoD*/			SoD::consts::MAP_INSPECT_SIZE,
-/*Underfoot*/	Underfoot::consts::MAP_INSPECT_SIZE,
+/*Underfoot*/	UF::consts::MAP_INSPECT_SIZE,
 /*RoF*/			RoF::consts::MAP_INSPECT_SIZE,
 /*RoF2*/		RoF2::consts::MAP_INSPECT_SIZE,
 
@@ -908,19 +698,19 @@ uint16 EQLimits::InventoryMapSize(int16 map, uint32 version) {
 		}
 	};
 
-	if ((uint16)map < _MapCount)
+	if ((uint16)indexMap < _MapCount)
-		return local[map][ValidateMobVersion(version)];
+		return local[indexMap][static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 
 	return NOT_USED;
 }
 
-uint64 EQLimits::PossessionsBitmask(uint32 version) {
+uint64 EQLimits::PossessionsBitmask(ClientVersion clientVersion) {
 	// these are for the new inventory system (RoF)..not the current (Ti) one...
 	// 0x0000000000200000 is SlotPowerSource (SoF+)
 	// 0x0000000080000000 is SlotGeneral9 (RoF+)
 	// 0x0000000100000000 is SlotGeneral10 (RoF+)
 
-	static const uint64 local[_EmuClientCount] = {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			0x000000027FDFFFFF,
 /*Titanium*/	0x000000027FDFFFFF,
@@ -937,11 +727,11 @@ uint64 EQLimits::PossessionsBitmask(uint32 version) {
 	};
 
 	return NOT_USED;
-	//return local[ValidateMobVersion(version)];
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint64 EQLimits::EquipmentBitmask(uint32 version) {
+uint64 EQLimits::EquipmentBitmask(ClientVersion clientVersion) {
-	static const uint64 local[_EmuClientCount] = {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			0x00000000005FFFFF,
 /*Titanium*/	0x00000000005FFFFF,
@@ -958,11 +748,11 @@ uint64 EQLimits::EquipmentBitmask(uint32 version) {
 	};
 
 	return NOT_USED;
-	//return local[ValidateMobVersion(version)];
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint64 EQLimits::GeneralBitmask(uint32 version) {
+uint64 EQLimits::GeneralBitmask(ClientVersion clientVersion) {
-	static const uint64 local[_EmuClientCount] = {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			0x000000007F800000,
 /*Titanium*/	0x000000007F800000,
@@ -979,11 +769,11 @@ uint64 EQLimits::GeneralBitmask(uint32 version) {
 	};
 
 	return NOT_USED;
-	//return local[ValidateMobVersion(version)];
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint64 EQLimits::CursorBitmask(uint32 version) {
+uint64 EQLimits::CursorBitmask(ClientVersion clientVersion) {
-	static const uint64 local[_EmuClientCount] = {
+	static const uint64 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			0x0000000200000000,
 /*Titanium*/	0x0000000200000000,
@@ -1000,17 +790,17 @@ uint64 EQLimits::CursorBitmask(uint32 version) {
 	};
 
 	return NOT_USED;
-	//return local[ValidateMobVersion(version)];
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-bool EQLimits::AllowsEmptyBagInBag(uint32 version) {
+bool EQLimits::AllowsEmptyBagInBag(ClientVersion clientVersion) {
-	static const bool local[_EmuClientCount] = {
+	static const bool local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		false,
 /*62*/			false,
 /*Titanium*/	Titanium::limits::ALLOWS_EMPTY_BAG_IN_BAG,
 /*SoF*/			SoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
 /*SoD*/			SoD::limits::ALLOWS_EMPTY_BAG_IN_BAG,
-/*Underfoot*/	Underfoot::limits::ALLOWS_EMPTY_BAG_IN_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
 /*RoF*/			RoF::limits::ALLOWS_EMPTY_BAG_IN_BAG,
 /*RoF2*/		RoF2::limits::ALLOWS_EMPTY_BAG_IN_BAG,
 
@@ -1021,17 +811,17 @@ bool EQLimits::AllowsEmptyBagInBag(uint32 version) {
 	};
 
 	return false; // not implemented
-	//return local[ValidateMobVersion(version)];
+	//return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-bool EQLimits::AllowsClickCastFromBag(uint32 version) {
+bool EQLimits::AllowsClickCastFromBag(ClientVersion clientVersion) {
-	static const bool local[_EmuClientCount] = {
+	static const bool local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		false,
 /*62*/			false,
 /*Titanium*/	Titanium::limits::ALLOWS_CLICK_CAST_FROM_BAG,
 /*SoF*/			SoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
 /*SoD*/			SoD::limits::ALLOWS_CLICK_CAST_FROM_BAG,
-/*Underfoot*/	Underfoot::limits::ALLOWS_CLICK_CAST_FROM_BAG,
+/*Underfoot*/	UF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
 /*RoF*/			RoF::limits::ALLOWS_CLICK_CAST_FROM_BAG,
 /*RoF2*/		RoF2::limits::ALLOWS_CLICK_CAST_FROM_BAG,
 
@@ -1041,12 +831,12 @@ bool EQLimits::AllowsClickCastFromBag(uint32 version) {
 /*Pet*/			false
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
 // items
-uint16 EQLimits::ItemCommonSize(uint32 version) {
+uint16 EQLimits::ItemCommonSize(ClientVersion clientVersion) {
-	static const uint16 local[_EmuClientCount] = {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			EmuConstants::ITEM_COMMON_SIZE,
 /*Titanium*/	EmuConstants::ITEM_COMMON_SIZE,
@@ -1062,11 +852,11 @@ uint16 EQLimits::ItemCommonSize(uint32 version) {
 /*Pet*/			EmuConstants::ITEM_COMMON_SIZE
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint16 EQLimits::ItemContainerSize(uint32 version) {
+uint16 EQLimits::ItemContainerSize(ClientVersion clientVersion) {
-	static const uint16 local[_EmuClientCount] = {
+	static const uint16 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			EmuConstants::ITEM_CONTAINER_SIZE,
 /*Titanium*/	EmuConstants::ITEM_CONTAINER_SIZE,
@@ -1082,17 +872,17 @@ uint16 EQLimits::ItemContainerSize(uint32 version) {
 /*Pet*/			EmuConstants::ITEM_CONTAINER_SIZE
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-bool EQLimits::CoinHasWeight(uint32 version) {
+bool EQLimits::CoinHasWeight(ClientVersion clientVersion) {
-	static const bool local[_EmuClientCount] = {
+	static const bool local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		true,
 /*62*/			true,
 /*Titanium*/	Titanium::limits::COIN_HAS_WEIGHT,
 /*SoF*/			SoF::limits::COIN_HAS_WEIGHT,
 /*SoD*/			SoD::limits::COIN_HAS_WEIGHT,
-/*Underfoot*/	Underfoot::limits::COIN_HAS_WEIGHT,
+/*Underfoot*/	UF::limits::COIN_HAS_WEIGHT,
 /*RoF*/			RoF::limits::COIN_HAS_WEIGHT,
 /*RoF2*/		RoF::limits::COIN_HAS_WEIGHT,
 
@@ -1102,11 +892,11 @@ bool EQLimits::CoinHasWeight(uint32 version) {
 /*Pet*/			true
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint32 EQLimits::BandoliersCount(uint32 version) {
+uint32 EQLimits::BandoliersCount(ClientVersion clientVersion) {
-	static const uint32 local[_EmuClientCount] = {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			EmuConstants::BANDOLIERS_COUNT,
 /*Titanium*/	EmuConstants::BANDOLIERS_COUNT,
@@ -1122,11 +912,11 @@ uint32 EQLimits::BandoliersCount(uint32 version) {
 /*Pet*/			NOT_USED
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint32 EQLimits::BandolierSize(uint32 version) {
+uint32 EQLimits::BandolierSize(ClientVersion clientVersion) {
-	static const uint32 local[_EmuClientCount] = {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			EmuConstants::BANDOLIER_SIZE,
 /*Titanium*/	EmuConstants::BANDOLIER_SIZE,
@@ -1142,11 +932,11 @@ uint32 EQLimits::BandolierSize(uint32 version) {
 /*Pet*/			NOT_USED
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }
 
-uint32 EQLimits::PotionBeltSize(uint32 version) {
+uint32 EQLimits::PotionBeltSize(ClientVersion clientVersion) {
-	static const uint32 local[_EmuClientCount] = {
+	static const uint32 local[CLIENT_VERSION_COUNT] = {
 /*Unknown*/		NOT_USED,
 /*62*/			EmuConstants::POTION_BELT_SIZE,
 /*Titanium*/	EmuConstants::POTION_BELT_SIZE,
@@ -1162,5 +952,5 @@ uint32 EQLimits::PotionBeltSize(uint32 version) {
 /*Pet*/			NOT_USED
 	};
 
-	return local[ValidateMobVersion(version)];
+	return local[static_cast<unsigned int>(ValidateMobClientVersion(clientVersion))];
 }

common/eq_dictionary.h

@@ -29,7 +29,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include "../common/patches/titanium_constants.h"
 #include "../common/patches/sof_constants.h"
 #include "../common/patches/sod_constants.h"
-#include "../common/patches/underfoot_constants.h"
+#include "../common/patches/uf_constants.h"
 #include "../common/patches/rof_constants.h"
 #include "../common/patches/rof2_constants.h"
 
@@ -46,15 +46,15 @@ class EmuConstants {
 	// an immutable value is required to initialize arrays, etc... use this class as a repository for those
 public:
 	// database
-	static const EQClientVersion CHARACTER_CREATION_CLIENT = EQClientRoF; // adjust according to starting item placement and target client
+	static const ClientVersion CHARACTER_CREATION_CLIENT = ClientVersion::RoF2; // adjust according to starting item placement and target client
 
 	// inventory
-	static uint16 InventoryMapSize(int16 map);
+	static uint16 InventoryMapSize(int16 indexMap);
 	//static std::string InventoryLocationName(Location_Struct location);
-	static std::string InventoryMapName(int16 map);
+	static std::string InventoryMapName(int16 indexMap);
-	static std::string InventoryMainName(int16 main);
+	static std::string InventoryMainName(int16 indexMain);
-	static std::string InventorySubName(int16 sub);
+	static std::string InventorySubName(int16 indexSub);
-	static std::string InventoryAugName(int16 aug);
+	static std::string InventoryAugName(int16 indexAug);
 
 	// these are currently hard-coded for existing inventory system..do not use in place of special client version handlers until ready
 	static const uint16	MAP_POSSESSIONS_SIZE = _MainCount;
@@ -149,6 +149,8 @@ public:
 	static const uint32 BANDOLIER_SIZE = Titanium::consts::BANDOLIER_SIZE;		// size = number of equipment slots in bandolier instance
 	static const uint32 POTION_BELT_SIZE = Titanium::consts::POTION_BELT_SIZE;
 
+	static const size_t TEXT_LINK_BODY_LENGTH = 56;
+
 	// legacy-related functions
 	//static int ServerToPerlSlot(int slot);	// encode
 	//static int PerlToServerSlot(int slot);	// decode
@@ -161,44 +163,41 @@ class EQLimits {
 public:
 	// client version validation (checks to avoid crashing zone server when accessing reference arrays)
 	// use this inside of class Client (limits to actual clients)
-	static bool				IsValidClientVersion(uint32 version);
+	static bool IsValidPCClientVersion(ClientVersion clientVersion);
-	static uint32			ValidateClientVersion(uint32 version);
+	static ClientVersion ValidatePCClientVersion(ClientVersion clientVersion);
-	static EQClientVersion	ValidateClientVersion(EQClientVersion version);
 
 	// basically..any non-client classes - do not when setting a valid client
-	static bool				IsValidNPCVersion(uint32 version);
+	static bool IsValidNPCClientVersion(ClientVersion clientVersion);
-	static uint32			ValidateNPCVersion(uint32 version);
+	static ClientVersion ValidateNPCClientVersion(ClientVersion clientVersion);
-	static EQClientVersion	ValidateNPCVersion(EQClientVersion version);
 
 	// these are 'universal' - do not when setting a valid client
-	static bool				IsValidMobVersion(uint32 version);
+	static bool IsValidMobClientVersion(ClientVersion clientVersion);
-	static uint32			ValidateMobVersion(uint32 version);
+	static ClientVersion ValidateMobClientVersion(ClientVersion clientVersion);
-	static EQClientVersion	ValidateMobVersion(EQClientVersion version);
 
 	// inventory
-	static uint16	InventoryMapSize(int16 map, uint32 version);
+	static uint16 InventoryMapSize(int16 indexMap, ClientVersion clientVersion);
-	static uint64	PossessionsBitmask(uint32 version);
+	static uint64 PossessionsBitmask(ClientVersion clientVersion);
-	static uint64	EquipmentBitmask(uint32 version);
+	static uint64 EquipmentBitmask(ClientVersion clientVersion);
-	static uint64	GeneralBitmask(uint32 version);
+	static uint64 GeneralBitmask(ClientVersion clientVersion);
-	static uint64	CursorBitmask(uint32 version);
+	static uint64 CursorBitmask(ClientVersion clientVersion);
 
-	static bool	AllowsEmptyBagInBag(uint32 version);
+	static bool AllowsEmptyBagInBag(ClientVersion clientVersion);
-	static bool AllowsClickCastFromBag(uint32 version);
+	static bool AllowsClickCastFromBag(ClientVersion clientVersion);
 
 	// items
-	static uint16	ItemCommonSize(uint32 version);
+	static uint16 ItemCommonSize(ClientVersion clientVersion);
-	static uint16	ItemContainerSize(uint32 version);
+	static uint16 ItemContainerSize(ClientVersion clientVersion);
 
 	// player profile
-	static bool	CoinHasWeight(uint32 version);
+	static bool CoinHasWeight(ClientVersion clientVersion);
 
-	static uint32	BandoliersCount(uint32 version);
+	static uint32 BandoliersCount(ClientVersion clientVersion);
-	static uint32	BandolierSize(uint32 version);
+	static uint32 BandolierSize(ClientVersion clientVersion);
 
-	static uint32	PotionBeltSize(uint32 version);
+	static uint32 PotionBeltSize(ClientVersion clientVersion);
 };
 
-#endif /* EQ_LIMITS_H */
+#endif /* EQ_DICTIONARY_H */
 
 /*
 Working Notes:

common/eq_packet.cpp

@@ -17,13 +17,14 @@
 */
 
 #include "crc16.h"
-#include "debug.h"
+#include "global_define.h"
 #include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
 #include "platform.h"
 #include <iomanip>
 #include <iostream>
+#include <sstream>
 #include <stdio.h>
 
 #ifndef STATIC_OPCODE
@@ -510,3 +511,8 @@ void DumpPacket(const EQApplicationPacket* app, bool iShowInfo) {
 //	DumpPacketAscii(app->pBuffer, app->size);
 }
 
+std::string DumpPacketToString(const EQApplicationPacket* app){
+	std::ostringstream out;
+	out << DumpPacketHexToString(app->pBuffer, app->size);
+	return out.str();
+}

common/eq_packet.h

@@ -20,6 +20,7 @@
 
 #include "base_packet.h"
 #include "platform.h"
+#include <iostream>
 
 #ifdef STATIC_OPCODE
 	typedef unsigned short EmuOpcode;
@@ -146,6 +147,6 @@ protected:
 };
 
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
-
+extern std::string DumpPacketToString(const EQApplicationPacket* app);
 
 #endif

common/eq_packet_structs.h

@@ -300,7 +300,7 @@ struct Spawn_Struct {
 /*0036*/ uint8	afk;			// 0=no, 1=afk
 /*0238*/ uint32	guildID;		// Current guild
 /*0242*/ char	title[32];		// Title
-/*0274*/ uint8	unknown0274;
+/*0274*/ uint8	unknown0274;	// non-zero prefixes name with '!'
 /*0275*/ uint8	set_to_0xFF[8];	// ***Placeholder (all ff)
 /*0283*/ uint8	helm;			// Helm texture
 /*0284*/ uint32	race;			// Spawn race
@@ -540,7 +540,7 @@ struct SpawnAppearance_Struct
 };
 
 
-// solar: this is used inside profile
+// this is used inside profile
 struct SpellBuff_Struct
 {
 /*000*/	uint8	slotid;		//badly named... seems to be 2 for a real buff, 0 otherwise
@@ -1268,7 +1268,7 @@ struct Animation_Struct {
 /*04*/
 };
 
-// solar: this is what causes the caster to animate and the target to
+// this is what causes the caster to animate and the target to
 // get the particle effects around them when a spell is cast
 // also causes a buff icon
 struct Action_Struct
@@ -1292,7 +1292,7 @@ struct Action_Struct
  /* 31 */
 };
 
-// solar: this is what prints the You have been struck. and the regular
+// this is what prints the You have been struck. and the regular
 // melee messages like You try to pierce, etc. It's basically the melee
 // and spell damage message
 struct CombatDamage_Struct
@@ -1811,7 +1811,7 @@ struct RandomReq_Struct {
 	uint32 high;
 };
 
-/* solar: 9/23/03 reply to /random command; struct from Zaphod */
+/* 9/23/03 reply to /random command */
 struct RandomReply_Struct {
 /* 00 */	uint32 low;
 /* 04 */	uint32 high;
@@ -2388,7 +2388,7 @@ struct AugmentItem_Struct {
 
 // OP_Emote
 struct Emote_Struct {
-/*0000*/	uint32 unknown01;
+/*0000*/	uint32 type;			// 0 - custom, 0xffffffff - command (/dance, /flip, etc...)
 /*0004*/	char message[1024];
 /*1028*/
 };
@@ -5269,6 +5269,23 @@ struct ClientMarqueeMessage_Struct {
 
 typedef std::list<ServerLootItem_Struct*> ItemList;
 
+struct TextLinkBody_Struct {
+	// Current server mask: EQClientRoF2
+	uint8 unknown_1;		/* %1X */
+	uint32 item_id;			/* %05X */
+	uint32 augment_1;		/* %05X */
+	uint32 augment_2;		/* %05X */
+	uint32 augment_3;		/* %05X */
+	uint32 augment_4;		/* %05X */
+	uint32 augment_5;		/* %05X */
+	uint32 augment_6;		/* %05X */
+	uint8 is_evolving;		/* %1X */
+	uint32 evolve_group;	/* %05X */
+	uint8 evolve_level;		/* %02X */
+	uint32 ornament_icon;	/* %05X */
+	int hash;				/* %08X */
+};
+
 // Restore structure packing to default
 #pragma pack()
 

common/eq_stream.cpp

@@ -16,12 +16,14 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "eq_packet.h"
 #include "eq_stream.h"
 #include "op_codes.h"
 #include "crc16.h"
 #include "platform.h"
+#include "string_util.h"
 
 #include <string>
 #include <iomanip>
@@ -80,19 +82,19 @@ void EQStream::init(bool resetSession) {
 
 	OpMgr = nullptr;
 	if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-		_log(NET__ERROR, _L "init Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, 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);
 	}
 	
 	if(NextSequencedSend > SequencedQueue.size()) {
-		_log(NET__ERROR, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "init Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 	}
 }
 
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	_log(NET__APP_CREATE, _L "Creating new application packet, length %d" __L, p->size);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, p->size);
-	_raw(NET__APP_CREATE_HEX, 0xFFFF, p);
+	// _raw(NET__APP_CREATE_HEX, 0xFFFF, p);
 	ap = p->MakeAppPacket();
 	return ap;
 }
@@ -100,8 +102,7 @@ EQRawApplicationPacket *EQStream::MakeApplicationPacket(EQProtocolPacket *p)
 EQRawApplicationPacket *EQStream::MakeApplicationPacket(const unsigned char *buf, uint32 len)
 {
 	EQRawApplicationPacket *ap=nullptr;
-	_log(NET__APP_CREATE, _L "Creating new application packet, length %d" __L, len);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Creating new application packet, length %d" __L, len);
-	_hex(NET__APP_CREATE_HEX, buf, len);
 	ap = new EQRawApplicationPacket(buf, len);
 	return ap;
 }
@@ -131,8 +132,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 	}
 
 	if (!Session && p->opcode!=OP_SessionRequest && p->opcode!=OP_SessionResponse) {
-		_log(NET__DEBUG, _L "Session not initialized, packet ignored" __L);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Session not initialized, packet ignored" __L);
-		_raw(NET__DEBUG, 0xFFFF, p);
+		// _raw(NET__DEBUG, 0xFFFF, p);
 		return;
 	}
 
@@ -142,8 +143,8 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed < p->size) {
 				subpacket_length=*(p->pBuffer+processed);
 				EQProtocolPacket *subp=MakeProtocolPacket(p->pBuffer+processed+1,subpacket_length);
-				_log(NET__NET_CREATE, _L "Extracting combined packet of length %d" __L, subpacket_length);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Extracting combined packet of length %d" __L, subpacket_length);
-				_raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
+				// _raw(NET__NET_CREATE_HEX, 0xFFFF, subp);
 				subp->copyInfo(p);
 				ProcessPacket(subp);
 				delete subp;
@@ -157,12 +158,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			while(processed<p->size) {
 				EQRawApplicationPacket *ap=nullptr;
 				if ((subpacket_length=(unsigned char)*(p->pBuffer+processed))!=0xff) {
-					_log(NET__NET_CREATE, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					Log.Out(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(NET__NET_CREATE, _L "Extracting combined app packet of length %d, short len" __L, subpacket_length);
+					Log.Out(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;
 				}
@@ -177,29 +178,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Packet: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				_log(NET__ERROR, _L "Received OP_Packet that was of malformed size" __L);
+				Log.Out(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(NET__DEBUG, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
-					_raw(NET__DEBUG, seq, p);
+					// _raw(NET__DEBUG, seq, p);
 
 					PacketQueue[seq]=p->Copy();
-					_log(NET__APP_TRACE, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				_log(NET__DEBUG, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Packet: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
-				_raw(NET__DEBUG, seq, p);
+				// _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(NET__NET_TRACE, "OP_Packet: Removing older queued packet with sequence %d", seq);
+					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Packet: Removing older queued packet with sequence %d", seq);
 					delete qp;
 				}
 
@@ -208,8 +209,8 @@ 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(NET__NET_CREATE, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined packet of length %d" __L, seq, subp->size);
-					_raw(NET__NET_CREATE_HEX, seq, subp);
+					// _raw(NET__NET_CREATE_HEX, seq, subp);
 					subp->copyInfo(p);
 					ProcessPacket(subp);
 					delete subp;
@@ -227,29 +228,29 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_Fragment: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				_log(NET__ERROR, _L "Received OP_Fragment that was of malformed size" __L);
+				Log.Out(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(NET__DEBUG, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Future OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
-				_raw(NET__DEBUG, seq, p);
+				// _raw(NET__DEBUG, seq, p);
 
 				PacketQueue[seq]=p->Copy();
-				_log(NET__APP_TRACE, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
+				Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Fragment Queue size=%d" __L, PacketQueue.size());
 
 				//SendOutOfOrderAck(seq);
 
 			} else if (check == SeqPast) {
-				_log(NET__DEBUG, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Duplicate OP_Fragment: Expecting Seq=%d, but got Seq=%d" __L, NextInSeq, seq);
-				_raw(NET__DEBUG, seq, p);
+				// _raw(NET__DEBUG, seq, p);
 				SendOutOfOrderAck(seq);
 			} else {
 				// In case we did queue one before as well.
 				EQProtocolPacket *qp=RemoveQueue(seq);
 				if (qp) {
-					_log(NET__NET_TRACE, "OP_Fragment: Removing older queued packet with sequence %d", seq);
+					Log.Out(Logs::General, Logs::Netcode, "[NET_TRACE] OP_Fragment: Removing older queued packet with sequence %d", seq);
 					delete qp;
 				}
 				SetNextAckToSend(seq);
@@ -257,18 +258,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(NET__NET_TRACE, _L "Fragment of oversized of length %d, seq %d: now at %d/%d" __L, p->size-2, seq, oversize_offset, oversize_length);
+					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);
 					if (oversize_offset==oversize_length) {
 						if (*(p->pBuffer+2)==0x00 && *(p->pBuffer+3)==0x19) {
 							EQProtocolPacket *subp=MakeProtocolPacket(oversize_buffer,oversize_offset);
-							_log(NET__NET_CREATE, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
+							Log.Out(Logs::Detail, Logs::Netcode, _L "seq %d, Extracting combined oversize packet of length %d" __L, seq, subp->size);
-							//_raw(NET__NET_CREATE_HEX, subp);
+							//// _raw(NET__NET_CREATE_HEX, subp);
 							subp->copyInfo(p);
 							ProcessPacket(subp);
 							delete subp;
 						} else {
 							EQRawApplicationPacket *ap=MakeApplicationPacket(oversize_buffer,oversize_offset);
-							_log(NET__NET_CREATE, _L "seq %d, completed combined oversize packet of length %d" __L, seq, ap->size);
+							Log.Out(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);
@@ -283,7 +284,7 @@ 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(NET__NET_TRACE, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment of oversized of seq %d: now at %d/%d" __L, seq, oversize_offset, oversize_length);
 				}
 			}
 		}
@@ -291,14 +292,14 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_KeepAlive: {
 #ifndef COLLECTOR
 			NonSequencedPush(new EQProtocolPacket(p->opcode,p->pBuffer,p->size));
-			_log(NET__NET_TRACE, _L "Received and queued reply to keep alive" __L);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Received and queued reply to keep alive" __L);
 #endif
 		}
 		break;
 		case OP_Ack: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				_log(NET__ERROR, _L "Received OP_Ack that was of malformed size" __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_Ack that was of malformed size" __L);
 				break;
 			}
 #ifndef COLLECTOR
@@ -314,12 +315,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionRequest: {
 			if(p->Size() < sizeof(SessionRequest))
 			{
-				_log(NET__ERROR, _L "Received OP_SessionRequest that was of malformed size" __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest that was of malformed size" __L);
 				break;
 			}
 #ifndef COLLECTOR
 			if (GetState()==ESTABLISHED) {
-				_log(NET__ERROR, _L "Received OP_SessionRequest in ESTABLISHED state (%d) streamactive (%i) attempt (%i)" __L, GetState(),streamactive,sessionAttempts);
+				Log.Out(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 +332,6 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				}
 			}
 #endif
-			//std::cout << "Got OP_SessionRequest" << std::endl;
 			sessionAttempts++;
 			// we set established below, so statistics will not be reset for session attempts/stream active.
 			init(GetState()!=ESTABLISHED);
@@ -339,7 +339,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			SessionRequest *Request=(SessionRequest *)p->pBuffer;
 			Session=ntohl(Request->Session);
 			SetMaxLen(ntohl(Request->MaxLength));
-			_log(NET__NET_TRACE, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionRequest: session %lu, maxlen %d" __L, (unsigned long)Session, MaxLen);
 			SetState(ESTABLISHED);
 #ifndef COLLECTOR
 			Key=0x11223344;
@@ -350,7 +350,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionResponse: {
 			if(p->Size() < sizeof(SessionResponse))
 			{
-				_log(NET__ERROR, _L "Received OP_SessionResponse that was of malformed size" __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionResponse that was of malformed size" __L);
 				break;
 			}
 
@@ -366,7 +366,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			compressed=(Response->Format&FLAG_COMPRESSED);
 			encoded=(Response->Format&FLAG_ENCODED);
 
-			_log(NET__NET_TRACE, _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.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");
 
 			// Kinda kludgy, but trie for now
 			if (StreamType==UnknownStream) {
@@ -389,17 +389,17 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			EQStreamState state = GetState();
 			if(state == ESTABLISHED) {
 				//client initiated disconnect?
-				_log(NET__NET_TRACE, _L "Received unsolicited OP_SessionDisconnect. Treating like a client-initiated disconnect." __L);
+				Log.Out(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(NET__NET_TRACE, _L "Received OP_SessionDisconnect when we have a pending close, they beat us to it. Were happy though." __L);
+				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);
 				_SendDisconnect();
 				SetState(CLOSED);
 			} else {
 				//we are expecting this (or have already gotten it, but dont care either way)
-				_log(NET__NET_TRACE, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received expected OP_SessionDisconnect. Moving to closed state." __L);
 				SetState(CLOSED);
 			}
 		}
@@ -407,7 +407,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_OutOfOrderAck: {
 			if(!p->pBuffer || (p->Size() < 4))
 			{
-				_log(NET__ERROR, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfOrderAck that was of malformed size" __L);
 				break;
 			}
 #ifndef COLLECTOR
@@ -415,15 +415,15 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 			MOutboundQueue.lock();
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				_log(NET__ERROR, _L "Pre-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, 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);
 			}
 			
 			if(NextSequencedSend > SequencedQueue.size()) {
-				_log(NET__ERROR, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 			}
 			//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(NET__NET_TRACE, _L "Received OP_OutOfOrderAck for sequence %d, starting retransmit at the start of our unacked buffer (seq %d, was %d)." __L,
+				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,
 					seq, SequencedBase, SequencedBase+NextSequencedSend);
 
 				bool retransmit_acked_packets = false;
@@ -434,7 +434,7 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 				if(!retransmit_acked_packets) {
 					uint16 sqsize = SequencedQueue.size();
 					uint16 index = seq - SequencedBase;
-					_log(NET__NET_TRACE, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "OP_OutOfOrderAck marking packet acked in queue (queue index = %d, queue size = %d)." __L, index, sqsize);
 					if (index < sqsize) {
 						std::deque<EQProtocolPacket *>::iterator sitr;
 						sitr = SequencedQueue.begin();
@@ -449,15 +449,15 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 
 				NextSequencedSend = 0;
 			} else {
-				_log(NET__NET_TRACE, _L "Received OP_OutOfOrderAck for out-of-window %d. Window (%d->%d)." __L, seq, SequencedBase, NextOutSeq);
+				Log.Out(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(NET__ERROR, _L "Post-OOA Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, 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);
 			}
 
 			if(NextSequencedSend > SequencedQueue.size()) {
-				_log(NET__ERROR, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Post-OOA Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 			}
 			MOutboundQueue.unlock();
 #endif
@@ -466,12 +466,12 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 		case OP_SessionStatRequest: {
 			if(p->Size() < sizeof(SessionStats))
 			{
-				_log(NET__ERROR, _L "Received OP_SessionStatRequest that was of malformed size" __L);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatRequest that was of malformed size" __L);
 				break;
 			}
 #ifndef COLLECTOR
 			SessionStats *Stats=(SessionStats *)p->pBuffer;
-			_log(NET__NET_TRACE, _L "Received Stats: %lu packets received, %lu packets sent, Deltas: local %lu, (%lu <- %lu -> %lu) remote %lu" __L,
+			Log.Out(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(Stats->packets_received), (unsigned long)ntohl(Stats->packets_sent), (unsigned long)ntohl(Stats->last_local_delta),
 				(unsigned long)ntohl(Stats->low_delta), (unsigned long)ntohl(Stats->average_delta),
 				(unsigned long)ntohl(Stats->high_delta), (unsigned long)ntohl(Stats->last_remote_delta));
@@ -492,18 +492,18 @@ void EQStream::ProcessPacket(EQProtocolPacket *p)
 					}
 					if(retransmittimeout > RETRANSMIT_TIMEOUT_MAX)
 						retransmittimeout = RETRANSMIT_TIMEOUT_MAX;
-					_log(NET__NET_TRACE, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Retransmit timeout recalculated to %dms" __L, retransmittimeout);
 				}
 			}
 #endif
 		}
 		break;
 		case OP_SessionStatResponse: {
-			_log(NET__NET_TRACE, _L "Received OP_SessionStatResponse. Ignoring." __L);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_SessionStatResponse. Ignoring." __L);
 		}
 		break;
 		case OP_OutOfSession: {
-			_log(NET__NET_TRACE, _L "Received OP_OutOfSession. Ignoring." __L);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Received OP_OutOfSession. Ignoring." __L);
 		}
 		break;
 		default:
@@ -534,7 +534,7 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 		return;
 
 	if(OpMgr == nullptr || *OpMgr == nullptr) {
-		_log(NET__DEBUG, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Packet enqueued into a stream with no opcode manager, dropping." __L);
 		delete pack;
 		return;
 	}
@@ -556,12 +556,24 @@ void EQStream::FastQueuePacket(EQApplicationPacket **p, bool ack_req)
 
 void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 {
-	uint32 chunksize,used;
+	uint32 chunksize, used;
 	uint32 length;
 
+	if (Log.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());
+		}
+	}
+
+	if (Log.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());
+		}
+	}
+
 	// 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(NET__FRAGMENT, _L "Making oversized packet, len %d" __L, p->size);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Making oversized packet, len %d" __L, p->size);
 
 		unsigned char *tmpbuff=new unsigned char[p->size+3];
 		length=p->serialize(opcode, tmpbuff);
@@ -570,7 +582,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 		*(uint32 *)(out->pBuffer+2)=htonl(p->Size());
 		used=MaxLen-10;
 		memcpy(out->pBuffer+6,tmpbuff,used);
-		_log(NET__FRAGMENT, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "First fragment: used %d/%d. Put size %d in the packet" __L, used, p->size, p->Size());
 		SequencedPush(out);
 
 
@@ -581,7 +593,7 @@ void EQStream::SendPacket(uint16 opcode, EQApplicationPacket *p)
 			out->size=chunksize+2;
 			SequencedPush(out);
 			used+=chunksize;
-			_log(NET__FRAGMENT, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Subsequent fragment: len %d, used %d/%d." __L, chunksize, used, p->size);
 		}
 		delete p;
 		delete[] tmpbuff;
@@ -605,22 +617,22 @@ void EQStream::SequencedPush(EQProtocolPacket *p)
 #else
 	MOutboundQueue.lock();
 if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	_log(NET__ERROR, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 }
 if(NextSequencedSend > SequencedQueue.size()) {
-	_log(NET__ERROR, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 }
 
-	_log(NET__APP_TRACE, _L "Pushing sequenced packet %d of length %d. Base Seq is %d." __L, NextOutSeq, p->size, SequencedBase);
+	Log.Out(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(NET__ERROR, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 }
 if(NextSequencedSend > SequencedQueue.size()) {
-	_log(NET__ERROR, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Push Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 }
 	MOutboundQueue.unlock();
 #endif
@@ -632,7 +644,7 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
 	delete p;
 #else
 	MOutboundQueue.lock();
-	_log(NET__APP_TRACE, _L "Pushing non-sequenced packet of length %d" __L, p->size);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pushing non-sequenced packet of length %d" __L, p->size);
 	NonSequencedQueue.push(p);
 	MOutboundQueue.unlock();
 #endif
@@ -641,14 +653,14 @@ void EQStream::NonSequencedPush(EQProtocolPacket *p)
 void EQStream::SendAck(uint16 seq)
 {
 uint16 Seq=htons(seq);
-	_log(NET__NET_ACKS, _L "Sending ack with sequence %d" __L, seq);
+	Log.Out(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(NET__APP_TRACE, _L "Sending out of order ack with sequence %d" __L, seq);
+	Log.Out(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)));
 }
@@ -664,7 +676,6 @@ void EQStream::Write(int eq_fd)
 	int32 threshold=RateThreshold;
 	MRate.unlock();
 	if (BytesWritten > threshold) {
-		//std::cout << "Over threshold: " << BytesWritten << " > " << threshold << std::endl;
 		return;
 	}
 
@@ -684,7 +695,7 @@ void EQStream::Write(int eq_fd)
 		// if we have a timeout defined and we have not received an ack recently enough, retransmit from beginning of queue
 		if (RETRANSMIT_TIMEOUT_MULT && !SequencedQueue.empty() && NextSequencedSend &&
 			(GetState()==ESTABLISHED) && ((retransmittimer+retransmittimeout) < Timer::GetCurrentTime())) {
-			_log(NET__NET_TRACE, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout since last ack received, starting retransmit at the start of our unacked "
 				"buffer (seq %d, was %d)." __L, SequencedBase, SequencedBase+NextSequencedSend);
 			NextSequencedSend = 0;
 			retransmittimer = Timer::GetCurrentTime(); // don't want to endlessly retransmit the first packet
@@ -705,24 +716,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(NET__NET_COMBINE, _L "Starting combined packet with non-seq packet of len %d" __L, p->size);
+				Log.Out(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())) {
 				// Tryint 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(NET__NET_COMBINE, _L "Combined packet full at len %d, next non-seq packet is len %d" __L, p->size, (NonSequencedQueue.front())->size);
+				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);
 				ReadyToSend.push(p);
 				BytesWritten+=p->size;
 				p=nullptr;
 
 				if (BytesWritten > threshold) {
 					// Sent enough this round, lets stop to be fair
-					_log(NET__RATES, _L "Exceeded write threshold in nonseq (%d > %d)" __L, BytesWritten, threshold);
+					Log.Out(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(NET__NET_COMBINE, _L "Combined non-seq packet of len %d, yeilding %d combined." __L, (NonSequencedQueue.front())->size, p->size);
+				Log.Out(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();
 			}
@@ -733,48 +744,48 @@ void EQStream::Write(int eq_fd)
 
 		if (sitr!=SequencedQueue.end()) {
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				_log(NET__ERROR, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Seq NSS=%d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, NextSequencedSend, SequencedBase, SequencedQueue.size(), NextOutSeq);
 			}
 
 			if(NextSequencedSend > SequencedQueue.size()) {
-				_log(NET__ERROR, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 			}
 			uint16 seq_send = SequencedBase + NextSequencedSend;	//just for logging...
 			
 			if(SequencedQueue.empty()) {
-				_log(NET__ERROR, _L "Tried to write a packet with an empty queue (%d is past next out %d)" __L, seq_send, NextOutSeq);
+				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);
 				SeqEmpty=true;
 				continue;
 			}
 
 			if(GetExecutablePlatform() == ExePlatformWorld || GetExecutablePlatform() == ExePlatformZone) {
 				if (!RETRANSMIT_ACKED_PACKETS && (*sitr)->acked) {
-					_log(NET__NET_TRACE, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Not retransmitting seq packet %d because already marked as acked" __L, seq_send);
 					sitr++;
 					NextSequencedSend++;
 				} 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(NET__NET_COMBINE, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					++sitr;
 					NextSequencedSend++;
 				} 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(NET__NET_COMBINE, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					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);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 
 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						_log(NET__RATES, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					_log(NET__NET_COMBINE, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
 					++sitr;
 					NextSequencedSend++;
 				}
@@ -783,35 +794,35 @@ void EQStream::Write(int eq_fd)
 					// 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(NET__NET_COMBINE, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Starting combined packet with seq packet %d of len %d" __L, seq_send, p->size);
 					++sitr;
 					NextSequencedSend++;
 				} 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(NET__NET_COMBINE, _L "Combined packet full at len %d, next seq packet %d is len %d" __L, p->size, seq_send, (*sitr)->size);
+					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);
 					ReadyToSend.push(p);
 					BytesWritten+=p->size;
 					p=nullptr;
 
 					if (BytesWritten > threshold) {
 						// Sent enough this round, lets stop to be fair
-						_log(NET__RATES, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
+						Log.Out(Logs::Detail, Logs::Netcode, _L "Exceeded write threshold in seq (%d > %d)" __L, BytesWritten, threshold);
 						break;
 					}
 				} else {
 					// Combine worked
-					_log(NET__NET_COMBINE, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
+					Log.Out(Logs::Detail, Logs::Netcode, _L "Combined seq packet %d of len %d, yeilding %d combined." __L, seq_send, (*sitr)->size, p->size);
 					++sitr;
 					NextSequencedSend++;
 				}
 			}
 
 			if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-				_log(NET__ERROR, _L "Post send Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, 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);
 			}
 			if(NextSequencedSend > SequencedQueue.size()) {
-				_log(NET__ERROR, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+				Log.Out(Logs::Detail, Logs::Netcode, _L "Post send Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 			}
 		} else {
 			// No more sequenced packets
@@ -823,7 +834,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(NET__NET_COMBINE, _L "Final combined packet not full, len %d" __L, p->size);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Final combined packet not full, len %d" __L, p->size);
 		ReadyToSend.push(p);
 		BytesWritten+=p->size;
 	}
@@ -840,7 +851,7 @@ void EQStream::Write(int eq_fd)
 	if(SeqEmpty && NonSeqEmpty) {
 		//no more data to send
 		if(CheckState(CLOSING)) {
-			_log(NET__DEBUG, _L "All outgoing data flushed, closing stream." __L );
+			Log.Out(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();
@@ -903,7 +914,7 @@ EQProtocolPacket *out=new EQProtocolPacket(OP_SessionResponse,nullptr,sizeof(Ses
 
 	out->size=sizeof(SessionResponse);
 
-	_log(NET__NET_TRACE, _L "Sending OP_SessionResponse: session %lu, maxlen=%d, key=0x%x, compressed? %s, encoded? %s" __L,
+	Log.Out(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);
@@ -917,7 +928,7 @@ EQProtocolPacket *out=new EQProtocolPacket(OP_SessionRequest,nullptr,sizeof(Sess
 	Request->Session=htonl(time(nullptr));
 	Request->MaxLength=htonl(512);
 
-	_log(NET__NET_TRACE, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionRequest: session %lu, maxlen=%d" __L, (unsigned long)ntohl(Request->Session), ntohl(Request->MaxLength));
 
 	NonSequencedPush(out);
 }
@@ -931,7 +942,7 @@ void EQStream::_SendDisconnect()
 	*(uint32 *)out->pBuffer=htonl(Session);
 	NonSequencedPush(out);
 
-	_log(NET__NET_TRACE, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Sending OP_SessionDisconnect: session %lu" __L, (unsigned long)Session);
 }
 
 void EQStream::InboundQueuePush(EQRawApplicationPacket *p)
@@ -953,15 +964,12 @@ EQRawApplicationPacket *p=nullptr;
 	}
 	MInboundQueue.unlock();
 
-	//resolve the opcode if we can.
+	if (p) {
-	if(p) {
+		if (OpMgr != nullptr && *OpMgr != nullptr) {
-		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
-#if EQDEBUG >= 4
+			if (emu_op == OP_Unknown) {
-			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(NET__ERROR, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
+			} 
-			}
-#endif
 			p->SetOpcode(emu_op);
 		}
 	}
@@ -985,11 +993,10 @@ EQRawApplicationPacket *p=nullptr;
 	if(p) {
 		if(OpMgr != nullptr && *OpMgr != nullptr) {
 			EmuOpcode emu_op = (*OpMgr)->EQToEmu(p->opcode);
-#if EQDEBUG >= 4
 			if(emu_op == OP_Unknown) {
-				LogFile->write(EQEMuLog::Debug, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
+				Log.Out(Logs::General, Logs::Netcode, "Unable to convert EQ opcode 0x%.4x to an Application opcode.", p->opcode);
 			}
-#endif
+
 			p->SetOpcode(emu_op);
 		}
 	}
@@ -1015,7 +1022,7 @@ void EQStream::InboundQueueClear()
 {
 EQApplicationPacket *p=nullptr;
 
-	_log(NET__APP_TRACE, _L "Clearing inbound queue" __L);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing inbound queue" __L);
 
 	MInboundQueue.lock();
 	if (!InboundQueue.empty()) {
@@ -1058,7 +1065,7 @@ void EQStream::OutboundQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	_log(NET__APP_TRACE, _L "Clearing outbound queue" __L);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing outbound queue" __L);
 
 	MOutboundQueue.lock();
 	while(!NonSequencedQueue.empty()) {
@@ -1080,7 +1087,7 @@ void EQStream::PacketQueueClear()
 {
 EQProtocolPacket *p=nullptr;
 
-	_log(NET__APP_TRACE, _L "Clearing future packet queue" __L);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Clearing future packet queue" __L);
 
 	if(!PacketQueue.empty()) {
 		std::map<unsigned short,EQProtocolPacket *>::iterator itr;
@@ -1112,8 +1119,7 @@ uint32 newlength=0;
 		delete p;
 		ProcessQueue();
 	} else {
-		_log(NET__DEBUG, _L "Incoming packet failed checksum" __L);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Incoming packet failed checksum" __L);
-		_hex(NET__NET_CREATE_HEX, buffer, length);
 	}
 }
 
@@ -1142,33 +1148,33 @@ std::deque<EQProtocolPacket *>::iterator itr, tmp;
 	MOutboundQueue.lock();
 //do a bit of sanity checking.
 if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	_log(NET__ERROR, _L "Pre-Ack Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Ack Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, SequencedBase, SequencedQueue.size(), NextOutSeq);
 }
 if(NextSequencedSend > SequencedQueue.size()) {
-	_log(NET__ERROR, _L "Pre-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Pre-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 }
 
 	SeqOrder ord = CompareSequence(SequencedBase, seq);
 	if(ord == SeqInOrder) {
 		//they are not acking anything new...
-		_log(NET__NET_ACKS, _L "Received an ack with no window advancement (seq %d)." __L, seq);
+		Log.Out(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(NET__NET_ACKS, _L "Received an ack with backward window advancement (they gave %d, our window starts at %d). This is bad." __L, seq, SequencedBase);
+		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);
 	} else {
-		_log(NET__NET_ACKS, _L "Received an ack up through sequence %d. Our base is %d." __L, seq, SequencedBase);
+		Log.Out(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(NET__ERROR, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
+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, NextSequencedSend);
 	SequencedBase = NextOutSeq;
 	NextSequencedSend = 0;
 	break;
 }
-			_log(NET__NET_ACKS, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Removing acked packet with sequence %lu. Next send is %d before this." __L, (unsigned long)SequencedBase, NextSequencedSend);
 			//clean out the acked packet
 			delete SequencedQueue.front();
 			SequencedQueue.pop_front();
@@ -1179,10 +1185,10 @@ _log(NET__ERROR, _L "OUT OF PACKETS acked packet with sequence %lu. Next send is
 			SequencedBase++;
 		}
 if(uint16(SequencedBase + SequencedQueue.size()) != NextOutSeq) {
-	_log(NET__ERROR, _L "Post-Ack on %d Invalid Sequenced queue: BS %d + SQ %d != NOS %d" __L, seq, 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);
 }
 if(NextSequencedSend > SequencedQueue.size()) {
-	_log(NET__ERROR, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Post-Ack Next Send Sequence is beyond the end of the queue NSS %d > SQ %d" __L, NextSequencedSend, SequencedQueue.size());
 }
 	}
 
@@ -1192,7 +1198,7 @@ if(NextSequencedSend > SequencedQueue.size()) {
 void EQStream::SetNextAckToSend(uint32 seq)
 {
 	MAcks.lock();
-	_log(NET__NET_ACKS, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Next Ack To Send to %lu" __L, (unsigned long)seq);
 	NextAckToSend=seq;
 	MAcks.unlock();
 }
@@ -1200,7 +1206,7 @@ void EQStream::SetNextAckToSend(uint32 seq)
 void EQStream::SetLastAckSent(uint32 seq)
 {
 	MAcks.lock();
-	_log(NET__NET_ACKS, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Set Last Ack Sent to %lu" __L, (unsigned long)seq);
 	LastAckSent=seq;
 	MAcks.unlock();
 }
@@ -1213,10 +1219,10 @@ void EQStream::ProcessQueue()
 
 	EQProtocolPacket *qp=nullptr;
 	while((qp=RemoveQueue(NextInSeq))!=nullptr) {
-		_log(NET__DEBUG, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Processing Queued Packet: Seq=%d" __L, NextInSeq);
 		ProcessPacket(qp);
 		delete qp;
-		_log(NET__APP_TRACE, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 }
 
@@ -1227,21 +1233,21 @@ EQProtocolPacket *qp=nullptr;
 	if ((itr=PacketQueue.find(seq))!=PacketQueue.end()) {
 		qp=itr->second;
 		PacketQueue.erase(itr);
-		_log(NET__APP_TRACE, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
+		Log.Out(Logs::Detail, Logs::Netcode, _L "OP_Packet Queue size=%d" __L, PacketQueue.size());
 	}
 	return qp;
 }
 
 void EQStream::SetStreamType(EQStreamType type)
 {
-	_log(NET__NET_TRACE, _L "Changing stream type from %s to %s" __L, StreamTypeString(StreamType), StreamTypeString(type));
+	Log.Out(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(NET__NET_TRACE, _L "Login stream has app opcode size %d, is not compressed or encoded." __L, app_opcode_size);
+			Log.Out(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:
@@ -1249,7 +1255,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=1;
 			compressed=false;
 			encoded=true;
-			_log(NET__NET_TRACE, _L "Chat/Mail stream has app opcode size %d, is not compressed, and is encoded." __L, app_opcode_size);
+			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);
 			break;
 		case ZoneStream:
 		case WorldStream:
@@ -1257,7 +1263,7 @@ void EQStream::SetStreamType(EQStreamType type)
 			app_opcode_size=2;
 			compressed=true;
 			encoded=false;
-			_log(NET__NET_TRACE, _L "World/Zone stream has app opcode size %d, is compressed, and is not encoded." __L, app_opcode_size);
+			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);
 			break;
 	}
 }
@@ -1307,7 +1313,7 @@ EQStream::SeqOrder EQStream::CompareSequence(uint16 expected_seq , uint16 seq)
 
 void EQStream::SetState(EQStreamState state) {
 	MState.lock();
-	_log(NET__NET_TRACE, _L "Changing state from %d to %d" __L, State, state);
+	Log.Out(Logs::Detail, Logs::Netcode, _L "Changing state from %d to %d" __L, State, state);
 	State=state;
 	MState.unlock();
 }
@@ -1319,29 +1325,29 @@ void EQStream::CheckTimeout(uint32 now, uint32 timeout) {
 
 	EQStreamState orig_state = GetState();
 	if (orig_state == CLOSING && !outgoing_data) {
-		_log(NET__NET_TRACE, _L "Out of data in closing state, disconnecting." __L);
+		Log.Out(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(NET__DEBUG, _L "Timeout expired in closing state. Moving to closed state." __L);
+			Log.Out(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(NET__DEBUG, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in disconnecting state. Moving to closed state." __L);
 			SetState(CLOSED);
 			break;
 		case CLOSED:
-			_log(NET__DEBUG, _L "Timeout expired in closed state??" __L);
+			Log.Out(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(NET__DEBUG, _L "Timeout expired in established state. Closing connection." __L);
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Timeout expired in established state. Closing connection." __L);
 			_SendDisconnect();
 			SetState(DISCONNECTING);
 			break;
@@ -1370,11 +1376,11 @@ void EQStream::AdjustRates(uint32 average_delta)
 			MRate.lock();
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
-			_log(NET__RATES, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log.Out(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(NET__RATES, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
+			Log.Out(Logs::Detail, Logs::Netcode, _L "Not adjusting data rate because avg delta over max (%d > %d)" __L, 
 				average_delta, AVERAGE_DELTA_MAX);
 		}
 	} else {
@@ -1382,7 +1388,7 @@ void EQStream::AdjustRates(uint32 average_delta)
 			MRate.lock();
 			RateThreshold=RATEBASE/average_delta;
 			DecayRate=DECAYBASE/average_delta;
-			_log(NET__RATES, _L "Adjusting data rate to thresh %d, decay %d based on avg delta %d" __L, 
+			Log.Out(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();
 		}
@@ -1392,12 +1398,12 @@ void EQStream::AdjustRates(uint32 average_delta)
 void EQStream::Close() {
 	if(HasOutgoingData()) {
 		//there is pending data, wait for it to go out.
-		_log(NET__DEBUG, _L "Stream requested to Close(), but there is pending data, waiting for it." __L);
+		Log.Out(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(NET__DEBUG, _L "Stream closing immediate due to Close()" __L);
+		Log.Out(Logs::Detail, Logs::Netcode, _L "Stream closing immediate due to Close()" __L);
 		SetState(DISCONNECTING);
 	}
 }
@@ -1425,19 +1431,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(NET__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.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);
 				res = MatchSuccessful;
 			} else if(sig->first_length == 0) {
-				_log(NET__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.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);
 				res = MatchSuccessful;
 			} else {
 				//opcode matched but length did not.
-				_log(NET__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.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);
 				res = MatchFailed;
 			}
 		} else {
 			//first opcode did not match..
-			_log(NET__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.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);
 			res = MatchFailed;
 		}
 	}

common/eq_stream.h

@@ -206,8 +206,14 @@ class EQStream : public EQStreamInterface {
 
 		void init(bool resetSession=true);
 	public:
-		EQStream() { init(); remote_ip = 0; remote_port = 0; State=UNESTABLISHED; StreamType=UnknownStream; compressed=true; encoded=false; app_opcode_size=2; bytes_sent=0; bytes_recv=0; create_time=Timer::GetTimeSeconds(); sessionAttempts = 0; streamactive=false; }
+		EQStream() { init(); remote_ip = 0; remote_port = 0; State = UNESTABLISHED; 
-		EQStream(sockaddr_in addr) { init(); remote_ip=addr.sin_addr.s_addr; remote_port=addr.sin_port; State=UNESTABLISHED; StreamType=UnknownStream; compressed=true; encoded=false; app_opcode_size=2; bytes_sent=0; bytes_recv=0; create_time=Timer::GetTimeSeconds(); }
+			StreamType = UnknownStream; compressed = true; encoded = false; app_opcode_size = 2; 
+			bytes_sent = 0; bytes_recv = 0; create_time = Timer::GetTimeSeconds(); sessionAttempts = 0; 
+			streamactive = false; }
+		EQStream(sockaddr_in addr) { init(); remote_ip = addr.sin_addr.s_addr; 
+			remote_port = addr.sin_port; State = UNESTABLISHED; StreamType = UnknownStream; 
+			compressed = true; encoded = false; app_opcode_size = 2; bytes_sent = 0; bytes_recv = 0; 
+			create_time = Timer::GetTimeSeconds(); }
 		virtual ~EQStream() { RemoveData(); SetState(CLOSED); }
 		void SetMaxLen(uint32 length) { MaxLen=length; }
 

common/eq_stream_factory.cpp

@@ -1,4 +1,5 @@
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "eq_stream_factory.h"
 
 #ifdef _WINDOWS
@@ -25,13 +26,13 @@ ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->ReaderLoop();
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -42,13 +43,13 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->WriterLoop();
 
 #ifndef WIN32
-	_log(COMMON__THREADS, "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -105,8 +106,6 @@ struct sockaddr_in address;
 		fcntl(sock, F_SETFL, O_NONBLOCK);
 	#endif
 	//moved these because on windows the output was delayed and causing the console window to look bad
-	//std::cout << "Starting factory Reader" << std::endl;
-	//std::cout << "Starting factory Writer" << std::endl;
 	#ifdef _WINDOWS
 		_beginthread(EQStreamFactoryReaderLoop,0, this);
 		_beginthread(EQStreamFactoryWriterLoop,0, this);
@@ -117,44 +116,39 @@ struct sockaddr_in address;
 	return true;
 }
 
-EQStream *EQStreamFactory::Pop()
+std::shared_ptr<EQStream> EQStreamFactory::Pop()
 {
-EQStream *s=nullptr;
+	std::shared_ptr<EQStream> s = nullptr;
-	//std::cout << "Pop():Locking MNewStreams" << std::endl;
 	MNewStreams.lock();
 	if (NewStreams.size()) {
-		s=NewStreams.front();
+		s = NewStreams.front();
 		NewStreams.pop();
 		s->PutInUse();
 	}
 	MNewStreams.unlock();
-	//std::cout << "Pop(): Unlocking MNewStreams" << std::endl;
 
 	return s;
 }
 
-void EQStreamFactory::Push(EQStream *s)
+void EQStreamFactory::Push(std::shared_ptr<EQStream> s)
 {
-	//std::cout << "Push():Locking MNewStreams" << std::endl;
 	MNewStreams.lock();
 	NewStreams.push(s);
 	MNewStreams.unlock();
-	//std::cout << "Push(): Unlocking MNewStreams" << std::endl;
 }
 
 void EQStreamFactory::ReaderLoop()
 {
-fd_set readset;
+	fd_set readset;
-std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-int num;
+	int num;
-int length;
+	int length;
-unsigned char buffer[2048];
+	unsigned char buffer[2048];
-sockaddr_in from;
+	sockaddr_in from;
-int socklen=sizeof(sockaddr_in);
+	int socklen = sizeof(sockaddr_in);
-timeval sleep_time;
+	timeval sleep_time;
-//time_t now;
+	ReaderRunning = true;
 
-	ReaderRunning=true;
 	while(sock!=-1) {
 		MReaderRunning.lock();
 		if (!ReaderRunning)
@@ -185,10 +179,10 @@ timeval sleep_time;
 				// What do we wanna do?
 			} else {
 				MStreams.lock();
-				stream_itr=Streams.find(std::make_pair(from.sin_addr.s_addr, from.sin_port));
+				stream_itr = Streams.find(std::make_pair(from.sin_addr.s_addr, from.sin_port));
 				if (stream_itr == Streams.end()) {
 					if (buffer[1]==OP_SessionRequest) {
-						EQStream *s = new EQStream(from);
+						std::shared_ptr<EQStream> s = std::make_shared<EQStream>(from);
 						s->SetStreamType(StreamType);
 						Streams[std::make_pair(from.sin_addr.s_addr, from.sin_port)]=s;
 						WriterWork.Signal();
@@ -199,13 +193,13 @@ timeval sleep_time;
 					}
 					MStreams.unlock();
 				} else {
-					EQStream *curstream = stream_itr->second;
+					std::shared_ptr<EQStream> curstream = stream_itr->second;
 					//dont bother processing incoming packets for closed connections
 					if(curstream->CheckClosed())
 						curstream = nullptr;
 					else
 						curstream->PutInUse();
-					MStreams.unlock();	//the in use flag prevents the stream from being deleted while we are using it.
+						//the in use flag prevents the stream from being deleted while we are using it.
 
 					if(curstream) {
 						curstream->AddBytesRecv(length);
@@ -213,6 +207,7 @@ timeval sleep_time;
 						curstream->SetLastPacketTime(Timer::GetCurrentTime());
 						curstream->ReleaseFromUse();
 					}
+					MStreams.unlock();
 				}
 			}
 		}
@@ -225,10 +220,10 @@ void EQStreamFactory::CheckTimeout()
 	MStreams.lock();
 
 	unsigned long now=Timer::GetCurrentTime();
-	std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
 
-	for(stream_itr=Streams.begin();stream_itr!=Streams.end();) {
+	for(stream_itr = Streams.begin(); stream_itr != Streams.end();) {
-		EQStream *s = stream_itr->second;
+		std::shared_ptr<EQStream> s = stream_itr->second;
 
 		s->CheckTimeout(now, stream_timeout);
 
@@ -240,11 +235,9 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				//std::cout << "Removing connection" << std::endl;
+				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
-				std::map<std::pair<uint32, uint16>,EQStream *>::iterator temp=stream_itr;
 				++stream_itr;
-				//let whoever has the stream outside delete it
+				temp->second = nullptr;
-				delete temp->second;
 				Streams.erase(temp);
 				continue;
 			}
@@ -257,21 +250,17 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-bool havework=true;
+	bool havework=true;
-std::vector<EQStream *> wants_write;
+	std::vector<std::shared_ptr<EQStream>> wants_write;
-std::vector<EQStream *>::iterator cur,end;
+	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
-bool decay=false;
+	bool decay = false;
-uint32 stream_count;
+	uint32 stream_count;
-
+	Timer DecayTimer(20);
-Timer DecayTimer(20);
+	WriterRunning = true;
-
-	WriterRunning=true;
 	DecayTimer.Enable();
+
 	while(sock!=-1) {
-		//if (!havework) {
-			//WriterWork.Wait();
-		//}
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -315,12 +304,10 @@ Timer DecayTimer(20);
 		Sleep(10);
 
 		MStreams.lock();
-		stream_count=Streams.size();
+		stream_count = Streams.size();
 		MStreams.unlock();
 		if (!stream_count) {
-			//std::cout << "No streams, waiting on condition" << std::endl;
 			WriterWork.Wait();
-			//std::cout << "Awake from condition, must have a stream now" << std::endl;
 		}
 	}
 }

common/eq_stream_factory.h

@@ -2,6 +2,7 @@
 
 #define _EQSTREAMFACTORY_H
 
+#include <memory>
 #include <queue>
 #include <map>
 
@@ -26,10 +27,10 @@ class EQStreamFactory : private Timeoutable {
 
 		EQStreamType StreamType;
 
-		std::queue<EQStream *> NewStreams;
+		std::queue<std::shared_ptr<EQStream>> NewStreams;
 		Mutex MNewStreams;
 
-		std::map<std::pair<uint32, uint16>,EQStream *> Streams;
+		std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>> Streams;
 		Mutex MStreams;
 
 		virtual void CheckTimeout();
@@ -42,8 +43,8 @@ class EQStreamFactory : private Timeoutable {
 		EQStreamFactory(EQStreamType type, uint32 timeout = 135000) : Timeoutable(5000), stream_timeout(timeout) { ReaderRunning=false; WriterRunning=false; StreamType=type; sock=-1; }
 		EQStreamFactory(EQStreamType type, int port, uint32 timeout = 135000);
 
-		EQStream *Pop();
+		std::shared_ptr<EQStream> Pop();
-		void Push(EQStream *s);
+		void Push(std::shared_ptr<EQStream> s);
 
 		bool Open();
 		bool Open(unsigned long port) { Port=port; return Open(); }

common/eq_stream_ident.cpp

@@ -1,20 +1,20 @@
-#include "debug.h"
+#include "global_define.h"
+#include "eqemu_logsys.h"
 #include "eq_stream_ident.h"
 #include "eq_stream_proxy.h"
-#include "logsys.h"
+
 
 EQStreamIdentifier::~EQStreamIdentifier() {
 	while(!m_identified.empty()) {
 		m_identified.front()->ReleaseFromUse();
 		m_identified.pop();
 	}
-	std::vector<Record *>::iterator cur, end;
+	std::vector<Record>::iterator cur, end;
 	cur = m_streams.begin();
 	end = m_streams.end();
 	for(; cur != end; ++cur) {
-		Record *r = *cur;
+		Record &r = *cur;
-		r->stream->ReleaseFromUse();
+		r.stream->ReleaseFromUse();
-		delete r;
 	}
 	std::vector<Patch *>::iterator curp, endp;
 	curp = m_patches.begin();
@@ -34,54 +34,52 @@ void EQStreamIdentifier::RegisterPatch(const EQStream::Signature &sig, const cha
 }
 
 void EQStreamIdentifier::Process() {
-	std::vector<Record *>::iterator cur;
+	std::vector<Record>::iterator cur;
 	std::vector<Patch *>::iterator curp, endp;
 
 	//foreach pending stream.
 	cur = m_streams.begin();
 	while(cur != m_streams.end()) {
-		Record *r = *cur;
+		Record &r = *cur;
 
 		//first see if this stream has expired
-		if(r->expire.Check(false)) {
+		if(r.expire.Check(false)) {
 			//this stream has failed to match any pattern in our timeframe.
-			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before timeout.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			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();
+			r.stream->ReleaseFromUse();
-			delete r;
 			cur = m_streams.erase(cur);
 			continue;
 		}
 
 		//then make sure the stream is still active
 		//if stream hasn't finished initializing then continue;
-		if(r->stream->GetState() == UNESTABLISHED)
+		if(r.stream->GetState() == UNESTABLISHED)
 		{
 			++cur;
 			continue;
 		}
-		if(r->stream->GetState() != ESTABLISHED) {
+		if(r.stream->GetState() != ESTABLISHED) {
 			//the stream closed before it was identified.
-			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before it closed.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			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()));
-			switch(r->stream->GetState())
+			switch(r.stream->GetState())
 			{
 			case ESTABLISHED:
-				_log(NET__IDENTIFY, "Stream state was Established");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
 				break;
 			case CLOSING:
-				_log(NET__IDENTIFY, "Stream state was Closing");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				_log(NET__IDENTIFY, "Stream state was Disconnecting");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				_log(NET__IDENTIFY, "Stream state was Closed");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
 				break;
 			default:
-				_log(NET__IDENTIFY, "Stream state was Unestablished or unknown");
+				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
 				break;
 			}
-			r->stream->ReleaseFromUse();
+			r.stream->ReleaseFromUse();
-			delete r;
 			cur = m_streams.erase(cur);
 			continue;
 		}
@@ -98,23 +96,23 @@ 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);
+			EQStream::MatchState res = r.stream->CheckSignature(&p->signature);
 			switch(res) {
 			case EQStream::MatchNotReady:
 				//the stream has not received enough packets to compare with this signature
-//				_log(NET__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());
+//				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: {
 				//yay, a match.
 
-				_log(NET__IDENTIFY, "Identified stream %s:%d with signature %s", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
+				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());
 
 				// 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);
+				r.stream->SetActive(true);
 
 				//might want to do something less-specific here... some day..
-				EQStreamInterface *s = new EQStreamProxy(r->stream, p->structs, p->opcodes);
+				EQStreamInterface *s = new EQStreamProxy(r.stream, p->structs, p->opcodes);
 				m_identified.push(s);
 
 				found_one = true;
@@ -122,7 +120,7 @@ void EQStreamIdentifier::Process() {
 			}
 			case EQStream::MatchFailed:
 				//do nothing...
-				_log(NET__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.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());
 				break;
 			}
 		}
@@ -130,14 +128,13 @@ 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(NET__IDENTIFY, "Unable to identify stream from %s:%d, no match found.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			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()));
-			r->stream->ReleaseFromUse();
+			r.stream->ReleaseFromUse();
 		}
 
 		//if we found a match, or were not able to identify it
 		if(found_one || all_ready) {
-			//cannot print ip/port here. r->stream is invalid.
+			//cannot print ip/port here. r.stream is invalid.
-			delete r;
 			cur = m_streams.erase(cur);
 		} else {
 			++cur;
@@ -145,8 +142,8 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }
 
-void EQStreamIdentifier::AddStream(EQStream *&eqs) {
+void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
-	m_streams.push_back(new Record(eqs));
+	m_streams.push_back(Record(eqs));
 	eqs = nullptr;
 }
 
@@ -158,7 +155,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }
 
-EQStreamIdentifier::Record::Record(EQStream *s)
+EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
 :	stream(s),
 	expire(STREAM_IDENT_WAIT_MS)
 {

common/eq_stream_ident.h

@@ -5,6 +5,7 @@
 #include "timer.h"
 #include <vector>
 #include <queue>
+#include <memory>
 
 #define STREAM_IDENT_WAIT_MS 10000
 
@@ -21,7 +22,7 @@ public:
 
 	//main processing interface
 	void Process();
-	void AddStream(EQStream *& eqs);
+	void AddStream(std::shared_ptr<EQStream> &eqs);
 	EQStreamInterface *PopIdentified();
 
 protected:
@@ -39,11 +40,11 @@ protected:
 	//pending streams..
 	class Record {
 	public:
-		Record(EQStream *s);
+		Record(std::shared_ptr<EQStream> s);
-		EQStream *stream;		//we own this
+		std::shared_ptr<EQStream> stream;		//we own this
 		Timer expire;
 	};
-	std::vector<Record *> m_streams;	//we own these objects, and the streams contained in them.
+	std::vector<Record> m_streams;	//we own these objects, and the streams contained in them.
 	std::queue<EQStreamInterface *> m_identified;	//we own these objects
 };
 

common/eq_stream_intf.h

@@ -35,7 +35,7 @@ public:
 	virtual const uint32 GetBytesRecieved() const { return 0; }
 	virtual const uint32 GetBytesSentPerSecond() const { return 0; }
 	virtual const uint32 GetBytesRecvPerSecond() const { return 0; }
-	virtual const EQClientVersion ClientVersion() const { return EQClientUnknown; }
+	virtual const ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -1,11 +1,11 @@
 
-#include "debug.h"
+#include "global_define.h"
 #include "eq_stream_proxy.h"
 #include "eq_stream.h"
 #include "struct_strategy.h"
 
 
-EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -15,16 +15,15 @@ EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, O
 }
 
 EQStreamProxy::~EQStreamProxy() {
-	//delete m_stream;	//released by the stream factory.
 }
 
 std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const EQClientVersion EQStreamProxy::ClientVersion() const
+const ClientVersion EQStreamProxy::GetClientVersion() const
 {
-	return m_structs->ClientVersion();
+	return m_structs->GetClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
@@ -85,12 +84,6 @@ const uint32 EQStreamProxy::GetBytesRecvPerSecond() const
 
 void EQStreamProxy::ReleaseFromUse() {
 	m_stream->ReleaseFromUse();
-
-	//this is so ugly, but I cant think of a better way to deal with
-	//it right now...
-	if(!m_stream->IsInUse()) {
-		delete this;
-	}
 }
 
 void EQStreamProxy::RemoveData() {

common/eq_stream_proxy.h

@@ -4,8 +4,9 @@
 
 #include "types.h"
 #include "eq_stream_intf.h"
+#include "eq_stream.h"
+#include <memory>
 
-class EQStream;
 class StructStrategy;
 class OpcodeManager;
 class EQApplicationPacket;
@@ -13,7 +14,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();
 
 	//EQStreamInterface:
@@ -27,7 +28,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const EQClientVersion ClientVersion() const;
+	virtual const ClientVersion GetClientVersion() const;
 
 	virtual const uint32 GetBytesSent() const;
 	virtual const uint32 GetBytesRecieved() const;
@@ -35,7 +36,7 @@ public:
 	virtual const uint32 GetBytesRecvPerSecond() const;
 
 protected:
-	EQStream *const					m_stream;	//we own this stream object.
+	std::shared_ptr<EQStream> 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.

common/eqdb.cpp

@@ -15,7 +15,7 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
+#include "global_define.h"
 #include "eqdb.h"
 #include "database.h"
 #include <mysql.h>

common/eqdb_res.cpp

@@ -15,7 +15,7 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-#include "debug.h"
+#include "global_define.h"
 #include "eqdb_res.h"
 #include <mysql.h>
 

common/eqemu_config.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "../common/debug.h"
+#include "../common/global_define.h"
 #include "eqemu_config.h"
 #include "misc_functions.h"
 
@@ -277,10 +277,6 @@ void EQEmuConfig::do_files(TiXmlElement *ele)
 	if (text) {
 		OpCodesFile = text;
 	}
-	text = ParseTextBlock(ele, "logsettings", true);
-	if (text) {
-		LogSettingsFile = text;
-	}
 	text = ParseTextBlock(ele, "eqtime", true);
 	if (text) {
 		EQTimeFile = text;
@@ -438,9 +434,6 @@ std::string EQEmuConfig::GetByName(const std::string &var_name) const
 	if (var_name == "EQTimeFile") {
 		return (EQTimeFile);
 	}
-	if (var_name == "LogSettingsFile") {
-		return (LogSettingsFile);
-	}
 	if (var_name == "MapDir") {
 		return (MapDir);
 	}
@@ -512,7 +505,6 @@ void EQEmuConfig::Dump() const
 	std::cout << "SpellsFile = " << SpellsFile << std::endl;
 	std::cout << "OpCodesFile = " << OpCodesFile << std::endl;
 	std::cout << "EQTimeFile = " << EQTimeFile << std::endl;
-	std::cout << "LogSettingsFile = " << LogSettingsFile << std::endl;
 	std::cout << "MapDir = " << MapDir << std::endl;
 	std::cout << "QuestDir = " << QuestDir << std::endl;
 	std::cout << "PluginDir = " << PluginDir << std::endl;

common/eqemu_config.h

@@ -86,7 +86,6 @@ class EQEmuConfig : public XMLParser
 		std::string SpellsFile;
 		std::string OpCodesFile;
 		std::string EQTimeFile;
-		std::string LogSettingsFile;
 
 		// From <directories/>
 		std::string MapDir;
@@ -162,7 +161,6 @@ class EQEmuConfig : public XMLParser
 			SpellsFile = "spells_us.txt";
 			OpCodesFile = "opcodes.conf";
 			EQTimeFile = "eqtime.cfg";
-			LogSettingsFile = "log.ini";
 			// Dirs
 			MapDir = "Maps";
 			QuestDir = "quests";

common/eqemu_error.cpp

@@ -1,135 +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
-*/
-#ifdef _WINDOWS
-#include <windows.h>
-#endif
-#include "eqemu_error.h"
-#include "linked_list.h"
-#include "mutex.h"
-#include "misc_functions.h"
-#include <stdio.h>
-#include <string.h>
-#ifdef _WINDOWS
-	#include <conio.h>
-#endif
-
-void UpdateWindowTitle(char* iNewTitle = 0);
-void CatchSignal(int sig_num);
-
-const char* EQEMuErrorText[EQEMuError_MaxErrorID] = { "ErrorID# 0, No Error",
-	"MySQL Error #1405 or #2001 means your mysql server rejected the username and password you presented it.",
-	"MySQL Error #2003 means you were unable to connect to the mysql server.",
-	"MySQL Error #2005 means you there are too many connections on the mysql server. The server is overloaded.",
-	"MySQL Error #2007 means you the server is out of memory. The server is overloaded.",
-	};
-
-LinkedList<char*>* EQEMuErrorList;
-Mutex* MEQEMuErrorList;
-AutoDelete< LinkedList<char*> > ADEQEMuErrorList(&EQEMuErrorList);
-AutoDelete<Mutex> ADMEQEMuErrorList(&MEQEMuErrorList);
-
-const char* GetErrorText(uint32 iError) {
-	if (iError >= EQEMuError_MaxErrorID)
-		return "ErrorID# out of range";
-	else
-		return EQEMuErrorText[iError];
-}
-
-void AddEQEMuError(eEQEMuError iError, bool iExitNow) {
-	if (!iError)
-		return;
-	if (!EQEMuErrorList) {
-		EQEMuErrorList = new LinkedList<char*>;
-		MEQEMuErrorList = new Mutex;
-	}
-	LockMutex lock(MEQEMuErrorList);
-
-	LinkedListIterator<char*> iterator(*EQEMuErrorList);
-	iterator.Reset();
-	while (iterator.MoreElements()) {
-		if (iterator.GetData()[0] == 1) {
-//Umm... this gets a big WTF...
-//			if (*((uint32*) iterator.GetData()[1]) == iError)
-//not sure whats going on, using a character as a pointer....
-			if (*((eEQEMuError*) &(iterator.GetData()[1])) == iError)
-				return;
-		}
-		iterator.Advance();
-	}
-
-	char* tmp = new char[6];
-	tmp[0] = 1;
-	tmp[5] = 0;
-	*((uint32*) &tmp[1]) = iError;
-	EQEMuErrorList->Append(tmp);
-
-	if (iExitNow)
-		CatchSignal(2);
-}
-
-void AddEQEMuError(char* iError, bool iExitNow) {
-	if (!iError)
-		return;
-	if (!EQEMuErrorList) {
-		EQEMuErrorList = new LinkedList<char*>;
-		MEQEMuErrorList = new Mutex;
-	}
-	LockMutex lock(MEQEMuErrorList);
-	char* tmp = strcpy(new char[strlen(iError) + 1], iError);
-	EQEMuErrorList->Append(tmp);
-
-	if (iExitNow)
-		CatchSignal(2);
-}
-
-uint32 CheckEQEMuError() {
-	if (!EQEMuErrorList)
-		return 0;
-	uint32 ret = 0;
-	char* tmp = 0;
-	bool HeaderPrinted = false;
-	LockMutex lock(MEQEMuErrorList);
-
-	while ((tmp = EQEMuErrorList->Pop() )) {
-		if (!HeaderPrinted) {
-			fprintf(stdout, "===============================\nRuntime errors:\n\n");
-			HeaderPrinted = true;
-		}
-		if (tmp[0] == 1) {
-			fprintf(stdout, "%s\n", GetErrorText(*((uint32*) &tmp[1])));
-			fprintf(stdout, "For more information on this error, visit http://www.eqemu.net/eqemuerror.php?id=%u\n\n", *((uint32*) &tmp[1]));
-		}
-		else {
-			fprintf(stdout, "%s\n\n", tmp);
-		}
-		safe_delete(tmp);
-		ret++;
-	}
-	return ret;
-}
-
-void CheckEQEMuErrorAndPause() {
-#ifdef _WINDOWS
-	if (CheckEQEMuError()) {
-		fprintf(stdout, "Hit any key to exit\n");
-		UpdateWindowTitle("Error");
-		getch();
-	}
-#endif
-}
-

common/eqemu_error.h

@@ -1,36 +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
-*/
-#ifndef EQEMuError_H
-#define EQEMuError_H
-
-#include "../common/types.h"
-
-enum eEQEMuError { EQEMuError_NoError,
-	EQEMuError_Mysql_1405,
-	EQEMuError_Mysql_2003,
-	EQEMuError_Mysql_2005,
-	EQEMuError_Mysql_2007,
-	EQEMuError_MaxErrorID };
-
-void AddEQEMuError(eEQEMuError iError, bool iExitNow = false);
-void AddEQEMuError(char* iError, bool iExitNow = false);
-uint32 CheckEQEMuError();
-void CheckEQEMuErrorAndPause();
-
-#endif
-

common/eqemu_logsys.cpp

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

common/eqemu_logsys.h

@@ -0,0 +1,204 @@
+/*	EQEMu: Everquest Server Emulator
+	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; version 2 of the License.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY except by those people which sell it, which
+	are required to give you total support for your newly bought product;
+	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to the Free Software
+	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef EQEMU_LOGSYS_H
+#define EQEMU_LOGSYS_H
+
+#include <iostream>
+#include <fstream>
+#include <stdio.h>
+#include <functional>
+
+#include "types.h"
+
+namespace Logs {
+	enum DebugLevel {
+		General = 1,	/* 1 - Low-Level general debugging, useful info on single line */
+		Moderate,		/* 2 - Informational based, used in functions, when particular things load */
+		Detail			/* 3 - Use this for extreme detail in logging, usually in extreme debugging in the stack or interprocess communication */
+	};
+
+	/*
+		If you add to this, make sure you update LogCategoryName
+		NOTE: Only add to the bottom of the enum because that is the type ID assignment
+	*/
+
+	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,
+		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)",
+	};
+}
+
+class EQEmuLogSys {
+public:
+	EQEmuLogSys();
+	~EQEmuLogSys();
+
+	void CloseFileLogs(); /* Close File Logs wherever necessary, either at zone shutdown or entire process shutdown for everything else. This should be handled on deconstructor but to be safe we use it anyways. */
+	void LoadLogSettingsDefaults(); /* Initializes log_settings and sets some defaults if DB is not present */
+	void MakeDirectory(const std::string &directory_name); /* Platform independent way of performing a MakeDirectory based on name */
+	/*
+		The one and only Logging function that uses a debug level as a parameter, as well as a log_category
+		log_category - defined in Logs::LogCategory::[]
+		log_category name resolution works by passing the enum int ID to Logs::LogCategoryName[category_id]
+
+		Example: EQEmuLogSys::Out(Logs::General, Logs::Guilds, "This guild has no leader present");
+			- This would pipe the same category and debug level to all output formats, but the internal memory reference of log_settings would
+				be checked against to see if that piped output is set to actually process it for the category and debug level
+	*/
+	void Out(Logs::DebugLevel debug_level, uint16 log_category, std::string message, ...);
+	void SetCurrentTimeStamp(char* time_stamp); /* Used in file logs to prepend a timestamp entry for logs */ 
+	void StartFileLogs(const std::string &log_name = ""); /* Used to declare the processes file log and to keep it open for later use */
+
+	/*
+		LogSettings Struct
+
+		This struct is the master reference for all settings for each category, and for each output
+
+		log_to_file[category_id] = [1-3] - Sets debug level for category to output to file
+		log_to_console[category_id] = [1-3] - Sets debug level for category to output to console
+		log_to_gmsay[category_id] = [1-3] - Sets debug level for category to output to gmsay
+	*/
+
+	struct LogSettings {
+		uint8 log_to_file;
+		uint8 log_to_console;
+		uint8 log_to_gmsay;
+		uint8 is_category_enabled; /* When any log output in a category > 0, set this to 1 as (Enabled) */
+	};
+
+	/* Internally used memory reference for all log settings per category.
+		These are loaded via DB and have defaults loaded in LoadLogSettingsDefaults.
+		Database loaded via Database::LoadLogSettings(log_settings)
+	*/
+	LogSettings log_settings[Logs::LogCategory::MaxCategoryID];
+
+	bool file_logs_enabled; /* Set when log settings are loaded to determine if keeping a file open is necessary */
+
+	int log_platform; /* Sets Executable platform (Zone/World/UCS) etc. */
+
+	std::string platform_file_name; /* File name used in writing logs */
+
+	uint16 GetGMSayColorFromCategory(uint16 log_category); /* GMSay Client Message colors mapped by category */
+
+	void OnLogHookCallBackZone(std::function<void(uint16 log_type, const std::string&)> f) { on_log_gmsay_hook = f; }
+
+private:
+	std::function<void(uint16 log_category, const std::string&)> on_log_gmsay_hook; /* Callback pointer to zone process for hooking logs to zone using GMSay */
+	std::string FormatOutMessageString(uint16 log_category, const std::string &in_message); /* Formats log messages like '[Category] This is a log message' */
+	std::string GetLinuxConsoleColorFromCategory(uint16 log_category); /* Linux console color messages mapped by category */
+
+	uint16 GetWindowsConsoleColorFromCategory(uint16 log_category); /* Windows console color messages mapped by category */
+
+	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 */
+};
+
+extern EQEmuLogSys Log;
+
+#endif

common/eqtime.cpp

@@ -17,7 +17,8 @@
 */
 
 #include <fstream>
-#include "../common/debug.h"
+#include "../common/global_define.h"
+#include "../common/eqemu_logsys.h"
 #include "../common/eqtime.h"
 #include "../common/eq_packet_structs.h"
 #include <memory.h>
@@ -140,11 +141,10 @@ bool EQTime::saveFile(const char *filename)
 	of.open(filename);
 	if(!of)
 	{
-		LogFile->write(EQEMuLog::Error, "EQTime::saveFile failed: Unable to open file '%s'", filename);
+		Log.Out(Logs::General, Logs::Error, "EQTime::saveFile failed: Unable to open file '%s'", filename);
 		return false;
 	}
 	//Enable for debugging
-	//std::cout << "SAVE: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl;
 	of << EQT_VERSION << std::endl;
 	of << (long)eqTime.start_eqtime.day << std::endl;
 	of << (long)eqTime.start_eqtime.hour << std::endl;
@@ -164,14 +164,14 @@ bool EQTime::loadFile(const char *filename)
 	in.open(filename);
 	if(!in)
 	{
-		LogFile->write(EQEMuLog::Error, "Could not load EQTime file %s", filename);
+		Log.Out(Logs::General, Logs::Error, "Could not load EQTime file %s", filename);
 		return false;
 	}
 	in >> version;
 	in.ignore(80, '\n');
 	if(version != EQT_VERSION)
 	{
-		LogFile->write(EQEMuLog::Error, "'%s' is NOT a valid EQTime file. File version is %i, EQTime version is %i", filename, version, EQT_VERSION);
+		Log.Out(Logs::General, Logs::Error, "'%s' is NOT a valid EQTime file. File version is %i, EQTime version is %i", filename, version, EQT_VERSION);
 		return false;
 	}
 	//in >> eqTime.start_eqtime.day;
@@ -194,7 +194,6 @@ bool EQTime::loadFile(const char *filename)
 	in.ignore(80, '\n');
 	in >> eqTime.start_realtime;
 	//Enable for debugging...
-	//std::cout << "LOAD: day=" << (long)eqTime.start_eqtime.day << ";hour=" << (long)eqTime.start_eqtime.hour << ";min=" << (long)eqTime.start_eqtime.minute << ";mon=" << (long)eqTime.start_eqtime.month << ";yr=" << eqTime.start_eqtime.year << ";timet=" << eqTime.start_realtime << std::endl;
 	in.close();
 	return true;
 }

common/extprofile.cpp

@@ -16,7 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "debug.h"
+#include "global_define.h"
 #include "extprofile.h"
 
 //Set defaults in the extended profile...

common/glm/glm/CMakeLists.txt

@@ -30,11 +30,13 @@ source_group("GTX Files" FILES ${GTX_HEADER})
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-add_executable(${NAME} ${ROOT_TEXT}
+if(GLM_TEST_ENABLE)
-	${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
+	add_executable(${NAME} ${ROOT_TEXT}
-	${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-	${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
+		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-	${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+endif(GLM_TEST_ENABLE)
 
 #add_library(glm STATIC glm.cpp)
 #add_library(glm_shared SHARED glm.cpp)

common/glm/glm/common.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -26,9 +30,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_COMMON_INCLUDED
+#pragma once
-#define GLM_COMMON_INCLUDED
 
 #include "detail/func_common.hpp"
-
-#endif//GLM_COMMON_INCLUDED

common/glm/glm/detail/_features.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_features.hpp
+/// @file glm/detail/_features.hpp
 /// @date 2013-02-20 / 2013-02-20
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_features
+#pragma once
-#define glm_core_features
 
 // #define GLM_CXX98_EXCEPTIONS
 // #define GLM_CXX98_RTTI
@@ -281,7 +284,7 @@
 #		define GLM_CXX11_STATIC_ASSERT
 #	endif
 
-#elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#elif(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
 #	if(__has_feature(cxx_exceptions))
 #		define GLM_CXX98_EXCEPTIONS
 #	endif
@@ -422,6 +425,4 @@
 #		define GLM_CXX11_VARIADIC_TEMPLATES
 #	endif
 
-#endif//(GLM_COMPILER & GLM_COMPILER_CLANG)
+#endif//(GLM_COMPILER & (GLM_COMPILER_APPLE_CLANG | GLM_COMPILER_LLVM))
-
-#endif//glm_core_features

common/glm/glm/detail/_fixes.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_fixes.hpp
+/// @file glm/detail/_fixes.hpp
 /// @date 2011-02-21 / 2011-11-22
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/_noise.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -26,8 +30,12 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_DETAIL_NOISE_INCLUDED
+#pragma once
-#define GLM_DETAIL_NOISE_INCLUDED
+
+#include "../vec2.hpp"
+#include "../vec3.hpp"
+#include "../vec4.hpp"
+#include "../common.hpp"
 
 namespace glm{
 namespace detail
@@ -75,19 +83,19 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> taylorInvSqrt(detail::tvec2<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec2<T, P> taylorInvSqrt(tvec2<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> taylorInvSqrt(detail::tvec3<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec3<T, P> taylorInvSqrt(tvec3<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> taylorInvSqrt(detail::tvec4<T, P> const & r)
+	GLM_FUNC_QUALIFIER tvec4<T, P> taylorInvSqrt(tvec4<T, P> const & r)
 	{
 		return T(1.79284291400159) - T(0.85373472095314) * r;
 	}
@@ -100,19 +108,19 @@ namespace detail
 */
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> fade(detail::tvec2<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec2<T, P> fade(tvec2<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> fade(detail::tvec3<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec3<T, P> fade(tvec3<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> fade(detail::tvec4<T, P> const & t)
+	GLM_FUNC_QUALIFIER tvec4<T, P> fade(tvec4<T, P> const & t)
 	{
 		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
 	}
@@ -126,5 +134,3 @@ namespace detail
 }//namespace detail
 }//namespace glm
 
-#endif//GLM_DETAIL_NOISE_INCLUDED
-

common/glm/glm/detail/_swizzle_func.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_swizzle_func.hpp
+/// @file glm/detail/_swizzle_func.hpp
 /// @date 2011-10-16 / 2011-10-16
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_swizzle_func
+#pragma once
-#define glm_core_swizzle_func
 
 #define GLM_SWIZZLE_GEN_VEC2_ENTRY(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_TYPE, CONST, A, B)	\
 	SWIZZLED_TYPE<TMPL_TYPE, PRECISION> A ## B() CONST												\
@@ -720,5 +723,3 @@
 	GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(TMPL_TYPE, PRECISION, CLASS_TYPE, SWIZZLED_VEC2_TYPE, SWIZZLED_VEC3_TYPE, SWIZZLED_VEC4_TYPE, s, t, p, q)
 
 //GLM_SWIZZLE_GEN_VEC_FROM_VEC4(valType, detail::vec4, detail::vec2, detail::vec3, detail::vec4)
-
-#endif//glm_core_swizzle_func

common/glm/glm/detail/_vectorize.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,197 +25,136 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_vectorize.hpp
+/// @file glm/detail/_vectorize.hpp
 /// @date 2011-10-14 / 2011-10-14
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_DETAIL_INCLUDED
+#pragma once
-#define GLM_CORE_DETAIL_INCLUDED
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
 #include "type_vec3.hpp"
 #include "type_vec4.hpp"
 
-#define VECTORIZE1_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func(	\
-		detail::tvec1<T, P> const & v)				\
-	{												\
-		return detail::tvec1<T, P>(					\
-			func(v.x));								\
-	}
-
-#define VECTORIZE2_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func(	\
-		detail::tvec2<T, P> const & v)				\
-	{												\
-		return detail::tvec2<T, P>(					\
-			func(v.x),								\
-			func(v.y));								\
-	}
-
-#define VECTORIZE3_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func(	\
-		detail::tvec3<T, P> const & v)				\
-	{												\
-		return detail::tvec3<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z));								\
-	}
-
-#define VECTORIZE4_VEC(func)						\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func(	\
-		detail::tvec4<T, P> const & v)				\
-	{												\
-		return detail::tvec4<T, P>(					\
-			func(v.x),								\
-			func(v.y),								\
-			func(v.z),								\
-			func(v.w));								\
-	}
-
-#define VECTORIZE_VEC(func)		\
-	VECTORIZE1_VEC(func)		\
-	VECTORIZE2_VEC(func)		\
-	VECTORIZE3_VEC(func)		\
-	VECTORIZE4_VEC(func)
-
-#define VECTORIZE1_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec1<T, P> func				\
-	(														\
-		detail::tvec1<T, P> const & x,						\
-		T const & y											\
-	)														\
-	{														\
-		return detail::tvec1<T, P>(							\
-			func(x.x, y));									\
-	}
-
-#define VECTORIZE2_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func				\
-	(														\
-		detail::tvec2<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec2<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y));									\
-	}
-
-#define VECTORIZE3_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func				\
-	(														\
-		detail::tvec3<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec3<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y),									\
-			func(x.z, y));									\
-	}
-
-#define VECTORIZE4_VEC_SCA(func)							\
-	template <typename T, precision P>						\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func				\
-	(														\
-		detail::tvec4<T, P> const & x,						\
-		T const & y	\
-	)														\
-	{														\
-		return detail::tvec4<T, P>(							\
-			func(x.x, y),									\
-			func(x.y, y),									\
-			func(x.z, y),									\
-			func(x.w, y));									\
-	}
-
-#define VECTORIZE_VEC_SCA(func)		\
-	VECTORIZE1_VEC_SCA(func)		\
-	VECTORIZE2_VEC_SCA(func)		\
-	VECTORIZE3_VEC_SCA(func)		\
-	VECTORIZE4_VEC_SCA(func)
-
-#define VECTORIZE2_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> func		\
-	(												\
-		detail::tvec2<T, P> const & x,				\
-		detail::tvec2<T, P> const & y				\
-	)												\
-	{												\
-		return detail::tvec2<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y));						\
-	}
-
-#define VECTORIZE3_VEC_VEC(func)					\
-	template <typename T, precision P>				\
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> func		\
-	(												\
-		detail::tvec3<T, P> const & x,				\
-		detail::tvec3<T, P> const & y				\
-	)												\
-	{												\
-		return detail::tvec3<T, P>(					\
-			func(x.x, y.x),							\
-			func(x.y, y.y),							\
-			func(x.z, y.z));						\
-	}
-
-#define VECTORIZE4_VEC_VEC(func)				\
-	template <typename T, precision P>			\
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> func	\
-	(											\
-		detail::tvec4<T, P> const & x,			\
-		detail::tvec4<T, P> const & y			\
-	)											\
-	{											\
-		return detail::tvec4<T, P>(				\
-			func(x.x, y.x),						\
-			func(x.y, y.y),						\
-			func(x.z, y.z),						\
-			func(x.w, y.w));					\
-	}
-
-#define VECTORIZE_VEC_VEC(func)		\
-	VECTORIZE2_VEC_VEC(func)		\
-	VECTORIZE3_VEC_VEC(func)		\
-	VECTORIZE4_VEC_VEC(func)
-
 namespace glm{
 namespace detail
 {
-	template<bool C>
+	template <typename R, typename T, precision P, template <typename, precision> class vecType>
-	struct If
+	struct functor1{};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec1>
 	{
-		template<typename F, typename T>
+		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
-		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
 		{
-			return functor(val);
+			return tvec1<R, P>(Func(v.x));
 		}
 	};
 
-	template<>
+	template <typename R, typename T, precision P>
-	struct If<false>
+	struct functor1<R, T, P, tvec2>
 	{
-		template<typename F, typename T>
+		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
-		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
 		{
-			return val;
+			return tvec2<R, P>(Func(v.x), Func(v.y));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<R, P> call(R (*Func) (T x), tvec3<T, P> const & v)
+		{
+			return tvec3<R, P>(Func(v.x), Func(v.y), Func(v.z));
+		}
+	};
+
+	template <typename R, typename T, precision P>
+	struct functor1<R, T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<R, P> call(R (*Func) (T x), tvec4<T, P> const & v)
+		{
+			return tvec4<R, P>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2{};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, tvec1<T, P> const & b)
+		{
+			return tvec1<T, P>(Func(a.x, b.x));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, tvec2<T, P> const & b)
+		{
+			return tvec2<T, P>(Func(a.x, b.x), Func(a.y, b.y));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, tvec3<T, P> const & b)
+		{
+			return tvec3<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, tvec4<T, P> const & b)
+		{
+			return tvec4<T, P>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
+		}
+	};
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	struct functor2_vec_sca{};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec1>
+	{
+		GLM_FUNC_QUALIFIER static tvec1<T, P> call(T (*Func) (T x, T y), tvec1<T, P> const & a, T b)
+		{
+			return tvec1<T, P>(Func(a.x, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec2>
+	{
+		GLM_FUNC_QUALIFIER static tvec2<T, P> call(T (*Func) (T x, T y), tvec2<T, P> const & a, T b)
+		{
+			return tvec2<T, P>(Func(a.x, b), Func(a.y, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec3>
+	{
+		GLM_FUNC_QUALIFIER static tvec3<T, P> call(T (*Func) (T x, T y), tvec3<T, P> const & a, T b)
+		{
+			return tvec3<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
+		}
+	};
+
+	template <typename T, precision P>
+	struct functor2_vec_sca<T, P, tvec4>
+	{
+		GLM_FUNC_QUALIFIER static tvec4<T, P> call(T (*Func) (T x, T y), tvec4<T, P> const & a, T b)
+		{
+			return tvec4<T, P>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
 		}
 	};
 }//namespace detail
 }//namespace glm
-
-#endif//GLM_CORE_DETAIL_INCLUDED

common/glm/glm/detail/dummy.cpp

@@ -12,6 +12,10 @@
 /// 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
@@ -29,7 +33,6 @@
 /// dummy.cpp exist only a wordaround for CMake file.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #include "../glm.hpp"
 #include <limits>
@@ -42,6 +45,7 @@ struct material
 	glm::vec4 specular; // Scm
 	float shininess; // Srm
 };
+
 struct light
 {
 	glm::vec4 ambient; // Acli
@@ -60,6 +64,7 @@ struct light
 	float quadraticAttenuation;// K2
 };
 
+
 // Sample 1
 #include <glm/vec3.hpp>// glm::vec3
 #include <glm/geometric.hpp>// glm::cross, glm::normalize
@@ -184,7 +189,34 @@ glm::vec3 lighting
 	return Color;
 }
 */
+
+
+template <typename T, glm::precision P, template<typename, glm::precision> class vecType>
+T normalizeDotA(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+#define GLM_TEMPLATE_GENTYPE typename T, glm::precision P, template<typename, glm::precision> class
+
+template <GLM_TEMPLATE_GENTYPE vecType>
+T normalizeDotB(vecType<T, P> const & x, vecType<T, P> const & y)
+{
+	return glm::dot(x, y) * glm::inversesqrt(glm::dot(x, x) * glm::dot(y, y));
+}
+
+template <typename vecType>
+typename vecType::value_type normalizeDotC(vecType const & a, vecType const & b)
+{
+	return glm::dot(a, b) * glm::inversesqrt(glm::dot(a, a) * glm::dot(b, b));
+}
+
 int main()
 {
+	glm::vec4 v(1);
+	float a = normalizeDotA(v, v);
+	float b = normalizeDotB(v, v);
+	float c = normalizeDotC(v, v);
+
 	return 0;
 }

common/glm/glm/detail/func_common.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_common.hpp
+/// @file glm/detail/func_common.hpp
 /// @date 2008-03-08 / 2010-01-26
 /// @author Christophe Riccio
 /// 
@@ -33,8 +37,7 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_FUNC_COMMON_INCLUDED
+#pragma once
-#define GLM_FUNC_COMMON_INCLUDED
 
 #include "setup.hpp"
 #include "precision.hpp"
@@ -53,7 +56,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType abs(genType const & x);
+	GLM_FUNC_DECL genType abs(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
 
 	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
 	/// 
@@ -61,17 +67,17 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType sign(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
-	
+
 	/// Returns a value equal to the nearest integer that is less then or equal to x. 
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType floor(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x
 	/// whose absolute value is not larger than the absolute value of x.
@@ -80,8 +86,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType trunc(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -93,9 +99,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType round(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
-	
+
 	/// Returns a value equal to the nearest integer to x.
 	/// A fractional part of 0.5 will round toward the nearest even
 	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
@@ -105,8 +111,8 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	/// @see <a href="http://developer.amd.com/documentation/articles/pages/New-Round-to-Even-Technique.aspx">New round to even technique</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType roundEven(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
 
 	/// Returns a value equal to the nearest integer
 	/// that is greater than or equal to x.
@@ -115,8 +121,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType ceil(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
 
 	/// Return x - floor(x).
 	/// 
@@ -125,7 +131,10 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType fract(genType const & x);
+	GLM_FUNC_DECL genType fract(genType x);
+
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
 
 	/// Modulus. Returns x - y * floor(x / y)
 	/// for each component in x using the floating point value y.
@@ -135,21 +144,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType mod(
+	GLM_FUNC_DECL genType mod(genType x, genType y);
-		genType const & x,
-		genType const & y);
 
-	/// Modulus. Returns x - y * floor(x / y)
+	template <typename T, precision P, template <typename, precision> class vecType>
-	/// for each component in x using the floating point value y.
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
-	/// 
+
-	/// @tparam genType Floating-point scalar or vector types.
+	template <typename T, precision P, template <typename, precision> class vecType>
-	/// 
+	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType mod(
-		genType const & x,
-		typename genType::value_type const & y);
 
 	/// Returns the fractional part of x and sets i to the integer
 	/// part (as a whole number floating point value). Both the
@@ -161,25 +162,22 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType modf(
+	GLM_FUNC_DECL genType modf(genType x, genType & i);
-		genType const & x,
-		genType & i);
 
 	/// Returns y if y < x; otherwise, it returns x.
 	///
 	/// @tparam genType Floating-point or integer; scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a><<<<<<< HEAD
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType min(
+	GLM_FUNC_DECL genType min(genType x, genType y);
-		genType const & x,
-		genType const & y);
 
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType min(
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
-		genType const & x,
+
-		typename genType::value_type const & y);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns y if x < y; otherwise, it returns x.
 	/// 
@@ -188,14 +186,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType max(
+	GLM_FUNC_DECL genType max(genType x, genType y);
-		genType const & x,
-		genType const & y);
 
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType max(
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
-		genType const & x,
+
-		typename genType::value_type const & y);
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns min(max(x, minVal), maxVal) for each component in x 
 	/// using the floating-point values minVal and maxVal.
@@ -205,16 +202,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType clamp(
+	GLM_FUNC_DECL genType clamp(genType x, genType minVal, genType maxVal);
-		genType const & x,
-		genType const & minVal,
-		genType const & maxVal);
 
-	template <typename genType, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType clamp(
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
-		genType const & x,
+
-		typename genType::value_type const & minVal,
+	template <typename T, precision P, template <typename, precision> class vecType>
-		typename genType::value_type const & maxVal);
+	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
 
 	/// If genTypeU is a floating scalar or vector:
 	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
@@ -259,40 +253,34 @@ namespace glm
 	/// glm::vec4 u = glm::mix(g, h, r); // Interpolations can be perform per component with a vector for the last parameter.
 	/// @endcode
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		vecType<U, P> const & a);
 
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(
+	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
-		vecType<T, P> const & x,
-		vecType<T, P> const & y,
-		U const & a);
 
 	template <typename genTypeT, typename genTypeU>
-	GLM_FUNC_DECL genTypeT mix(
+	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
-		genTypeT const & x,
-		genTypeT const & y,
-		genTypeU const & a);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0 for each component of a genType.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType step(
+	GLM_FUNC_DECL genType step(genType edge, genType x);
-		genType const & edge,
-		genType const & x);
 
 	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_DECL vecType<T, P> step(
+	GLM_FUNC_DECL vecType<T, P> step(T edge, vecType<T, P> const & x);
-		T const & edge,
+
-		vecType<T, P> const & x);
+	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <template <typename, precision> class vecType, typename T, precision P>
+	GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
 
 	/// Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
 	/// performs smooth Hermite interpolation between 0 and 1
@@ -309,16 +297,13 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
 	template <typename genType>
-	GLM_FUNC_DECL genType smoothstep(
+	GLM_FUNC_DECL genType smoothstep(genType edge0, genType edge1, genType x);
-		genType const & edge0,
-		genType const & edge1,
-		genType const & x);
 
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType smoothstep(
+	GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
-		typename genType::value_type const & edge0,
+
-		typename genType::value_type const & edge1,
+	template <typename T, precision P, template <typename, precision> class vecType>
-		genType const & x);
+	GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
 
 	/// Returns true if x holds a NaN (not a number)
 	/// representation in the underlying implementation's set of
@@ -332,8 +317,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
+	GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -345,8 +330,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
+	GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
 
 	/// Returns a signed integer value representing
 	/// the encoding of a floating-point value. The floating-point
@@ -469,4 +454,3 @@ namespace glm
 
 #include "func_common.inl"
 
-#endif//GLM_FUNC_COMMON_INCLUDED

common/glm/glm/detail/func_exponential.hpp

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

common/glm/glm/detail/func_exponential.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_exponential.inl
+/// @file glm/detail/func_exponential.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -29,25 +33,28 @@
 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"
 #include <limits>
+#include <cmath>
 #include <cassert>
 
 namespace glm{
 namespace detail
 {
-	template <bool isFloat>
+#	if GLM_HAS_CXX11_STL
+		using std::log2;
+#	else
+		template <typename genType>
+		genType log2(genType Value)
+		{
+			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
+		}
+#	endif
+
+	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
 	struct compute_log2
 	{
-		template <typename T>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
-		T operator() (T const & Value) const;
-	};
-
-	template <>
-	struct compute_log2<true>
-	{
-		template <typename T>
-		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
 		{
-			return static_cast<T>(::std::log(Value)) * static_cast<T>(1.4426950408889634073599246810019);
+			return detail::functor1<T, T, P, vecType>::call(log2, vec);
 		}
 	};
 
@@ -78,170 +85,77 @@ namespace detail
 }//namespace detail
 
 	// pow
-	template <typename genType>
+	using std::pow;
-	GLM_FUNC_QUALIFIER genType pow
+	template <typename T, precision P, template <typename, precision> class vecType>
-	(
+	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
-		genType const & x, 
-		genType const & y
-	)
 	{
-		GLM_STATIC_ASSERT(
+		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
-			std::numeric_limits<genType>::is_iec559,
-			"'pow' only accept floating-point inputs");
-
-		return std::pow(x, y);
 	}
 
-	VECTORIZE_VEC_VEC(pow)
-
 	// exp
-	template <typename genType>
+	using std::exp;
-	GLM_FUNC_QUALIFIER genType exp
+	template <typename T, precision P, template <typename, precision> class vecType>
-	(
+	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
-		genType const & x
-	)
 	{
-		GLM_STATIC_ASSERT(
+		return detail::functor1<T, T, P, vecType>::call(exp, x);
-			std::numeric_limits<genType>::is_iec559,
-			"'exp' only accept floating-point inputs");
-
-		return std::exp(x);
 	}
 
-	VECTORIZE_VEC(exp)
-
 	// log
-	template <typename genType>
+	using std::log;
-	GLM_FUNC_QUALIFIER genType log
+	template <typename T, precision P, template <typename, precision> class vecType>
-	(
+	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
-		genType const & x
-	)
 	{
-		GLM_STATIC_ASSERT(
+		return detail::functor1<T, T, P, vecType>::call(log, x);
-			std::numeric_limits<genType>::is_iec559,
-			"'log' only accept floating-point inputs");
-
-		return std::log(x);
 	}
 
-	VECTORIZE_VEC(log)
-
 	//exp2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType exp2(genType const & x)
+	GLM_FUNC_QUALIFIER genType exp2(genType x)
 	{
-		GLM_STATIC_ASSERT(
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
-			std::numeric_limits<genType>::is_iec559,
-			"'exp2' only accept floating-point inputs");
 
 		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
 	}
 
-	VECTORIZE_VEC(exp2)
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
+	{
+		return detail::functor1<T, T, P, vecType>::call(exp2, x);
+	}
 
 	// log2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType log2(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
+		return log2(tvec1<genType>(x)).x;
-			"GLM core 'log2' only accept floating-point inputs. Include <glm/gtx/integer.hpp> for additional integer support.");
-
-		assert(x > genType(0)); // log2 is only defined on the range (0, inf]
-		return detail::compute_log2<std::numeric_limits<genType>::is_iec559>()(x);
 	}
 
-	VECTORIZE_VEC(log2)
+	template <typename T, precision P, template <typename, precision> class vecType>
-
+	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
-	namespace detail
 	{
-		template <template <class, precision> class vecType, typename T, precision P>
+		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
-		struct compute_sqrt{};
+	}
-		
+
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec1, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
-			{
-				return detail::tvec1<T, P>(std::sqrt(x.x));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec2, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
-			{
-				return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec3, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
-			{
-				return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
-			}
-		};
-		
-		template <typename T, precision P>
-		struct compute_sqrt<detail::tvec4, T, P>
-		{
-			GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
-			{
-				return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
-			}
-		};
-	}//namespace detail
-	
 	// sqrt
-	GLM_FUNC_QUALIFIER float sqrt(float x)
+	using std::sqrt;
-	{
-#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<float, highp> tmp(detail::compute_sqrt<detail::tvec1, float, highp>::call(x));
-			return tmp.x;
-#		else
-			return detail::compute_sqrt<detail::tvec1, float, highp>::call(x).x;
-#		endif
-	}
-
-	GLM_FUNC_QUALIFIER double sqrt(double x)
-	{
-#		ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
-			detail::tvec1<double, highp> tmp(detail::compute_sqrt<detail::tvec1, double, highp>::call(x));
-			return tmp.x;
-#		else
-			return detail::compute_sqrt<detail::tvec1, double, highp>::call(x).x;
-#		endif
-	}
-		
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<T, P> sqrt(vecType<T, P> const & x)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<vecType, T, P>::call(x);
+		return detail::functor1<T, T, P, vecType>::call(sqrt, x);
 	}
 
 	// inversesqrt
-	GLM_FUNC_QUALIFIER float inversesqrt(float const & x)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
 	{
-		return 1.0f / sqrt(x);
+		return static_cast<genType>(1) / sqrt(x);
 	}
 	
-	GLM_FUNC_QUALIFIER double inversesqrt(double const & x)
+	template <typename T, precision P, template <typename, precision> class vecType>
-	{
+	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
-		return 1.0 / sqrt(x);
-	}
-	
-	template <template <class, precision> class vecType, typename T, precision P>
-	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);
 	}
-
-	VECTORIZE_VEC(inversesqrt)
 }//namespace glm

common/glm/glm/detail/func_geometric.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.hpp
+/// @file glm/detail/func_geometric.hpp
 /// @date 2008-08-03 / 2011-06-14
 /// @author Christophe Riccio
 ///
@@ -33,8 +37,7 @@
 /// These operate on vectors as vectors, not component-wise.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_geometric
+#pragma once
-#define glm_core_func_geometric
 
 #include "type_vec3.hpp"
 
@@ -49,9 +52,9 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename genType::value_type length(
+	GLM_FUNC_DECL T length(
-		genType const & x); 
+		vecType<T, P> const & x);
 
 	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
 	///
@@ -59,10 +62,10 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename genType::value_type distance(
+	GLM_FUNC_DECL T distance(
-		genType const & p0, 
+		vecType<T, P> const & p0,
-		genType const & p1);
+		vecType<T, P> const & p1);
 
 	/// Returns the dot product of x and y, i.e., result = x * y.
 	///
@@ -75,17 +78,6 @@ namespace glm
 		vecType<T, P> const & x,
 		vecType<T, P> const & y);
 
-	/// Returns the dot product of x and y, i.e., result = x * y.
-	///
-	/// @tparam genType Floating-point vector types.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL genType dot(
-		genType const & x,
-		genType const & y);
-
 	/// Returns the cross product of x and y.
 	///
 	/// @tparam valType Floating-point scalar types.
@@ -93,17 +85,18 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
 	template <typename T, precision P>
-	GLM_FUNC_DECL detail::tvec3<T, P> cross(
+	GLM_FUNC_DECL tvec3<T, P> cross(
-		detail::tvec3<T, P> const & x,
+		tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y);
+		tvec3<T, P> const & y);
 
 	/// Returns a vector in the same direction as x but with length of 1.
+	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename genType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType normalize(
+	GLM_FUNC_DECL vecType<T, P> normalize(
-		genType const & x);
+		vecType<T, P> const & x);
 
 	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
 	///
@@ -141,11 +134,9 @@ namespace glm
 	GLM_FUNC_DECL vecType<T, P> refract(
 		vecType<T, P> const & I,
 		vecType<T, P> const & N,
-		T const & eta);
+		T eta);
 
 	/// @}
 }//namespace glm
 
 #include "func_geometric.inl"
-
-#endif//glm_core_func_geometric

common/glm/glm/detail/func_geometric.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.inl
+/// @file glm/detail/func_geometric.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -39,45 +43,40 @@ namespace detail
 	struct compute_dot{};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec1, T, P>
+	struct compute_dot<tvec1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
 		{
-#			ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+			return a.x * b.x;
-				detail::tvec1<T, P> tmp(x * y);
-				return tmp.x;
-#			else
-				return detail::tvec1<T, P>(x * y).x;
-#			endif
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec2, T, P>
+	struct compute_dot<tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
 		{
-			detail::tvec2<T, P> tmp(x * y);
+			tvec2<T, P> tmp(x * y);
 			return tmp.x + tmp.y;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec3, T, P>
+	struct compute_dot<tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
 		{
-			detail::tvec3<T, P> tmp(x * y);
+			tvec3<T, P> tmp(x * y);
 			return tmp.x + tmp.y + tmp.z;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<detail::tvec4, T, P>
+	struct compute_dot<tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
 		{
-			detail::tvec4<T, P> tmp(x * y);
+			tvec4<T, P> tmp(x * y);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
@@ -85,144 +84,58 @@ namespace detail
 
 	// length
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length
+	GLM_FUNC_QUALIFIER genType length(genType x)
-	(
-		genType const & x
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
 
-		genType sqr = x * x;
+		return abs(x);
-		return sqrt(sqr);
 	}
 
-	template <typename T, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
+	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");
 
-		T sqr = v.x * v.x + v.y * v.y;
+		return sqrt(dot(v, v));
-		return sqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec3<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
-
-		T sqr = v.x * v.x + v.y * v.y + v.z * v.z;
-		return sqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length(detail::tvec4<T, P> const & v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
-
-		T sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
-		return sqrt(sqr);
 	}
 
 	// distance
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType distance
+	GLM_FUNC_QUALIFIER genType distance(genType const & p0, genType const & p1)
-	(
-		genType const & p0,
-		genType const & p1
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
 
 		return length(p1 - p0);
 	}
 
-	template <typename T, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance
+	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
-	(
-		detail::tvec2<T, P> const & p0,
-		detail::tvec2<T, P> const & p1
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T distance
-	(
-		detail::tvec3<T, P> const & p0,
-		detail::tvec3<T, P> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T distance
-	(
-		detail::tvec4<T, P> const & p0,
-		detail::tvec4<T, P> const & p1
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'distance' only accept floating-point inputs");
-
 		return length(p1 - p0);
 	}
 
 	// dot
 	template <typename T>
-	GLM_FUNC_QUALIFIER T dot
+	GLM_FUNC_QUALIFIER T dot(T x, T y)
-	(
-		T const & x,
-		T const & y
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
+		return x * y;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot
+	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		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);
 	}
 
-/* // SSE3
-	GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
-	{
-		float Result;
-		__asm
-		{
-			mov		esi, x
-			mov		edi, y
-			movaps	xmm0, [esi]
-			mulps	xmm0, [edi]
-			haddps(	_xmm0, _xmm0 )
-			haddps(	_xmm0, _xmm0 )
-			movss	Result, xmm0
-		}
-		return Result;
-	}
-*/
 	// cross
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
-	(
-		detail::tvec3<T, P> const & x,
-		detail::tvec3<T, P> const & y
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' only accept floating-point inputs");
 
-		return detail::tvec3<T, P>(
+		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);
@@ -230,111 +143,53 @@ namespace detail
 
 	// normalize
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType normalize
+	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
-	(
-		genType const & x
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' only accept floating-point inputs");
 
 		return x < genType(0) ? genType(-1) : genType(1);
 	}
 
-	// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
+	template <typename T, precision P, template <typename, precision> class vecType>
-	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> normalize
-	(
-		detail::tvec2<T, P> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
-		
-		T sqr = x.x * x.x + x.y * x.y;
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> normalize
-	(
-		detail::tvec3<T, P> const & x
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
 
-		T sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+		return x * inversesqrt(dot(x, x));
-		return x * inversesqrt(sqr);
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> normalize
-	(
-		detail::tvec4<T, P> const & x
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' only accept floating-point inputs");
-		
-		T sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
-		return x * inversesqrt(sqr);
 	}
 
 	// faceforward
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward
+	GLM_FUNC_QUALIFIER genType faceforward(genType const & N, genType const & I, genType const & Nref)
-	(
-		genType const & N,
-		genType const & I,
-		genType const & Nref
-	)
 	{
-		return dot(Nref, I) < 0 ? N : -N;
+		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
 	}
 
 	// reflect
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect
+	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
-	(
-		genType const & I,
-		genType const & N
-	)
 	{
-		return I - N * dot(N, I) * genType(2);
+		return I - N * dot(N, I) * static_cast<genType>(2);
 	}
 
 	// refract
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract
+	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
-	(
-		genType const & I,
-		genType const & N,
-		genType const & eta
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
 
-		genType dotValue = dot(N, I);
+		genType const dotValue(dot(N, I));
-		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
+		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
-		if(k < genType(0))
+		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
-			return genType(0);
-		else
-			return eta * I - (eta * dotValue + sqrt(k)) * N;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract
+	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
-	(
-		vecType<T, P> const & I,
-		vecType<T, P> const & N,
-		T const & eta
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' only accept floating-point inputs");
 
-		T dotValue = dot(N, I);
+		T const dotValue(dot(N, I));
-		T k = T(1) - eta * eta * (T(1) - dotValue * dotValue);
+		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-		if(k < T(0))
+		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
-			return vecType<T, P>(0);
-		else
-			return eta * I - (eta * dotValue + std::sqrt(k)) * N;
 	}
-
 }//namespace glm

common/glm/glm/detail/func_integer.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.hpp
+/// @file glm/detail/func_integer.hpp
 /// @date 2010-03-17 / 2011-06-18
 /// @author Christophe Riccio
 ///
@@ -35,10 +39,12 @@
 /// b, inclusive. The lowest-order bit is bit 0.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_integer
+#pragma once
-#define glm_core_func_integer
 
 #include "setup.hpp"
+#include "precision.hpp"
+#include "func_common.hpp"
+#include "func_vector_relational.hpp"
 
 namespace glm
 {
@@ -53,11 +59,11 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genUType uaddCarry(
+	GLM_FUNC_DECL vecType<uint, P> uaddCarry(
-		genUType const & x,
+		vecType<uint, P> const & x,
-		genUType const & y,
+		vecType<uint, P> const & y,
-		genUType & carry);
+		vecType<uint, P> & carry);
 
 	/// Subtracts the 32-bit unsigned integer y from x, returning
 	/// the difference if non-negative, or pow(2, 32) plus the difference
@@ -67,12 +73,12 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genUType usubBorrow(
+	GLM_FUNC_DECL vecType<uint, P> usubBorrow(
-		genUType const & x,
+		vecType<uint, P> const & x,
-		genUType const & y,
+		vecType<uint, P> const & y,
-		genUType & borrow);
+		vecType<uint, P> & borrow);
-		
+
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
 	/// The 32 most-significant bits are returned in msb.
@@ -81,12 +87,12 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genUType>
+	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL void umulExtended(
-		genUType const & x,
+		vecType<uint, P> const & x,
-		genUType const & y,
+		vecType<uint, P> const & y,
-		genUType & msb,
+		vecType<uint, P> & msb,
-		genUType & lsb);
+		vecType<uint, P> & lsb);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
@@ -96,12 +102,12 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIType>
+	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL void imulExtended(
-		genIType const & x,
+		vecType<int, P> const & x,
-		genIType const & y,
+		vecType<int, P> const & y,
-		genIType & msb,
+		vecType<int, P> & msb,
-		genIType & lsb);
+		vecType<int, P> & lsb);
 
 	/// Extracts bits [offset, offset + bits - 1] from value,
 	/// returning them in the least significant bits of the result.
@@ -114,15 +120,15 @@ namespace glm
 	/// offset and bits is greater than the number of bits used
 	/// to store the operand.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genIUType bitfieldExtract(
+	GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
-		genIUType const & Value,
+		vecType<T, P> const & Value,
-		int const & Offset,
+		int Offset,
-		int const & Bits);
+		int Bits);
 
 	/// Returns the insertion the bits least-significant bits of insert into base.
 	///
@@ -134,70 +140,93 @@ namespace glm
 	/// offset and bits is greater than the number of bits used to
 	/// store the operand.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genIUType bitfieldInsert(
+	GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
-		genIUType const & Base,
+		vecType<T, P> const & Base,
-		genIUType const & Insert,
+		vecType<T, P> const & Insert,
-		int const & Offset,
+		int Offset,
-		int const & Bits);
+		int Bits);
 
 	/// Returns the reversal of the bits of value. 
 	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
 	/// where bits is the total number of bits used to represent value.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
+	GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
-		
+
 	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL int bitCount(genType v);
+
+	/// Returns the number of bits set to 1 in the binary representation of value.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
+	/// @tparam T Signed or unsigned integer scalar or vector types.
-	template <typename T, template <typename> class genIUType>
+	///
-	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
 
 	/// Returns the bit number of the least significant bit set to
 	/// 1 in the binary representation of value. 
 	/// If value is zero, -1 will be returned.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findLSB(genIUType x);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
+	/// @tparam T Signed or unsigned integer scalar types.
-	template <typename T, template <typename> class genIUType>
+	///
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
 	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
 	/// For negative integers, the result will be the bit number of the most significant
 	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findMSB(genIUType x);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
+	/// @tparam T Signed or unsigned integer scalar types.
-	template <typename T, template <typename> class genIUType>
+	///
-	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
 
 	/// @}
 }//namespace glm
 
 #include "func_integer.inl"
-
-#endif//glm_core_func_integer
-

common/glm/glm/detail/func_integer.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.inl
+/// @file glm/detail/func_integer.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -39,73 +43,186 @@
 #endif//(GLM_ARCH != GLM_ARCH_PURE)
 #include <limits>
 
-namespace glm
+namespace glm{
+namespace detail
 {
+	template <typename T>
+	GLM_FUNC_QUALIFIER T mask(T Bits)
+	{
+		return Bits >= sizeof(T) * 8 ? ~static_cast<T>(0) : (static_cast<T>(1) << Bits) - static_cast<T>(1);
+	}
+
+	template <bool EXEC = false>
+	struct compute_bitfieldReverseStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldReverseStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
+		}
+	};
+
+	template <bool EXEC = false>
+	struct compute_bitfieldBitCountStep
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T, T)
+		{
+			return v;
+		}
+	};
+
+	template <>
+	struct compute_bitfieldBitCountStep<true>
+	{
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & v, T Mask, T Shift)
+		{
+			return (v & Mask) + ((v >> Shift) & Mask);
+		}
+	};
+
+	template <typename genIUType, size_t Bits>
+	struct compute_findLSB
+	{
+		GLM_FUNC_QUALIFIER static int call(genIUType Value)
+		{
+			if(Value == 0)
+				return -1;
+
+			return glm::bitCount(~Value & (Value - static_cast<genIUType>(1)));
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 32>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward(&Result, *reinterpret_cast<unsigned long*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		struct compute_findLSB<genIUType, 64>
+		{
+			GLM_FUNC_QUALIFIER static int call(genIUType Value)
+			{
+				unsigned long Result(0);
+				unsigned char IsNotNull = _BitScanForward64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+				return IsNotNull ? int(Result) : -1;
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+
+	template <typename T, glm::precision P, template <class, glm::precision> class vecType, bool EXEC = true>
+	struct compute_findMSB_step_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T Shift)
+		{
+			return x | (x >> Shift);
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
+	struct compute_findMSB_step_vec<T, P, vecType, false>
+	{
+		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & x, T)
+		{
+			return x;
+		}
+	};
+
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType, int>
+	struct compute_findMSB_vec
+	{
+		GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & vec)
+		{
+			vecType<T, P> x(vec);
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 1));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 2));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >=  8>::call(x, static_cast<T>( 4));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 16>::call(x, static_cast<T>( 8));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 32>::call(x, static_cast<T>(16));
+			x = compute_findMSB_step_vec<T, P, vecType, sizeof(T) * 8 >= 64>::call(x, static_cast<T>(32));
+			return vecType<int, P>(sizeof(T) * 8 - 1) - glm::bitCount(~x);
+		}
+	};
+
+#	if GLM_HAS_BITSCAN_WINDOWS
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_32(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse(&Result, *reinterpret_cast<unsigned long*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 32>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_32, x);
+			}
+		};
+
+#		if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_MODEL == GLM_MODEL_32))
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int compute_findMSB_64(genIUType Value)
+		{
+			unsigned long Result(0);
+			unsigned char IsNotNull = _BitScanReverse64(&Result, *reinterpret_cast<unsigned __int64*>(&Value));
+			return IsNotNull ? int(Result) : -1;
+		}
+
+		template <typename T, glm::precision P, template <class, glm::precision> class vecType>
+		struct compute_findMSB_vec<T, P, vecType, 64>
+		{
+			GLM_FUNC_QUALIFIER static vecType<int, P> call(vecType<T, P> const & x)
+			{
+				return detail::functor1<int, T, P, vecType>::call(compute_findMSB_64, x);
+			}
+		};
+#		endif
+#	endif//GLM_HAS_BITSCAN_WINDOWS
+}//namespace detail
+
 	// uaddCarry
-	template <>
+	GLM_FUNC_QUALIFIER uint uaddCarry(uint const & x, uint const & y, uint & Carry)
-	GLM_FUNC_QUALIFIER uint uaddCarry
-	(
-		uint const & x,
-		uint const & y,
-		uint & Carry
-	)
 	{
-		uint64 Value64 = static_cast<uint64>(x) + static_cast<uint64>(y);
+		uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
-		uint32 Result = static_cast<uint32>(Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32)));
+		uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-		Carry = (Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32))) > 1 ? static_cast<uint32>(1) : static_cast<uint32>(0);
+		Carry = Value64 > Max32 ? 1 : 0;
-		return Result;
+		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
 	}
 
-	template <>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER uvec2 uaddCarry
+	GLM_FUNC_QUALIFIER vecType<uint, P> uaddCarry(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Carry)
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & Carry
-	)
 	{
-		return uvec2(
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) + vecType<uint64, P>(y));
-			uaddCarry(x[0], y[0], Carry[0]),
+		vecType<uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-			uaddCarry(x[1], y[1], Carry[1]));
+		Carry = mix(vecType<uint32, P>(0), vecType<uint32, P>(1), greaterThan(Value64, Max32));
-	}
+		return vecType<uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec3 uaddCarry
-	(
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & Carry
-	)
-	{
-		return uvec3(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec4 uaddCarry
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & Carry
-	)
-	{
-		return uvec4(
-			uaddCarry(x[0], y[0], Carry[0]),
-			uaddCarry(x[1], y[1], Carry[1]),
-			uaddCarry(x[2], y[2], Carry[2]),
-			uaddCarry(x[3], y[3], Carry[3]));
 	}
 
 	// usubBorrow
-	template <>
+	GLM_FUNC_QUALIFIER uint usubBorrow(uint const & x, uint const & y, uint & Borrow)
-	GLM_FUNC_QUALIFIER uint usubBorrow
-	(
-		uint const & x,
-		uint const & y,
-		uint & Borrow
-	)
 	{
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
@@ -116,57 +233,17 @@ namespace glm
 			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
 	}
 
-	template <>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER uvec2 usubBorrow
+	GLM_FUNC_QUALIFIER vecType<uint, P> usubBorrow(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Borrow)
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & Borrow
-	)
 	{
-		return uvec2(
+		Borrow = mix(vecType<uint, P>(1), vecType<uint, P>(0), greaterThanEqual(x, y));
-			usubBorrow(x[0], y[0], Borrow[0]),
+		vecType<uint, P> const YgeX(y - x);
-			usubBorrow(x[1], y[1], Borrow[1]));
+		vecType<uint, P> const XgeY(vecType<uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<int64, P>(y) - vecType<int64, P>(x))));
-	}
+		return mix(XgeY, YgeX, greaterThanEqual(y, x));
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec3 usubBorrow
-	(
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & Borrow
-	)
-	{
-		return uvec3(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]));
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER uvec4 usubBorrow
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & Borrow
-	)
-	{
-		return uvec4(
-			usubBorrow(x[0], y[0], Borrow[0]),
-			usubBorrow(x[1], y[1], Borrow[1]),
-			usubBorrow(x[2], y[2], Borrow[2]),
-			usubBorrow(x[3], y[3], Borrow[3]));
 	}
 
 	// umulExtended
-	template <>
+	GLM_FUNC_QUALIFIER void umulExtended(uint const & x, uint const & y, uint & msb, uint & lsb)
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uint const & x,
-		uint const & y,
-		uint & msb,
-		uint & lsb
-	)
 	{
 		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
 
@@ -177,57 +254,18 @@ namespace glm
 		lsb = *PointerLSB;
 	}
 
-	template <>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void umulExtended
+	GLM_FUNC_QUALIFIER void umulExtended(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & msb, vecType<uint, P> & lsb)
-	(
-		uvec2 const & x,
-		uvec2 const & y,
-		uvec2 & msb,
-		uvec2 & lsb
-	)
 	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
+		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-	}
 
-	template <>
+		vecType<uint64, P> Value64(vecType<uint64, P>(x) * vecType<uint64, P>(y));
-	GLM_FUNC_QUALIFIER void umulExtended
+		msb = vecType<uint32, P>(Value64 >> static_cast<uint64>(32));
-	(
+		lsb = vecType<uint32, P>(Value64);
-		uvec3 const & x,
-		uvec3 const & y,
-		uvec3 & msb,
-		uvec3 & lsb
-	)
-	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-		umulExtended(x[2], y[2], msb[2], lsb[2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER void umulExtended
-	(
-		uvec4 const & x,
-		uvec4 const & y,
-		uvec4 & msb,
-		uvec4 & lsb
-	)
-	{
-		umulExtended(x[0], y[0], msb[0], lsb[0]);
-		umulExtended(x[1], y[1], msb[1], lsb[1]);
-		umulExtended(x[2], y[2], msb[2], lsb[2]);
-		umulExtended(x[3], y[3], msb[3], lsb[3]);
 	}
 
 	// imulExtended
-	template <>
+	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int & msb, int & lsb)
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		int const & x,
-		int const & y,
-		int & msb,
-		int & lsb
-	)
 	{
 		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
 
@@ -238,417 +276,118 @@ namespace glm
 		lsb = *PointerLSB;
 	}
 
-	template <>
+	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void imulExtended
+	GLM_FUNC_QUALIFIER void imulExtended(vecType<int, P> const & x, vecType<int, P> const & y, vecType<int, P> & msb, vecType<int, P> & lsb)
-	(
-		ivec2 const & x,
-		ivec2 const & y,
-		ivec2 & msb,
-		ivec2 & lsb
-	)
 	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
+		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-	}
 
-	template <>
+		vecType<int64, P> Value64(vecType<int64, P>(x) * vecType<int64, P>(y));
-	GLM_FUNC_QUALIFIER void imulExtended
+		lsb = vecType<int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
-	(
+		msb = vecType<int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
-		ivec3 const & x,
-		ivec3 const & y,
-		ivec3 & msb,
-		ivec3 & lsb
-	)
-	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-		imulExtended(x[2], y[2], msb[2], lsb[2]);
-	}
-
-	template <>
-	GLM_FUNC_QUALIFIER void imulExtended
-	(
-		ivec4 const & x,
-		ivec4 const & y,
-		ivec4 & msb,
-		ivec4 & lsb
-	)
-	{
-		imulExtended(x[0], y[0], msb[0], lsb[0]),
-		imulExtended(x[1], y[1], msb[1], lsb[1]);
-		imulExtended(x[2], y[2], msb[2], lsb[2]);
-		imulExtended(x[3], y[3], msb[3], lsb[3]);
 	}
 
 	// bitfieldExtract
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract(genIUType Value, int Offset, int Bits)
-	(
-		genIUType const & Value,
-		int const & Offset,
-		int const & Bits
-	)
 	{
-		int GenSize = int(sizeof(genIUType)) << int(3);
+		return bitfieldExtract(tvec1<genIUType>(Value), Offset, Bits).x;
-
-		assert(Offset + Bits <= GenSize);
-
-		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
-		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
-
-		return ShiftBack;
 	}
 
-	template <typename T, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldExtract(vecType<T, P> const & Value, int Offset, int Bits)
-	(
-		detail::tvec2<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
 	{
-		return detail::tvec2<T, P>(
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits));
-	}
 
-	template <typename T, precision P>
+		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldExtract
-	(
-		detail::tvec3<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T, P>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldExtract
-	(
-		detail::tvec4<T, P> const & Value,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T, P>(
-			bitfieldExtract(Value[0], Offset, Bits),
-			bitfieldExtract(Value[1], Offset, Bits),
-			bitfieldExtract(Value[2], Offset, Bits),
-			bitfieldExtract(Value[3], Offset, Bits));
 	}
 
 	// bitfieldInsert
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert(genIUType const & Base, genIUType const & Insert, int Offset, int Bits)
-	(
-		genIUType const & Base,
-		genIUType const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+		return bitfieldInsert(tvec1<genIUType>(Base), tvec1<genIUType>(Insert), Offset, Bits).x;
-		assert(Offset + Bits <= sizeof(genIUType));
+	}
 
-		if(Bits == 0)
+	template <typename T, precision P, template <typename, precision> class vecType>
-			return Base;
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldInsert(vecType<T, P> const & Base, vecType<T, P> const & Insert, int Offset, int Bits)
-
+	{
-		genIUType Mask = 0;
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
-		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
-			Mask |= (1 << Bit);
 
+		T const Mask = static_cast<T>(detail::mask(Bits) << Offset);
 		return (Base & ~Mask) | (Insert & Mask);
 	}
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldInsert
-	(
-		detail::tvec2<T, P> const & Base,
-		detail::tvec2<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec2<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> bitfieldInsert
-	(
-		detail::tvec3<T, P> const & Base,
-		detail::tvec3<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec3<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> bitfieldInsert
-	(
-		detail::tvec4<T, P> const & Base,
-		detail::tvec4<T, P> const & Insert,
-		int const & Offset,
-		int const & Bits
-	)
-	{
-		return detail::tvec4<T, P>(
-			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
-			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
-	}
-
 	// bitfieldReverse
-	template <typename genIUType>
+	template <typename genType>
-	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+		return bitfieldReverse(glm::tvec1<genType, glm::defaultp>(x)).x;
+	}
 
-		genIUType Out = 0;
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-		std::size_t BitSize = sizeof(genIUType) * 8;
+	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
-		for(std::size_t i = 0; i < BitSize; ++i)
+	{
-			if(Value & (genIUType(1) << i))
+		vecType<T, P> x(v);
-				Out |= genIUType(1) << (BitSize - 1 - i);
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
-		return Out;
+		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));
-	VECTORIZE_VEC(bitfieldReverse)
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
+		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
+		return x;
+	}
 
 	// bitCount
-	template <typename genIUType>
+	template <typename genType>
-	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
+	GLM_FUNC_QUALIFIER int bitCount(genType x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+		return bitCount(glm::tvec1<genType, glm::defaultp>(x)).x;
-
-		int Count = 0;
-		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
-		{
-			if(Value & (1 << i))
-				++Count;
-		}
-		return Count;
 	}
 
-	template <typename T, precision P>
+	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
+	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
-	(
-		detail::tvec2<T, P> const & value
-	)
 	{
-		return detail::tvec2<int, P>(
+		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
-			bitCount(value[0]),
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
-			bitCount(value[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));
-	template <typename T, precision P>
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
+		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
-	(
+		return vecType<int, P>(x);
-		detail::tvec3<T, P> const & value
-	)
-	{
-		return detail::tvec3<int, P>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> bitCount
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			bitCount(value[0]),
-			bitCount(value[1]),
-			bitCount(value[2]),
-			bitCount(value[3]));
 	}
 
 	// findLSB
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findLSB
+	GLM_FUNC_QUALIFIER int findLSB(genIUType Value)
-	(
-		genIUType const & Value
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
-		if(Value == 0)
-			return -1;
 
-		genIUType Bit;
+		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
-		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
-		return Bit;
 	}
 
-	template <typename T, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
+	GLM_FUNC_QUALIFIER vecType<int, P> findLSB(vecType<T, P> const & x)
-	(
-		detail::tvec2<T, P> const & value
-	)
 	{
-		return detail::tvec2<int, P>(
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
-			findLSB(value[0]),
-			findLSB(value[1]));
-	}
 
-	template <typename T, precision P>
+		return detail::functor1<int, T, P, vecType>::call(findLSB, x);
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findLSB
-	(
-		detail::tvec3<T, P> const & value
-	)
-	{
-		return detail::tvec3<int, P>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]));
-	}
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findLSB
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			findLSB(value[0]),
-			findLSB(value[1]),
-			findLSB(value[2]),
-			findLSB(value[3]));
 	}
 
 	// findMSB
-#if((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_VC))
-
 	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
+	GLM_FUNC_QUALIFIER int findMSB(genIUType x)
-	(
-		genIUType const & Value
-	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
 
-		unsigned long Result(0);
+		return findMSB(tvec1<genIUType>(x)).x;
-		_BitScanReverse(&Result, Value);
-		return int(Result);
-	}
-/*
-// __builtin_clz seems to be buggy as it crasks for some values, from 0x00200000 to 80000000
-#elif((GLM_ARCH != GLM_ARCH_PURE) && (GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC40))
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		if(Value == 0)
-			return -1;
-
-		// clz returns the number or trailing 0-bits; see
-		// http://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Other-Builtins.html
-		//
-		// NoteBecause __builtin_clz only works for unsigned ints, this
-		// implementation will not work for 64-bit integers.
-		//
-		return 31 - __builtin_clzl(Value);
-	}
-*/
-#else
-
-/* SSE implementation idea
-
-		__m128i const Zero = _mm_set_epi32( 0,  0,  0,  0);
-		__m128i const One = _mm_set_epi32( 1,  1,  1,  1);
-		__m128i Bit = _mm_set_epi32(-1, -1, -1, -1);
-		__m128i Tmp = _mm_set_epi32(Value, Value, Value, Value);
-		__m128i Mmi = Zero;
-		for(int i = 0; i < 32; ++i)
-		{
-			__m128i Shilt = _mm_and_si128(_mm_cmpgt_epi32(Tmp, One), One);
-			Tmp = _mm_srai_epi32(Tmp, One);
-			Bit = _mm_add_epi32(Bit, _mm_and_si128(Shilt, i));
-			Mmi = _mm_and_si128(Mmi, One);
-		}
-		return Bit;
-
-*/
-
-	template <typename genIUType>
-	GLM_FUNC_QUALIFIER int findMSB
-	(
-		genIUType const & Value
-	)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-		
-		if(Value == genIUType(0) || Value == genIUType(-1))
-			return -1;
-		else if(Value > 0)
-		{
-			genIUType Bit = genIUType(-1);
-			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
-			return Bit;
-		}
-		else //if(Value < 0)
-		{
-			int const BitCount(sizeof(genIUType) * 8);
-			int MostSignificantBit(-1);
-			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
-				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
-			assert(MostSignificantBit >= 0);
-			return MostSignificantBit;
-		}
-	}
-#endif//(GLM_COMPILER)
-
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findMSB
-	(
-		detail::tvec2<T, P> const & value
-	)
-	{
-		return detail::tvec2<int, P>(
-			findMSB(value[0]),
-			findMSB(value[1]));
 	}
 
-	template <typename T, precision P>
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
+	GLM_FUNC_QUALIFIER vecType<int, P> findMSB(vecType<T, P> const & x)
-	(
-		detail::tvec3<T, P> const & value
-	)
 	{
-		return detail::tvec3<int, P>(
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]));
-	}
 
-	template <typename T, precision P>
+		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
-	GLM_FUNC_QUALIFIER detail::tvec4<int, P> findMSB
-	(
-		detail::tvec4<T, P> const & value
-	)
-	{
-		return detail::tvec4<int, P>(
-			findMSB(value[0]),
-			findMSB(value[1]),
-			findMSB(value[2]),
-			findMSB(value[3]));
 	}
 }//namespace glm

common/glm/glm/detail/func_matrix.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_matrix.hpp
+/// @file glm/detail/func_matrix.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///
@@ -37,8 +41,7 @@
 /// floating point version is shown.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_matrix
+#pragma once
-#define GLM_CORE_func_matrix
 
 // Dependencies
 #include "../detail/precision.hpp"
@@ -137,8 +140,6 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	/// 
-	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
 	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
 	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
 
@@ -148,7 +149,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_VC11))
+#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
 		template <typename T, precision P, template <typename, precision> class matType>
 		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
 #	endif
@@ -175,5 +176,3 @@ namespace detail
 }//namespace glm
 
 #include "func_matrix.inl"
-
-#endif//GLM_CORE_func_matrix

common/glm/glm/detail/func_matrix.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_matrix.inl
+/// @file glm/detail/func_matrix.inl
 /// @date 2008-03-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -32,173 +36,15 @@
 namespace glm{
 namespace detail
 {
-	template
-	<
-		template <class, precision> class vecTypeA,
-		template <class, precision> class vecTypeB,
-		typename T, precision P
-	>
-	struct compute_outerProduct{};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec2, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec2>::type call(detail::tvec2<T, P> const & c, detail::tvec2<T, P> const & r)
-		{
-			detail::tmat2x2<T, P> m(detail::tmat2x2<T, P>::_null);
-			m[0][0] = c[0] * r[0];
-			m[0][1] = c[1] * r[0];
-			m[1][0] = c[0] * r[1];
-			m[1][1] = c[1] * r[1];
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec3, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec3>::type call(detail::tvec3<T, P> const & c, detail::tvec3<T, P> const & r)
-		{
-			detail::tmat3x3<T, P> m(detail::tmat3x3<T, P>::_null);
-			for(length_t i(0); i < m.length(); ++i)
-				m[i] = c * r[i];
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec4, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec4>::type call(detail::tvec4<T, P> const & c, detail::tvec4<T, P> const & r)
-		{
-			detail::tmat4x4<T, P> m(detail::tmat4x4<T, P>::_null);
-			for(length_t i(0); i < m.length(); ++i)
-				m[i] = c * r[i];
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec2, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec2>::type call(detail::tvec3<T, P> const & c, detail::tvec2<T, P> const & r)
-		{
-			detail::tmat2x3<T, P> m(detail::tmat2x3<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[0][2] = c.z * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[1][2] = c.z * r.y;
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec3, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec3>::type call(detail::tvec2<T, P> const & c, detail::tvec3<T, P> const & r)
-		{
-			detail::tmat3x2<T, P> m(detail::tmat3x2<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[2][0] = c.x * r.z;
-			m[2][1] = c.y * r.z;
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec2, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec2>::type call(detail::tvec4<T, P> const & c, detail::tvec2<T, P> const & r)
-		{
-			detail::tmat2x4<T, P> m(detail::tmat2x4<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[0][2] = c.z * r.x;
-			m[0][3] = c.w * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[1][2] = c.z * r.y;
-			m[1][3] = c.w * r.y;
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec2, detail::tvec4, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec2, detail::tvec4>::type call(detail::tvec2<T, P> const & c, detail::tvec4<T, P> const & r)
-		{
-			detail::tmat4x2<T, P> m(detail::tmat4x2<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[2][0] = c.x * r.z;
-			m[2][1] = c.y * r.z;
-			m[3][0] = c.x * r.w;
-			m[3][1] = c.y * r.w;
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec4, detail::tvec3, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec4, detail::tvec3>::type call(detail::tvec4<T, P> const & c, detail::tvec3<T, P> const & r)
-		{
-			detail::tmat3x4<T, P> m(detail::tmat3x4<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[0][2] = c.z * r.x;
-			m[0][3] = c.w * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[1][2] = c.z * r.y;
-			m[1][3] = c.w * r.y;
-			m[2][0] = c.x * r.z;
-			m[2][1] = c.y * r.z;
-			m[2][2] = c.z * r.z;
-			m[2][3] = c.w * r.z;
-			return m;
-		}
-	};
-
-	template <typename T, precision P>
-	struct compute_outerProduct<detail::tvec3, detail::tvec4, T, P>
-	{
-		GLM_FUNC_QUALIFIER static typename detail::outerProduct_trait<T, P, detail::tvec3, detail::tvec4>::type call(detail::tvec3<T, P> const & c, detail::tvec4<T, P> const & r)
-		{
-			detail::tmat4x3<T, P> m(detail::tmat4x3<T, P>::_null);
-			m[0][0] = c.x * r.x;
-			m[0][1] = c.y * r.x;
-			m[0][2] = c.z * r.x;
-			m[1][0] = c.x * r.y;
-			m[1][1] = c.y * r.y;
-			m[1][2] = c.z * r.y;
-			m[2][0] = c.x * r.z;
-			m[2][1] = c.y * r.z;
-			m[2][2] = c.z * r.z;
-			m[3][0] = c.x * r.w;
-			m[3][1] = c.y * r.w;
-			m[3][2] = c.z * r.w;
-			return m;
-		}
-	};
-
 	template <template <class, precision> class matType, typename T, precision P>
 	struct compute_transpose{};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x2, T, P>
+	struct compute_transpose<tmat2x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x2<T, P> call(tmat2x2<T, P> const & m)
 		{
-			detail::tmat2x2<T, P> result(detail::tmat2x2<T, P>::_null);
+			tmat2x2<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -208,11 +54,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x3, T, P>
+	struct compute_transpose<tmat2x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x2<T, P> call(detail::tmat2x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x2<T, P> call(tmat2x3<T, P> const & m)
 		{
-			detail::tmat3x2<T, P> result(detail::tmat3x2<T, P>::_null);
+			tmat3x2<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -224,11 +70,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat2x4, T, P>
+	struct compute_transpose<tmat2x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x2<T, P> call(detail::tmat2x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x2<T, P> call(tmat2x4<T, P> const & m)
 		{
-			detail::tmat4x2<T, P> result(detail::tmat4x2<T, P>::_null);
+			tmat4x2<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[1][0] = m[0][1];
@@ -242,11 +88,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x2, T, P>
+	struct compute_transpose<tmat3x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x3<T, P> call(detail::tmat3x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x3<T, P> call(tmat3x2<T, P> const & m)
 		{
-			detail::tmat2x3<T, P> result(detail::tmat2x3<T, P>::_null);
+			tmat2x3<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -258,11 +104,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x3, T, P>
+	struct compute_transpose<tmat3x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x3<T, P> call(tmat3x3<T, P> const & m)
 		{
-			detail::tmat3x3<T, P> result(detail::tmat3x3<T, P>::_null);
+			tmat3x3<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -279,11 +125,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat3x4, T, P>
+	struct compute_transpose<tmat3x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x3<T, P> call(detail::tmat3x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x3<T, P> call(tmat3x4<T, P> const & m)
 		{
-			detail::tmat4x3<T, P> result(detail::tmat4x3<T, P>::_null);
+			tmat4x3<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -301,11 +147,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x2, T, P>
+	struct compute_transpose<tmat4x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat2x4<T, P> call(detail::tmat4x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat2x4<T, P> call(tmat4x2<T, P> const & m)
 		{
-			detail::tmat2x4<T, P> result(detail::tmat2x4<T, P>::_null);
+			tmat2x4<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -319,11 +165,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x3, T, P>
+	struct compute_transpose<tmat4x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat3x4<T, P> call(detail::tmat4x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat3x4<T, P> call(tmat4x3<T, P> const & m)
 		{
-			detail::tmat3x4<T, P> result(detail::tmat3x4<T, P>::_null);
+			tmat3x4<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -341,11 +187,11 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_transpose<detail::tmat4x4, T, P>
+	struct compute_transpose<tmat4x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static detail::tmat4x4<T, P> call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static tmat4x4<T, P> call(tmat4x4<T, P> const & m)
 		{
-			detail::tmat4x4<T, P> result(detail::tmat4x4<T, P>::_null);
+			tmat4x4<T, P> result(uninitialize);
 			result[0][0] = m[0][0];
 			result[0][1] = m[1][0];
 			result[0][2] = m[2][0];
@@ -373,18 +219,18 @@ namespace detail
 	struct compute_determinant{};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat2x2, T, P>
+	struct compute_determinant<tmat2x2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat2x2<T, P> const & m)
 		{
 			return m[0][0] * m[1][1] - m[1][0] * m[0][1];
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat3x3, T, P>
+	struct compute_determinant<tmat3x3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat3x3<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat3x3<T, P> const & m)
 		{
 			return
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
@@ -394,9 +240,9 @@ namespace detail
 	};
 
 	template <typename T, precision P>
-	struct compute_determinant<detail::tmat4x4, T, P>
+	struct compute_determinant<tmat4x4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(detail::tmat4x4<T, P> const & m)
+		GLM_FUNC_QUALIFIER static T call(tmat4x4<T, P> const & m)
 		{
 			T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
 			T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
@@ -405,7 +251,7 @@ namespace detail
 			T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
 			T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
 
-			detail::tvec4<T, P> DetCof(
+			tvec4<T, P> DetCof(
 				+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 				- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 				+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -423,8 +269,8 @@ namespace detail
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'matrixCompMult' only accept floating-point inputs");
 
-		matType<T, P> result(matType<T, P>::_null);
+		matType<T, P> result(uninitialize);
-		for(length_t i = 0; i < result.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(result); ++i)
 			result[i] = x[i] * y[i];
 		return result;
 	}
@@ -433,7 +279,11 @@ namespace detail
 	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");
-		return detail::compute_outerProduct<vecTypeA, vecTypeB, T, P>::call(c, r);
+
+		typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type m(uninitialize);
+		for(detail::component_count_t i = 0; i < detail::component_count(m); ++i)
+			m[i] = c * r[i];
+		return m;
 	}
 
 	template <typename T, precision P, template <typename, precision> class matType>
@@ -454,7 +304,7 @@ namespace detail
 	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<matType, T, P>::call(m);
+		return detail::compute_inverse(m);
 	}
 
 }//namespace glm

common/glm/glm/detail/func_noise.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_noise.hpp
+/// @file glm/detail/func_noise.hpp
 /// @date 2008-08-01 / 2011-06-18
 /// @author Christophe Riccio
 ///
@@ -35,8 +39,7 @@
 /// appearance of randomness, but are not truly random.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_func_noise
+#pragma once
-#define glm_core_func_noise
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -64,7 +67,7 @@ namespace glm
 	/// @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 detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+	GLM_FUNC_DECL tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
 
 	/// Returns a 3D noise value based on the input value x.
 	///
@@ -73,7 +76,7 @@ namespace glm
 	/// @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 detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+	GLM_FUNC_DECL tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
 
 	/// Returns a 4D noise value based on the input value x.
 	///
@@ -82,11 +85,9 @@ namespace glm
 	/// @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 detail::tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+	GLM_FUNC_DECL tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
 
 	/// @}
 }//namespace glm
 
 #include "func_noise.inl"
-
-#endif//glm_core_func_noise

common/glm/glm/detail/func_noise.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_noise.inl
+/// @file glm/detail/func_noise.inl
 /// @date 2008-08-01 / 2011-09-27
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -33,43 +37,43 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> grad4(T const & j, detail::tvec4<T, P> const & ip)
+	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
 	{
-		detail::tvec3<T, P> pXYZ = floor(fract(detail::tvec3<T, P>(j) * detail::tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
+		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), detail::tvec3<T, P>(1));
+		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
-		detail::tvec4<T, P> s = detail::tvec4<T, P>(lessThan(detail::tvec4<T, P>(pXYZ, pW), detail::tvec4<T, P>(0.0)));
+		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
-		pXYZ = pXYZ + (detail::tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
+		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
-		return detail::tvec4<T, P>(pXYZ, pW);
+		return tvec4<T, P>(pXYZ, pW);
 	}
 }//namespace detail
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER T noise1(T const & x)
 	{
-		return noise1(detail::tvec2<T, defaultp>(x, T(0)));
+		return noise1(tvec2<T, defaultp>(x, T(0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> noise2(T const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
 	{
-		return detail::tvec2<T, defaultp>(
+		return tvec2<T, defaultp>(
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> noise3(T const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
 	{
-		return detail::tvec3<T, defaultp>(
+		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 detail::tvec4<T, defaultp> noise4(T const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
 	{
-		return detail::tvec4<T, defaultp>(
+		return tvec4<T, defaultp>(
 			noise1(x - T(1.0)),
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)),
@@ -77,38 +81,38 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
 	{
-		detail::tvec4<T, P> const C = detail::tvec4<T, P>(
+		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
-		detail::tvec2<T, P> i  = floor(v + dot(v, detail::tvec2<T, P>(C[1])));
+		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
-		detail::tvec2<T, P> x0 = v -   i + dot(i, detail::tvec2<T, P>(C[0]));
+		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;
-		detail::tvec2<T, P> i1 = (x0.x > x0.y) ? detail::tvec2<T, P>(1, 0) : detail::tvec2<T, P>(0, 1);
+		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 ;
-		detail::tvec4<T, P> x12 = detail::tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T, P>(C.x, C.x, C.z, C.z);
+		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 = detail::tvec4<T, P>(detail::tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
 		
 		// Permutations
 		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T, P> p = detail::permute(
+		tvec3<T, P> p = detail::permute(
-			detail::permute(i.y + detail::tvec3<T, P>(T(0), i1.y, T(1))) + i.x + detail::tvec3<T, P>(T(0), i1.x, T(1)));
+			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
 		
-		detail::tvec3<T, P> m = max(T(0.5) - detail::tvec3<T, P>(
+		tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
 			dot(x0, x0),
-			dot(detail::tvec2<T, P>(x12.x, x12.y), detail::tvec2<T, P>(x12.x, x12.y)),
+			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
-			dot(detail::tvec2<T, P>(x12.z, x12.w), detail::tvec2<T, P>(x12.z, x12.w))), T(0));
+			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
 		
 		m = m * m;
 		m = m * m;
@@ -116,17 +120,17 @@ namespace detail
 		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
 		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
 		
-		detail::tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T, P> h = abs(x) - T(0.5);
+		tvec3<T, P> h = abs(x) - T(0.5);
-		detail::tvec3<T, P> ox = floor(x + T(0.5));
+		tvec3<T, P> ox = floor(x + T(0.5));
-		detail::tvec3<T, P> a0 = x - ox;
+		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
-		detail::tvec3<T, P> g;
+		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;
@@ -135,84 +139,84 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
 	{
-		detail::tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
+		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
 		
 		// First corner
-		detail::tvec3<T, P> i(floor(v + dot(v, detail::tvec3<T, P>(C.y))));
+		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
-		detail::tvec3<T, P> x0(v - i + dot(i, detail::tvec3<T, P>(C.x)));
+		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
 		
 		// Other corners
-		detail::tvec3<T, P> g(step(detail::tvec3<T, P>(x0.y, x0.z, x0.x), x0));
+		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
-		detail::tvec3<T, P> l(T(1) - g);
+		tvec3<T, P> l(T(1) - g);
-		detail::tvec3<T, P> i1(min(g, detail::tvec3<T, P>(l.z, l.x, l.y)));
+		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
-		detail::tvec3<T, P> i2(max(g, detail::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;
-		detail::tvec3<T, P> x1(x0 - i1 + C.x);
+		tvec3<T, P> x1(x0 - i1 + C.x);
-		detail::tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
+		tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
+		tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
 		
 		// Permutations
 		i = mod289(i); 
-		detail::tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
+		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
-			i.z + detail::tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
+			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
-			i.y + detail::tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
+			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
-			i.x + detail::tvec4<T, P>(T(0), i1.x, i2.x, 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
-		detail::tvec3<T, P> ns(n_ * detail::tvec3<T, P>(D.w, D.y, D.z) - detail::tvec3<T, P>(D.x, D.z, D.x));
+		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
 		
-		detail::tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
+		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
 		
-		detail::tvec4<T, P> x_(floor(j * ns.z));
+		tvec4<T, P> x_(floor(j * ns.z));
-		detail::tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
+		tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
 		
-		detail::tvec4<T, P> x(x_ * ns.x + ns.y);
+		tvec4<T, P> x(x_ * ns.x + ns.y);
-		detail::tvec4<T, P> y(y_ * ns.x + ns.y);
+		tvec4<T, P> y(y_ * ns.x + ns.y);
-		detail::tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		tvec4<T, P> h(T(1) - abs(x) - abs(y));
 		
-		detail::tvec4<T, P> b0(x.x, x.y, y.x, y.y);
+		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
-		detail::tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		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;
-		detail::tvec4<T, P> s0(floor(b0) * T(2) + T(1));
+		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
-		detail::tvec4<T, P> s1(floor(b1) * T(2) + T(1));
+		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
-		detail::tvec4<T, P> sh(-step(h, detail::tvec4<T, P>(0.0)));
+		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
 		
-		detail::tvec4<T, P> a0 = detail::tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + detail::tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * detail::tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
+		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);
-		detail::tvec4<T, P> a1 = detail::tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + detail::tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * detail::tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		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);
 		
-		detail::tvec3<T, P> p0(a0.x, a0.y, h.x);
+		tvec3<T, P> p0(a0.x, a0.y, h.x);
-		detail::tvec3<T, P> p1(a0.z, a0.w, h.y);
+		tvec3<T, P> p1(a0.z, a0.w, h.y);
-		detail::tvec3<T, P> p2(a1.x, a1.y, h.z);
+		tvec3<T, P> p2(a1.x, a1.y, h.z);
-		detail::tvec3<T, P> p3(a1.z, a1.w, h.w);
+		tvec3<T, P> p3(a1.z, a1.w, h.w);
 		
 		// Normalise gradients
-		detail::tvec4<T, P> norm = taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		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
-		detail::tvec4<T, P> m = max(T(0.6) - detail::tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
+		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, detail::tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+		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(detail::tvec4<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
 	{
-		detail::tvec4<T, P> const C(
+		tvec4<T, P> const C(
 			0.138196601125011,		// (5 - sqrt(5))/20  G4
 			0.276393202250021,		// 2 * G4
 			0.414589803375032,		// 3 * G4
@@ -222,66 +226,66 @@ namespace detail
 		T const F4 = static_cast<T>(0.309016994374947451);
 		
 		// First corner
-		detail::tvec4<T, P> i  = floor(v + dot(v, detail::tvec4<T, P>(F4)));
+		tvec4<T, P> i  = floor(v + dot(v, tvec4<T, P>(F4)));
-		detail::tvec4<T, P> x0 = v -   i + dot(i, detail::tvec4<T, P>(C.x));
+		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)
-		detail::tvec4<T, P> i0;
+		tvec4<T, P> i0;
-		detail::tvec3<T, P> isX = step(detail::tvec3<T, P>(x0.y, x0.z, x0.w), detail::tvec3<T, P>(x0.x));
+		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
-		detail::tvec3<T, P> isYZ = step(detail::tvec3<T, P>(x0.z, x0.w, x0.w), detail::tvec3<T, P>(x0.y, x0.y, x0.z));
+		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 = detail::tvec4<T, P>(isX.x + isX.y + isX.z, 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 - detail::tvec2<T, P>(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
-		detail::tvec4<T, P> i3 = clamp(i0, T(0), T(1));
+		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
-		detail::tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
+		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
-		detail::tvec4<T, P> i1 = clamp(i0 - T(2), 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
-		detail::tvec4<T, P> x1 = x0 - i1 + C.x;
+		tvec4<T, P> x1 = x0 - i1 + C.x;
-		detail::tvec4<T, P> x2 = x0 - i2 + C.y;
+		tvec4<T, P> x2 = x0 - i2 + C.y;
-		detail::tvec4<T, P> x3 = x0 - i3 + C.z;
+		tvec4<T, P> x3 = x0 - i3 + C.z;
-		detail::tvec4<T, P> x4 = x0 + C.w;
+		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);
-		detail::tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
+		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
-			i.w + detail::tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
+			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
-			i.z + detail::tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
+			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
-			i.y + detail::tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
+			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
-			i.x + detail::tvec4<T, P>(i1.x, i2.x, i3.x, 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.
-		detail::tvec4<T, P> ip = detail::tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
 		
-		detail::tvec4<T, P> p0 = detail::grad4(j0,   ip);
+		tvec4<T, P> p0 = detail::grad4(j0,   ip);
-		detail::tvec4<T, P> p1 = detail::grad4(j1.x, ip);
+		tvec4<T, P> p1 = detail::grad4(j1.x, ip);
-		detail::tvec4<T, P> p2 = detail::grad4(j1.y, ip);
+		tvec4<T, P> p2 = detail::grad4(j1.y, ip);
-		detail::tvec4<T, P> p3 = detail::grad4(j1.z, ip);
+		tvec4<T, P> p3 = detail::grad4(j1.z, ip);
-		detail::tvec4<T, P> p4 = detail::grad4(j1.w, ip);
+		tvec4<T, P> p4 = detail::grad4(j1.w, ip);
 		
 		// Normalise gradients
-		detail::tvec4<T, P> norm = detail::taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		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;
@@ -289,96 +293,96 @@ namespace detail
 		p4 *= taylorInvSqrt(dot(p4, p4));
 		
 		// Mix contributions from the five corners
-		detail::tvec3<T, P> m0 = max(T(0.6) - detail::tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T, P> m1 = max(T(0.6) - detail::tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), 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, detail::tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
+			dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
-			dot(m1 * m1, detail::tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
-			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(x + tvec2<T, P>(0.0)),
-			noise1(detail::tvec2<T, P>(0.0) - x));
+			noise1(tvec2<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
-			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(x + tvec3<T, P>(0.0)),
-			noise1(detail::tvec3<T, P>(0.0) - x));
+			noise1(tvec3<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
 	{
-		return detail::tvec2<T, P>(
+		return tvec2<T, P>(
-			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(0)),
-			noise1(detail::tvec4<T, P>(0) - x));
+			noise1(tvec4<T, P>(0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
-			noise1(x - detail::tvec2<T, P>(1.0)),
+			noise1(x - tvec2<T, P>(1.0)),
-			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(x + tvec2<T, P>(0.0)),
-			noise1(x + detail::tvec2<T, P>(1.0)));
+			noise1(x + tvec2<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
-			noise1(x - detail::tvec3<T, P>(1.0)),
+			noise1(x - tvec3<T, P>(1.0)),
-			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(x + tvec3<T, P>(0.0)),
-			noise1(x + detail::tvec3<T, P>(1.0)));
+			noise1(x + tvec3<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
 	{
-		return detail::tvec3<T, P>(
+		return tvec3<T, P>(
-			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x - tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(0)),
-			noise1(x + detail::tvec4<T, P>(1)));
+			noise1(x + tvec4<T, P>(1)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
-			noise1(x - detail::tvec2<T, P>(1)),
+			noise1(x - tvec2<T, P>(1)),
-			noise1(x + detail::tvec2<T, P>(0)),
+			noise1(x + tvec2<T, P>(0)),
-			noise1(x + detail::tvec2<T, P>(1)),
+			noise1(x + tvec2<T, P>(1)),
-			noise1(x + detail::tvec2<T, P>(2)));
+			noise1(x + tvec2<T, P>(2)));
 	}
 
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
-			noise1(x - detail::tvec3<T, P>(1)),
+			noise1(x - tvec3<T, P>(1)),
-			noise1(x + detail::tvec3<T, P>(0)),
+			noise1(x + tvec3<T, P>(0)),
-			noise1(x + detail::tvec3<T, P>(1)),
+			noise1(x + tvec3<T, P>(1)),
-			noise1(x + detail::tvec3<T, P>(2)));
+			noise1(x + tvec3<T, P>(2)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
 	{
-		return detail::tvec4<T, P>(
+		return tvec4<T, P>(
-			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x - tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + tvec4<T, P>(0)),
-			noise1(x + detail::tvec4<T, P>(1)),
+			noise1(x + tvec4<T, P>(1)),
-			noise1(x + detail::tvec4<T, P>(2)));
+			noise1(x + tvec4<T, P>(2)));
 	}
 	
 }//namespace glm

common/glm/glm/detail/func_packing.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,11 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_packing.hpp
+/// @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
@@ -33,8 +38,7 @@
 /// These functions do not operate component-wise, rather as described in each case.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_packing
+#pragma once
-#define GLM_CORE_func_packing
 
 #include "type_vec2.hpp"
 #include "type_vec4.hpp"
@@ -191,5 +195,3 @@ namespace glm
 }//namespace glm
 
 #include "func_packing.inl"
-
-#endif//GLM_CORE_func_packing

common/glm/glm/detail/func_packing.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_packing.inl
+/// @file glm/detail/func_packing.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -35,7 +39,9 @@ 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);
+		// return reinterpret_cast<uint&>(Topack);
+    uint* ptr(reinterpret_cast<uint*>(&Topack));
+    return *ptr;
 	}
 
 	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint const & p)
@@ -47,7 +53,9 @@ namespace glm
 	GLM_FUNC_QUALIFIER uint packSnorm2x16(vec2 const & v)
 	{
 		i16vec2 Topack(round(clamp(v ,-1.0f, 1.0f) * 32767.0f));
-		return reinterpret_cast<uint32&>(Topack);
+		// return reinterpret_cast<uint32&>(Topack);
+    uint* ptr(reinterpret_cast<uint*>(&Topack));
+    return *ptr;
 	}
 
 	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint const & p)

common/glm/glm/detail/func_trigonometric.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_trigonometric.hpp
+/// @file glm/detail/func_trigonometric.hpp
 /// @date 2008-08-01 / 2011-06-15
 /// @author Christophe Riccio
 ///
@@ -37,8 +41,10 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_trigonometric
+#pragma once
-#define GLM_CORE_func_trigonometric
+
+#include "setup.hpp"
+#include "precision.hpp"
 
 namespace glm
 {
@@ -51,8 +57,8 @@ 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 genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType radians(genType const & degrees);
+	GLM_FUNC_DECL vecType<T, P> radians(vecType<T, P> const & degrees);
 
 	/// Converts radians to degrees and returns the result.
 	///
@@ -60,8 +66,8 @@ 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 genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType degrees(genType const & radians);
+	GLM_FUNC_DECL vecType<T, P> degrees(vecType<T, P> const & radians);
 
 	/// The standard trigonometric sine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -70,8 +76,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType sin(genType const & angle);
+	GLM_FUNC_DECL vecType<T, P> sin(vecType<T, P> const & angle);
 
 	/// The standard trigonometric cosine function. 
 	/// The values returned by this function will range from [-1, 1].
@@ -80,8 +86,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType cos(genType const & angle);
+	GLM_FUNC_DECL vecType<T, P> cos(vecType<T, P> const & angle);
 
 	/// The standard trigonometric tangent function.
 	///
@@ -89,8 +95,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType tan(genType const & angle); 
+	GLM_FUNC_DECL vecType<T, P> tan(vecType<T, P> const & angle); 
 
 	/// Arc sine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [-PI/2, PI/2]. 
@@ -100,8 +106,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType asin(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> asin(vecType<T, P> const & x);
 
 	/// Arc cosine. Returns an angle whose sine is x. 
 	/// The range of values returned by this function is [0, PI]. 
@@ -111,8 +117,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType acos(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> acos(vecType<T, P> const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y/x. 
 	/// The signs of x and y are used to determine what 
@@ -124,8 +130,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType atan(genType const & y, genType const & x);
+	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y, vecType<T, P> const & x);
 
 	/// Arc tangent. Returns an angle whose tangent is y_over_x. 
 	/// The range of values returned by this function is [-PI/2, PI/2].
@@ -134,8 +140,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType atan(genType const & y_over_x);
+	GLM_FUNC_DECL vecType<T, P> atan(vecType<T, P> const & y_over_x);
 
 	/// Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
 	///
@@ -143,8 +149,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType sinh(genType const & angle);
+	GLM_FUNC_DECL vecType<T, P> sinh(vecType<T, P> const & angle);
 
 	/// Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
 	///
@@ -152,8 +158,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType cosh(genType const & angle);
+	GLM_FUNC_DECL vecType<T, P> cosh(vecType<T, P> const & angle);
 
 	/// Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
 	///
@@ -161,8 +167,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType tanh(genType const & angle);
+	GLM_FUNC_DECL vecType<T, P> tanh(vecType<T, P> const & angle);
 
 	/// Arc hyperbolic sine; returns the inverse of sinh.
 	///
@@ -170,8 +176,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType asinh(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> asinh(vecType<T, P> const & x);
 	
 	/// Arc hyperbolic cosine; returns the non-negative inverse
 	/// of cosh. Results are undefined if x < 1.
@@ -180,8 +186,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType acosh(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> acosh(vecType<T, P> const & x);
 
 	/// Arc hyperbolic tangent; returns the inverse of tanh.
 	/// Results are undefined if abs(x) >= 1.
@@ -190,14 +196,10 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.1 Angle and Trigonometry Functions</a>
-	template <typename genType> 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL genType atanh(genType const & x);
+	GLM_FUNC_DECL vecType<T, P> atanh(vecType<T, P> const & x);
 
 	/// @}
 }//namespace glm
 
 #include "func_trigonometric.inl"
-
-#endif//GLM_CORE_func_trigonometric
-
-

common/glm/glm/detail/func_trigonometric.inl

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

common/glm/glm/detail/func_vector_relational.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_vector_relational.hpp
+/// @file glm/detail/func_vector_relational.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///
@@ -38,14 +42,11 @@
 /// call must match.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_func_vector_relational
+#pragma once
-#define GLM_CORE_func_vector_relational
 
 #include "precision.hpp"
 #include "setup.hpp"
 
-#if !((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER <= GLM_COMPILER_VC10)) // Workaround a Visual C++ bug
-
 namespace glm
 {
 	/// @addtogroup core_func_vector_relational
@@ -57,9 +58,8 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	// TODO: Mismatched 
+	template <typename T, precision P, template <typename, precision> class vecType>
-	//template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
-	//GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThan(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x <= y.
 	///
@@ -68,7 +68,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename vecType<T, P>::bool_type lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x > y.
 	///
@@ -77,7 +77,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x >= y.
 	///
@@ -86,7 +86,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -94,9 +94,8 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
-	//TODO: conflicts with definision
+	template <typename T, precision P, template <typename, precision> class vecType>
-	//template <typename T, precision P, template <typename, precision> class vecType>
+	GLM_FUNC_DECL vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y);
-	//GLM_FUNC_DECL typename vecType<T, P>::bool_type equal(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x != y.
 	/// 
@@ -105,7 +104,7 @@ namespace glm
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.7 Vector Relational Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns true if any component of x is true.
 	///
@@ -138,8 +137,4 @@ namespace glm
 	/// @}
 }//namespace glm
 
-#endif
-
 #include "func_vector_relational.inl"
-
-#endif//GLM_CORE_func_vector_relational

common/glm/glm/detail/func_vector_relational.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_vector_relational.inl
+/// @file glm/detail/func_vector_relational.inl
 /// @date 2008-08-03 / 2011-09-09
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -31,100 +35,68 @@
 namespace glm
 {
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type lessThan
+	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+		assert(detail::component_count(x) == detail::component_count(y));
-			"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] < y[i];
 
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type lessThanEqual
+	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+		assert(detail::component_count(x) == detail::component_count(y));
-			"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type greaterThan
+	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+		assert(detail::component_count(x) == detail::component_count(y));
-			"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type greaterThanEqual
+	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+		assert(detail::component_count(x) == detail::component_count(y));
-			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
-		assert(x.length() == y.length());
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type equal
+	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		assert(x.length() == y.length());
+		assert(detail::component_count(x) == detail::component_count(y));
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type notEqual
+	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
-	(
-		vecType<T, P> const & x,
-		vecType<T, P> const & y
-	)
 	{
-		assert(x.length() == y.length());
+		assert(detail::component_count(x) == detail::component_count(y));
 
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < x.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;
 	}
@@ -133,7 +105,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
 	{
 		bool Result = false;
-		for(int i = 0; i < v.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
 			Result = Result || v[i];
 		return Result;
 	}
@@ -142,7 +114,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
 	{
 		bool Result = true;
-		for(int i = 0; i < v.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
 			Result = Result && v[i];
 		return Result;
 	}
@@ -150,8 +122,8 @@ namespace glm
 	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
 	{
-		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		vecType<bool, P> Result(uninitialize);
-		for(int i = 0; i < v.length(); ++i)
+		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
 			Result[i] = !v[i];
 		return Result;
 	}

common/glm/glm/detail/glm.cpp

@@ -12,6 +12,10 @@
 /// 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
@@ -30,11 +34,9 @@
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtx/dual_quaternion.hpp>
 
-namespace glm{
+namespace glm
-namespace detail
 {
 // tvec1 type explicit instantiation
-/*
 template struct tvec1<uint8, lowp>;
 template struct tvec1<uint16, lowp>;
 template struct tvec1<uint32, lowp>;
@@ -43,7 +45,6 @@ template struct tvec1<int8, lowp>;
 template struct tvec1<int16, lowp>;
 template struct tvec1<int32, lowp>;
 template struct tvec1<int64, lowp>;
-template struct tvec1<float16, lowp>;
 template struct tvec1<float32, lowp>;
 template struct tvec1<float64, lowp>;
 
@@ -55,7 +56,6 @@ template struct tvec1<int8, mediump>;
 template struct tvec1<int16, mediump>;
 template struct tvec1<int32, mediump>;
 template struct tvec1<int64, mediump>;
-template struct tvec1<float16, mediump>;
 template struct tvec1<float32, mediump>;
 template struct tvec1<float64, mediump>;
 
@@ -67,10 +67,9 @@ template struct tvec1<int8, highp>;
 template struct tvec1<int16, highp>;
 template struct tvec1<int32, highp>;
 template struct tvec1<int64, highp>;
-template struct tvec1<float16, highp>;
 template struct tvec1<float32, highp>;
 template struct tvec1<float64, highp>;
-*/
+
 // tvec2 type explicit instantiation
 template struct tvec2<uint8, lowp>;
 template struct tvec2<uint16, lowp>;
@@ -283,6 +282,5 @@ template struct tdualquat<float64, mediump>;
 template struct tdualquat<float32, highp>;
 template struct tdualquat<float64, highp>;
 
-}//namespace detail
 }//namespace glm
 

common/glm/glm/detail/intrinsic_common.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_common.hpp
+/// @file glm/detail/intrinsic_common.hpp
 /// @date 2009-05-11 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_common
+#pragma once
-#define glm_detail_intrinsic_common
 
 #include "setup.hpp"
 
@@ -86,4 +85,3 @@ namespace detail
 #include "intrinsic_common.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_common

common/glm/glm/detail/intrinsic_common.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_common.inl
+/// @file glm/detail/intrinsic_common.inl
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_exponential.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_exponential.hpp
+/// @file glm/detail/intrinsic_exponential.hpp
 /// @date 2009-05-11 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_exponential
+#pragma once
-#define glm_detail_intrinsic_exponential
 
 #include "setup.hpp"
 
@@ -76,4 +75,3 @@ GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float *
 }//namespace glm
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_exponential

common/glm/glm/detail/intrinsic_exponential.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_exponential.inl
+/// @file glm/detail/intrinsic_exponential.inl
 /// @date 2011-06-15 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_geometric.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_geometric.hpp
+/// @file glm/detail/intrinsic_geometric.hpp
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_intrinsic_geometric
+#pragma once
-#define glm_core_intrinsic_geometric
 
 #include "setup.hpp"
 
@@ -73,4 +72,3 @@ namespace detail
 #include "intrinsic_geometric.inl"
 
 #endif//GLM_ARCH
-#endif//glm_core_intrinsic_geometric

common/glm/glm/detail/intrinsic_geometric.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_geometric.inl
+/// @file glm/detail/intrinsic_geometric.inl
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -32,32 +32,33 @@ namespace detail{
 //length
 GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
 {
-    __m128 dot0 = sse_dot_ps(x, x);
+	__m128 dot0 = sse_dot_ps(x, x);
 	__m128 sqt0 = _mm_sqrt_ps(dot0);
-    return sqt0;
+	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);
+	__m128 len0 = sse_len_ps(sub0);
-    return len0;
+	return len0;
 }
 
 //dot
 GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
 {
-#   if((GLM_ARCH & GLM_ARCH_AVX) == GLM_ARCH_AVX)
+
-        return _mm_dp_ps(v1, v2, 0xff);
+#	if(GLM_ARCH & GLM_ARCH_AVX)
-#   else
+		return _mm_dp_ps(v1, v2, 0xff);
-        __m128 mul0 = _mm_mul_ps(v1, v2);
+#	else
-        __m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+		__m128 mul0 = _mm_mul_ps(v1, v2);
-        __m128 add0 = _mm_add_ps(mul0, swp0);
+		__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
-        __m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+		__m128 add0 = _mm_add_ps(mul0, swp0);
-        __m128 add1 = _mm_add_ps(add0, swp1);
+		__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
-        return add1;
+		__m128 add1 = _mm_add_ps(add0, swp1);
-#   endif
+		return add1;
+#	endif
 }
 
 // SSE1

common/glm/glm/detail/intrinsic_integer.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_integer.hpp
+/// @file glm/detail/intrinsic_integer.hpp
 /// @date 2009-05-11 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_integer
+#pragma once
-#define glm_detail_intrinsic_integer
 
 #include "glm/glm.hpp"
 
@@ -47,4 +46,3 @@ namespace detail
 #include "intrinsic_integer.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_integer

common/glm/glm/detail/intrinsic_integer.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_integer.inl
+/// @file glm/detail/intrinsic_integer.inl
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_matrix.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_common.hpp
+/// @file glm/detail/intrinsic_common.hpp
 /// @date 2009-06-05 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_matrix
+#pragma once
-#define glm_detail_intrinsic_matrix
 
 #include "setup.hpp"
 
@@ -66,4 +65,3 @@ namespace detail
 #include "intrinsic_matrix.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_matrix

common/glm/glm/detail/intrinsic_matrix.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_common.inl
+/// @file glm/detail/intrinsic_common.inl
 /// @date 2009-06-05 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -448,7 +448,7 @@ GLM_FUNC_QUALIFIER __m128 sse_detd_ps
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//detail::tvec4<T, P> DetCof(
+	//tvec4<T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -514,7 +514,7 @@ GLM_FUNC_QUALIFIER __m128 sse_det_ps
 	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
 	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
 
-	//detail::tvec4<T, P> DetCof(
+	//tvec4<T, P> DetCof(
 	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
 	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
 	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
@@ -1003,7 +1003,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
 	__m128 Sin0 = _mm_set_ss(s);
 	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
 
-	// detail::tvec3<T, P> temp = (valType(1) - c) * axis;
+	// tvec3<T, P> temp = (valType(1) - c) * axis;
 	__m128 Temp0 = _mm_sub_ps(one, CosA);
 	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
 	
@@ -1049,7 +1049,7 @@ GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float con
 	Result[2] = TmpC4;
 	Result[3] = _mm_set_ps(1, 0, 0, 0);
 
-	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::_null);
+	//tmat4x4<valType> Result(uninitialize);
 	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
 	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
 	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];

common/glm/glm/detail/intrinsic_trigonometric.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_trigonometric.hpp
+/// @file glm/detail/intrinsic_trigonometric.hpp
 /// @date 2009-06-09 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_trigonometric
+#pragma once
-#define glm_detail_intrinsic_trigonometric
 
 #include "setup.hpp"
 
@@ -45,4 +44,3 @@ namespace detail
 #include "intrinsic_trigonometric.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_trigonometric

common/glm/glm/detail/intrinsic_trigonometric.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_trigonometric.inl
+/// @file glm/detail/intrinsic_trigonometric.inl
 /// @date 2011-06-15 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_vector_relational.hpp

@@ -21,13 +21,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_vector_relational.hpp
+/// @file glm/detail/intrinsic_vector_relational.hpp
 /// @date 2009-06-09 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_detail_intrinsic_vector_relational
+#pragma once
-#define glm_detail_intrinsic_vector_relational
 
 #include "setup.hpp"
 
@@ -45,4 +44,3 @@ namespace detail
 #include "intrinsic_vector_relational.inl"
 
 #endif//GLM_ARCH
-#endif//glm_detail_intrinsic_vector_relational

common/glm/glm/detail/intrinsic_vector_relational.inl

@@ -21,17 +21,17 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/intrinsic_vector_relational.inl
+/// @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 detail::tvec2<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThan
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -39,14 +39,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
+//    return typename tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThan
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -54,14 +54,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
+//	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 detail::tvec4<T, P>::bool_type lessThan
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThan
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -69,15 +69,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
+//	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 detail::tvec2<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -85,14 +85,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
+//	return typename tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -100,14 +100,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
+//	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 detail::tvec4<T, P>::bool_type lessThanEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type lessThanEqual
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -115,15 +115,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
+//	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 detail::tvec2<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThan
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -131,14 +131,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
+//	return typename tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThan
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -146,14 +146,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
+//	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 detail::tvec4<T, P>::bool_type greaterThan
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThan
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -161,15 +161,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //	
-//	return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
+//	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 detail::tvec2<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -177,14 +177,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
+//	return typename tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -192,14 +192,14 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
+//	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 detail::tvec4<T, P>::bool_type greaterThanEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type greaterThanEqual
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -207,15 +207,15 @@
 //		detail::type<valType>::is_int || 
 //		detail::type<valType>::is_uint);
 //
-//	return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
+//	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 detail::tvec2<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type equal
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -224,14 +224,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
+//	return typename tvec2<T, P>::bool_type(x.x == y.x, x.y == y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type equal
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -240,14 +240,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec3<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
+//	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 detail::tvec4<T, P>::bool_type equal
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type equal
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -256,15 +256,15 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec4<T, P>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
+//	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 detail::tvec2<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec2<T, P>::bool_type notEqual
 //(
-//	detail::tvec2<T, P> const & x, 
+//	tvec2<T, P> const & x, 
-//	detail::tvec2<T, P> const & y
+//	tvec2<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -273,14 +273,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
+//	return typename tvec2<T, P>::bool_type(x.x != y.x, x.y != y.y);
 //}
 //
 //template <typename valType>
-//GLM_FUNC_QUALIFIER typename detail::tvec3<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec3<T, P>::bool_type notEqual
 //(
-//	detail::tvec3<T, P> const & x, 
+//	tvec3<T, P> const & x, 
-//	detail::tvec3<T, P> const & y
+//	tvec3<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -289,14 +289,14 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec3<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
+//	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 detail::tvec4<T, P>::bool_type notEqual
+//GLM_FUNC_QUALIFIER typename tvec4<T, P>::bool_type notEqual
 //(
-//	detail::tvec4<T, P> const & x, 
+//	tvec4<T, P> const & x, 
-//	detail::tvec4<T, P> const & y
+//	tvec4<T, P> const & y
 //)
 //{
 //	GLM_STATIC_ASSERT(
@@ -305,62 +305,62 @@
 //		detail::type<valType>::is_uint || 
 //		detail::type<valType>::is_bool);
 //
-//	return typename detail::tvec4<T, P>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
+//	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(detail::tvec2<bool> const & x)
+//GLM_FUNC_QUALIFIER bool any(tvec2<bool> const & x)
 //{
 //	return x.x || x.y;
 //}
 //
-//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
+//GLM_FUNC_QUALIFIER bool any(tvec3<bool> const & x)
 //{
 //    return x.x || x.y || x.z;
 //}
 //
-//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
+//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 detail::tvec2<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec2<bool>& x)
 //{
 //    return x.x && x.y;
 //}
 //
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec3<bool>& x)
 //{
 //    return x.x && x.y && x.z;
 //}
 //
-//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
+//GLM_FUNC_QUALIFIER bool all(const tvec4<bool>& x)
 //{
 //    return x.x && x.y && x.z && x.w;
 //}
 //
 //// not
-//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec2<bool>::bool_type not_
 //(
-//	detail::tvec2<bool> const & v
+//	tvec2<bool> const & v
 //)
 //{
-//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
+//    return tvec2<bool>::bool_type(!v.x, !v.y);
 //}
 //
-//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec3<bool>::bool_type not_
 //(
-//	detail::tvec3<bool> const & v
+//	tvec3<bool> const & v
 //)
 //{
-//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
+//    return tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
 //}
 //
-//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
+//GLM_FUNC_QUALIFIER tvec4<bool>::bool_type not_
 //(
-//	detail::tvec4<bool> const & v
+//	tvec4<bool> const & v
 //)
 //{
-//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
+//    return tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
 //}

common/glm/glm/detail/precision.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/precision.hpp
+/// @file glm/detail/precision.hpp
 /// @date 2013-04-01 / 2013-04-01
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef GLM_CORE_PRECISION_INCLUDED
+#pragma once
-#define GLM_CORE_PRECISION_INCLUDED
 
 namespace glm
 {
@@ -39,5 +42,3 @@ namespace glm
 		defaultp = highp
 	};
 }//namespace glm
-
-#endif//GLM_CORE_PRECISION_INCLUDED

common/glm/glm/detail/type_float.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/type_float.hpp
+/// @file glm/detail/type_float.hpp
 /// @date 2008-08-22 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_float
+#pragma once
-#define glm_core_type_float
 
 #include "setup.hpp"
 
@@ -91,5 +94,3 @@ namespace detail
 	/// @}
 
 }//namespace glm
-
-#endif//glm_core_type_float

common/glm/glm/detail/type_gentype.hpp

@@ -12,6 +12,10 @@
 /// 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
@@ -21,13 +25,12 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/type_gentype.hpp
+/// @file glm/detail/type_gentype.hpp
 /// @date 2008-10-05 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#ifndef glm_core_type_gentype
+#pragma once
-#define glm_core_type_gentype
 
 namespace glm
 {
@@ -219,5 +222,3 @@ namespace detail
 }//namespace glm
 
 //#include "type_gentype.inl"
-
-#endif//glm_core_type_gentype

common/glm/glm/detail/type_gentype.inl

@@ -12,6 +12,10 @@
 /// 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
@@ -21,7 +25,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/type_gentype.inl
+/// @file glm/detail/type_gentype.inl
 /// @date 2008-10-05 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////