Updated/activated EQDictionary code to use the new possessions enumeration

.travis.yml

@@ -1,18 +1,16 @@
 language: cpp
 compiler: gcc
-sudo: false
-addons:
-  apt:
-    packages:
-    - libmysqlclient-dev
-    - libperl-dev
-    - libboost-dev
-    - liblua5.1-0-dev
-    - zlib1g-dev
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y libmysqlclient-dev libperl-dev libboost-dev liblua5.1-0-dev zlib1g-dev
 script:
   - cmake -G "Unix Makefiles" -DEQEMU_BUILD_TESTS=ON -DEQEMU_ENABLE_BOTS=ON
-  - make -j8
+  - make
   - ./bin/tests
+branches:
+  only:
+    - master
+    - stable
 notifications:
   email: false
   irc:

CMakeLists.txt

@@ -24,8 +24,8 @@
 #EQEMU_DISABLE_LOGSYS
 #EQEMU_COMMANDS_LOGGING
 #EQEMU_BUILD_SERVER
-#EQEMU_BUILD_LOGIN
-#EQEMU_BUILD_TESTS
+#EQEMU_BUILD_LOGIN 
+#EQEMU_BUILD_TESTS 
 #EQEMU_BUILD_PERL
 #EQEMU_BUILD_LUA
 #EQEMU_SANITIZE_LUA_LIBS
@@ -103,7 +103,7 @@ IF(MSVC)
 		SET(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /SAFESEH:NO")
 		SET(CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO} /SAFESEH:NO")
 	ENDIF(EQEMU_DISABLE_SAFESEH)
-
+	
 	OPTION(EQEMU_BUILD_MSVC_MP "Enable build with multiple processes." ON)
 	IF(EQEMU_BUILD_MSVC_MP)
 		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
@@ -115,7 +115,7 @@ IF(MSVC)
 			STRING(REGEX REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
 		ENDIF(${flag_var} MATCHES "/MD")
 	ENDFOREACH(flag_var)
-
+	
 	ADD_DEFINITIONS(-DNOMINMAX)
 ELSE(MSVC)
 	#Normally set by perl but we don't use the perl flags anymore so we set it.
@@ -126,7 +126,6 @@ ENDIF(MSVC)
 IF(UNIX)
 	IF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 		ADD_DEFINITIONS(-DFREEBSD)
-		ADD_DEFINITIONS(-D_GLIBCXX_USE_C99)
 		SET(FREEBSD TRUE)
 	ENDIF(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 	IF(CMAKE_SYSTEM_NAME MATCHES "Darwin")
@@ -306,39 +305,33 @@ FIND_PACKAGE(ZLIB REQUIRED)
 FIND_PACKAGE(MySQL REQUIRED)
 IF(EQEMU_BUILD_PERL)
 	FIND_PACKAGE(PerlLibs REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}")
+	INCLUDE_DIRECTORIES("${PERL_INCLUDE_PATH}")
 ENDIF(EQEMU_BUILD_PERL)
 
 IF(EQEMU_BUILD_LUA)
 	FIND_PACKAGE(EQLua51 REQUIRED)
 	SET(Boost_USE_STATIC_LIBS OFF)
-	SET(Boost_USE_MULTITHREADED ON)
+	SET(Boost_USE_MULTITHREADED ON) 
 	SET(Boost_USE_STATIC_RUNTIME OFF)
 	SET(BOOST_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/boost")
 
 	FIND_PACKAGE(Boost REQUIRED)
-	INCLUDE_DIRECTORIES(SYSTEM "${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
-
+	INCLUDE_DIRECTORIES("${LUA_INCLUDE_DIR}" "${Boost_INCLUDE_DIRS}" "luabind")
+	
 	OPTION(EQEMU_SANITIZE_LUA_LIBS "Sanitize Lua Libraries (Remove OS and IO standard libraries from being able to run)." ON)
 	IF(EQEMU_SANITIZE_LUA_LIBS)
 		ADD_DEFINITIONS(-DSANITIZE_LUA_LIBS)
 	ENDIF(EQEMU_SANITIZE_LUA_LIBS)
 ENDIF(EQEMU_BUILD_LUA)
 
-INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm")
+INCLUDE_DIRECTORIES("${ZLIB_INCLUDE_DIRS}" "${MySQL_INCLUDE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/common/glm/glm")
 
 IF(EQEMU_BUILD_LUA)
     ADD_SUBDIRECTORY(luabind)
 ENDIF(EQEMU_BUILD_LUA)
 
-INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/recast/debug_utils/include")
-INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/recast/detour/include")
-INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/recast/detour_tile_cache/include")
-INCLUDE_DIRECTORIES("${CMAKE_CURRENT_SOURCE_DIR}/recast/recast/include")
-
 IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 	ADD_SUBDIRECTORY(common)
-	ADD_SUBDIRECTORY(recast)
 ENDIF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS)
 IF(EQEMU_BUILD_SERVER)
 	ADD_SUBDIRECTORY(shared_memory)

client_files/export/main.cpp

@@ -17,9 +17,7 @@
 */
 
 #include <stdio.h>
-
-#include "../../common/eqemu_logsys.h"
-#include "../../common/global_define.h"
+#include "../../common/debug.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
@@ -27,55 +25,47 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys Log;
-
 void ExportSpells(SharedDatabase *db);
 void ExportSkillCaps(SharedDatabase *db);
 void ExportBaseData(SharedDatabase *db);
-void ExportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientExport);
-	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log.Out(Logs::General, Logs::Status, "Client Files Export Utility");
+	LogFile->write(EQEMuLog::Status, "Client Files Export Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+		LogFile->write(EQEMuLog::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;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	LogFile->write(EQEMuLog::Status, "Connecting to database...");
 	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
 		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+		LogFile->write(EQEMuLog::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);
-	ExportDBStrings(&database);
-
-	Log.CloseFileLogs();
 
 	return 0;
 }
 
 void ExportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Spells...");
+	LogFile->write(EQEMuLog::Status, "Exporting Spells...");
 
 	FILE *f = fopen("export/spells_us.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/spells_us.txt to write, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open export/spells_us.txt to write, skipping.");
 		return;
 	}
 
@@ -99,6 +89,7 @@ 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);
@@ -112,6 +103,7 @@ 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;
     }
 
@@ -131,6 +123,7 @@ 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;
     }
 
@@ -142,11 +135,11 @@ int GetSkill(SharedDatabase *db, int skill_id, int class_id, int level) {
 }
 
 void ExportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Skill Caps...");
+	LogFile->write(EQEMuLog::Status, "Exporting Skill Caps...");
 
 	FILE *f = fopen("export/SkillCaps.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open export/SkillCaps.txt to write, skipping.");
 		return;
 	}
 
@@ -171,11 +164,11 @@ void ExportSkillCaps(SharedDatabase *db) {
 }
 
 void ExportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting Base Data...");
+	LogFile->write(EQEMuLog::Status, "Exporting Base Data...");
 
 	FILE *f = fopen("export/BaseData.txt", "w");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/BaseData.txt to write, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open export/BaseData.txt to write, skipping.");
 		return;
 	}
 
@@ -196,38 +189,8 @@ void ExportBaseData(SharedDatabase *db) {
 
 			fprintf(f, "%s\n", line.c_str());
 		}
-	}
-
-	fclose(f);
-}
-
-void ExportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Exporting DB Strings...");
-
-	FILE *f = fopen("export/dbstr_us.txt", "w");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open export/dbstr_us.txt to write, skipping.");
-		return;
-	}
-
-	fprintf(f, "Major^Minor^String(New)\n");
-	const std::string query = "SELECT * FROM db_str ORDER BY id, type";
-	auto results = db->QueryDatabase(query);
-	if(results.Success()) {
-		for(auto row = results.begin(); row != results.end(); ++row) {
-			std::string line;
-			unsigned int fields = results.ColumnCount();
-			for(unsigned int rowIndex = 0; rowIndex < fields; ++rowIndex) {
-				if(rowIndex != 0)
-					line.push_back('^');
-
-				if(row[rowIndex] != nullptr) {
-					line += row[rowIndex];
-				}
-			}
-
-			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,8 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
-#include "../../common/eqemu_logsys.h"
-#include "../../common/global_define.h"
+#include "../../common/debug.h"
 #include "../../common/shareddb.h"
 #include "../../common/eqemu_config.h"
 #include "../../common/platform.h"
@@ -25,45 +24,38 @@
 #include "../../common/rulesys.h"
 #include "../../common/string_util.h"
 
-EQEmuLogSys Log;
-
 void ImportSpells(SharedDatabase *db);
 void ImportSkillCaps(SharedDatabase *db);
 void ImportBaseData(SharedDatabase *db);
-void ImportDBStrings(SharedDatabase *db);
 
 int main(int argc, char **argv) {
 	RegisterExecutablePlatform(ExePlatformClientImport);
-	Log.LoadLogSettingsDefaults();
 	set_exception_handler();
 
-	Log.Out(Logs::General, Logs::Status, "Client Files Import Utility");
+	LogFile->write(EQEMuLog::Status, "Client Files Import Utility");
 	if(!EQEmuConfig::LoadConfig()) {
-		Log.Out(Logs::General, Logs::Error, "Unable to load configuration file.");
+		LogFile->write(EQEMuLog::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;
-	Log.Out(Logs::General, Logs::Status, "Connecting to database...");
+	LogFile->write(EQEMuLog::Status, "Connecting to database...");
 	if(!database.Connect(config->DatabaseHost.c_str(), config->DatabaseUsername.c_str(),
 		config->DatabasePassword.c_str(), config->DatabaseDB.c_str(), config->DatabasePort)) {
-		Log.Out(Logs::General, Logs::Error, "Unable to connect to the database, cannot continue without a "
+		LogFile->write(EQEMuLog::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);
-	ImportDBStrings(&database);
 
-	Log.CloseFileLogs();
-	
 	return 0;
 }
 
@@ -72,35 +64,18 @@ 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;
     }
 
 	return results.RowCount();
 }
 
-bool IsStringField(int i) {
-	switch(i)
-	{
-	case 1:
-	case 2:
-	case 3:
-	case 4:
-	case 5:
-	case 6:
-	case 7:
-	case 8:
-		return true;
-		break;
-	default:
-		return false;
-	}
-}
-
 void ImportSpells(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Spells...");
+	LogFile->write(EQEMuLog::Status, "Importing Spells...");
 	FILE *f = fopen("import/spells_us.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/spells_us.txt to read, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open import/spells_us.txt to read, skipping.");
 		return;
 	}
 
@@ -133,12 +108,7 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				if(split[i].compare("") == 0 && !IsStringField(i)) {
-					sql += "0";
-				}
-				else {
-					sql += split[i];
-				}
+				sql += split[i];
 				sql += "'";
 			}
 
@@ -153,12 +123,7 @@ void ImportSpells(SharedDatabase *db) {
 					sql += "'";
 				}
 
-				if(split[i].compare("") == 0 && !IsStringField(i)) {
-					sql += "0";
-				} else {
-					sql += split[i];
-				}
-
+				sql += split[i];
 				sql += "'";
 			}
 
@@ -173,23 +138,23 @@ void ImportSpells(SharedDatabase *db) {
 
 		spells_imported++;
 		if(spells_imported % 1000 == 0) {
-			Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+			LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
 		}
 	}
 
 	if(spells_imported % 1000 != 0) {
-		Log.Out(Logs::General, Logs::Status, "%d spells imported.", spells_imported);
+		LogFile->write(EQEMuLog::Status, "%d spells imported.", spells_imported);
 	}
 
 	fclose(f);
 }
 
 void ImportSkillCaps(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Skill Caps...");
+	LogFile->write(EQEMuLog::Status, "Importing Skill Caps...");
 
 	FILE *f = fopen("import/SkillCaps.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open import/SkillCaps.txt to read, skipping.");
 		return;
 	}
 
@@ -204,6 +169,7 @@ void ImportSkillCaps(SharedDatabase *db) {
 			continue;
 		}
 
+
 		int class_id, skill_id, level, cap;
 		class_id = atoi(split[0].c_str());
 		skill_id = atoi(split[1].c_str());
@@ -220,11 +186,11 @@ void ImportSkillCaps(SharedDatabase *db) {
 }
 
 void ImportBaseData(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing Base Data...");
+	LogFile->write(EQEMuLog::Status, "Importing Base Data...");
 
 	FILE *f = fopen("import/BaseData.txt", "r");
 	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/BaseData.txt to read, skipping.");
+		LogFile->write(EQEMuLog::Error, "Unable to open import/BaseData.txt to read, skipping.");
 		return;
 	}
 
@@ -263,56 +229,3 @@ void ImportBaseData(SharedDatabase *db) {
 
 	fclose(f);
 }
-
-void ImportDBStrings(SharedDatabase *db) {
-	Log.Out(Logs::General, Logs::Status, "Importing DB Strings...");
-
-	FILE *f = fopen("import/dbstr_us.txt", "r");
-	if(!f) {
-		Log.Out(Logs::General, Logs::Error, "Unable to open import/dbstr_us.txt to read, skipping.");
-		return;
-	}
-
-	std::string delete_sql = "DELETE FROM db_str";
-	db->QueryDatabase(delete_sql);
-
-	char buffer[2048];
-	bool first = true;
-	while(fgets(buffer, 2048, f)) {
-		if(first) {
-			first = false;
-			continue;
-		}
-
-		for(int i = 0; i < 2048; ++i) {
-			if(buffer[i] == '\n') {
-				buffer[i] = 0;
-				break;
-			}
-		}
-
-		auto split = SplitString(buffer, '^');
-
-		if(split.size() < 2) {
-			continue;
-		}
-
-		std::string sql;
-		int id, type;
-		std::string value;
-		
-		id = atoi(split[0].c_str());
-		type = atoi(split[1].c_str());
-		
-		if(split.size() >= 3) {
-			value = ::EscapeString(split[2]);
-		}
-
-		sql = StringFormat("INSERT INTO db_str(id, type, value) VALUES(%u, %u, '%s')",
-						   id, type, value.c_str());
-
-		db->QueryDatabase(sql);
-	}
-
-	fclose(f);
-}

cmake/FindMySQL.cmake

@@ -21,12 +21,6 @@ IF(MYSQL_ROOT)
 		NAMES mysql.h
 		PATHS ${MYSQL_ROOT}/include
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
-	)
-	FIND_PATH(MySQL_INCLUDE_DIR
-		NAMES mysql.h
-		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
 	FIND_PATH(MySQL_INCLUDE_DIR
@@ -36,46 +30,49 @@ ELSE(MYSQL_ROOT)
 ENDIF(MYSQL_ROOT)
 
 # Library
-SET(MySQL_NAMES libmysql)
+SET(MySQL_NAMES mysqlclient_r mysqlclient)
 IF(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
 		NAMES ${MySQL_NAMES}
-		PATHS ${MYSQL_ROOT}/lib
+		PATHS ${MYSQL_ROOT}/lib/debug /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
-		NO_DEFAULT_PATH
-		NO_SYSTEM_ENVIRONMENT_PATH
 	)
-	
-	FIND_LIBRARY(MySQL_LIBRARY
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
 		NAMES ${MySQL_NAMES}
+		PATHS ${MYSQL_ROOT}/lib /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ELSE(MYSQL_ROOT)
-	FIND_LIBRARY(MySQL_LIBRARY
-		NAMES ${MySQL_NAMES} mysqlclient_r mysqlclient
+	FIND_LIBRARY(MySQL_LIBRARY_DEBUG
+		NAMES ${MySQL_NAMES}
+		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
+		PATH_SUFFIXES mysql
+	)
+
+	FIND_LIBRARY(MySQL_LIBRARY_RELEASE
+		NAMES ${MySQL_NAMES}
 		PATHS /usr/lib /usr/local/lib /usr/lib64 /usr/local/lib64
 		PATH_SUFFIXES mysql
 	)
 ENDIF(MYSQL_ROOT)
 
-IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+IF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 	SET(MySQL_FOUND TRUE)
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY} )
-ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
+ELSE (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 	SET(MySQL_FOUND FALSE)
 	SET( MySQL_LIBRARIES )
-ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY)
+ENDIF (MySQL_INCLUDE_DIR AND MySQL_LIBRARY_DEBUG AND MySQL_LIBRARY_RELEASE)
 
 
 # handle the QUIETLY and REQUIRED arguments and set MySQL_FOUND to TRUE if
 # all listed variables are TRUE
 INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY MySQL_INCLUDE_DIR)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(MySQL DEFAULT_MSG MySQL_LIBRARY_DEBUG MySQL_LIBRARY_RELEASE MySQL_INCLUDE_DIR)
 
 IF(MySQL_FOUND)
-	SET( MySQL_LIBRARY_RELEASE ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARY_DEBUG ${MySQL_LIBRARY} )
-	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_RELEASE} ${MySQL_LIBRARY_DEBUG} )
+	SET( MySQL_LIBRARIES ${MySQL_LIBRARY_DEBUG} ${MySQL_LIBRARY_RELEASE} )
 ELSE(MySQL_FOUND)
 	SET( MySQL_LIBRARIES )
 ENDIF(MySQL_FOUND)

common/CMakeLists.txt

@@ -8,9 +8,8 @@ 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
@@ -19,7 +18,7 @@ SET(common_sources
 	eqdb_res.cpp
 	eqemu_exception.cpp
 	eqemu_config.cpp
-	eqemu_logsys.cpp
+	eqemu_error.cpp
 	eq_packet.cpp
 	eq_stream.cpp
 	eq_stream_factory.cpp
@@ -32,10 +31,13 @@ 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
@@ -64,15 +66,14 @@ SET(common_sources
 	unix.cpp
 	worldconn.cpp
 	xml_parser.cpp
-	pathfind.cpp
 	platform.cpp
+	patches/client62.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sof.cpp
 	patches/rof.cpp
-	patches/rof2.cpp
 	patches/titanium.cpp
-	patches/uf.cpp
+	patches/underfoot.cpp
 	SocketLib/Base64.cpp
 	SocketLib/File.cpp
 	SocketLib/HttpdCookies.cpp
@@ -96,6 +97,7 @@ SET(common_headers
 	base_packet.h
 	base_data.h
 	bodytypes.h
+	breakdowns.h
 	classes.h
 	condition.h
 	crash.h
@@ -104,6 +106,7 @@ SET(common_headers
 	data_verification.h
 	database.h
 	dbcore.h
+	debug.h
 	deity.h
 	emu_opcodes.h
 	emu_oplist.h
@@ -117,7 +120,7 @@ SET(common_headers
 	eqemu_exception.h
 	eqemu_config.h
 	eqemu_config_elements.h
-	eqemu_logsys.h
+	eqemu_error.h
 	eq_packet.h
 	eq_stream.h
 	eq_stream_factory.h
@@ -133,7 +136,6 @@ 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
@@ -142,12 +144,15 @@ 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
@@ -157,14 +162,12 @@ SET(common_headers
 	packet_dump.h
 	packet_dump_file.h
 	packet_functions.h
-	pathfind.h
 	platform.h
 	proc_launcher.h
 	profiler.h
 	ptimer.h
 	queue.h
 	races.h
-	random.h
 	rdtsc.h
 	rulesys.h
 	ruletypes.h
@@ -188,6 +191,11 @@ SET(common_headers
 	worldconn.h
 	xml_parser.h
 	zone_numbers.h
+	patches/client62.h
+	patches/client62_constants.h
+	patches/client62_itemfields.h
+	patches/client62_ops.h
+	patches/client62_structs.h
 	patches/patches.h
 	patches/sod.h
 	patches/sod_constants.h
@@ -208,21 +216,17 @@ SET(common_headers
 	patches/rof_itemfields.h
 	patches/rof_ops.h
 	patches/rof_structs.h
-	patches/rof2.h
 	patches/rof2_constants.h
-	patches/rof2_itemfields.h
-	patches/rof2_ops.h
-	patches/rof2_structs.h
 	patches/titanium.h
 	patches/titanium_constants.h
 	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_structs.h
-	patches/uf.h
-	patches/uf_constants.h
-	patches/uf_itemfields.h
-	patches/uf_ops.h
-	patches/uf_structs.h
+	patches/underfoot.h
+	patches/underfoot_constants.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_structs.h
 	SocketLib/Base64.h
 	SocketLib/File.h
 	SocketLib/HttpdCookies.h
@@ -241,6 +245,11 @@ SET(common_headers
 )
 
 SOURCE_GROUP(Patches FILES
+	patches/client62.h
+	patches/client62_itemfields.h
+	patches/client62_ops.h
+	patches/client62_constants.h
+	patches/client62_structs.h
 	patches/patches.h
 	patches/sod.h
 	patches/sod_itemfields.h
@@ -260,29 +269,25 @@ SOURCE_GROUP(Patches FILES
 	patches/rof_itemfields.h
 	patches/rof_ops.h
 	patches/rof_constants.h
-	patches/rof_structs.h
-	patches/rof2.h
-	patches/rof2_itemfields.h
-	patches/rof2_ops.h
 	patches/rof2_constants.h
-	patches/rof2_structs.h
+	patches/rof_structs.h
 	patches/titanium.h
 	patches/titanium_itemfields.h
 	patches/titanium_ops.h
 	patches/titanium_constants.h
 	patches/titanium_structs.h
-	patches/uf.h
-	patches/uf_itemfields.h
-	patches/uf_ops.h
-	patches/uf_constants.h
-	patches/uf_structs.h
+	patches/underfoot.h
+	patches/underfoot_itemfields.h
+	patches/underfoot_ops.h
+	patches/underfoot_constants.h
+	patches/underfoot_structs.h
+	patches/client62.cpp
 	patches/patches.cpp
 	patches/sod.cpp
 	patches/sof.cpp
 	patches/rof.cpp
-	patches/rof2.cpp
 	patches/titanium.cpp
-	patches/uf.cpp
+	patches/underfoot.cpp
 )
 
 SOURCE_GROUP(SocketLib FILES
@@ -331,9 +336,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/uf.cpp" PROPERTIES COMPILE_FLAGS -O0)
+	SET_SOURCE_FILES_PROPERTIES("patches/sod.cpp" "patches/sof.cpp" "patches/rof.cpp" "patches/underfoot.cpp" PROPERTIES COMPILE_FLAGS -O0)
 ENDIF(UNIX)
 
-
 SET(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin)

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 "../global_define.h"
+#include "../debug.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 "../global_define.h"
+#include "../debug.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 "../global_define.h"
+#include "../debug.h"
 #include "Utility.h"
 #include "HttpdCookies.h"
 #include "HttpdForm.h"
@@ -194,6 +194,7 @@ 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,6 +110,7 @@ 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;
 	}
@@ -141,6 +142,7 @@ 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,6 +1128,7 @@ 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

@@ -15,12 +15,13 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#include "global_define.h"
+#include "debug.h"
 #include "base_packet.h"
 #include "misc.h"
 #include "packet_dump.h"
 
+
+
 BasePacket::BasePacket(const unsigned char *buf, uint32 len)
 {
 	this->pBuffer=nullptr;

common/base_packet.h

@@ -21,6 +21,7 @@
 #include "types.h"
 #include <stdio.h>
 #include <string.h>
+#include <string>
 
 #ifdef WIN32
 	#include <time.h>
@@ -63,12 +64,9 @@ public:
 	void WriteFloat(float value) { *(float *)(pBuffer + _wpos) = value; _wpos += sizeof(float); }
 	void WriteDouble(double value) { *(double *)(pBuffer + _wpos) = value; _wpos += sizeof(double); }
 	void WriteString(const char * str) { uint32 len = static_cast<uint32>(strlen(str)) + 1; memcpy(pBuffer + _wpos, str, len); _wpos += len; }
-	void WriteData(const void *ptr, size_t n) { memcpy(pBuffer + _wpos, ptr, n); _wpos += (uint32)n; }
 
 	uint8 ReadUInt8() { uint8 value = *(uint8 *)(pBuffer + _rpos); _rpos += sizeof(uint8); return value; }
 	uint8 ReadUInt8(uint32 Offset) const { uint8 value = *(uint8 *)(pBuffer + Offset); return value; }
-	uint16 ReadUInt16() { uint16 value = *(uint16 *)(pBuffer + _rpos); _rpos += sizeof(uint16); return value; }
-	uint16 ReadUInt16(uint32 Offset) const { uint16 value = *(uint16 *)(pBuffer + Offset); return value; }
 	uint32 ReadUInt32() { uint32 value = *(uint32 *)(pBuffer + _rpos); _rpos += sizeof(uint32); return value; }
 	uint32 ReadUInt32(uint32 Offset) const { uint32 value = *(uint32 *)(pBuffer + Offset); return value; }
 	void ReadString(char *str) { uint32 len = static_cast<uint32>(strlen((char *)(pBuffer + _rpos))) + 1; memcpy(str, pBuffer + _rpos, len); _rpos += len; }

common/breakdowns.h

@@ -0,0 +1,134 @@
+/*	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

@@ -14,8 +14,8 @@
 	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/debug.h"
 #include "../common/classes.h"
 
 const char* GetEQClassName(uint8 class_, uint8 level) {
@@ -290,3 +290,50 @@ const char* GetEQClassName(uint8 class_, uint8 level) {
 	}
 }
 
+uint32 GetArrayEQClass(uint8 eqclass) {
+	switch (eqclass) {
+		case WARRIOR:
+			return WARRIOR;
+		case CLERIC:
+			return CLERIC;
+		case PALADIN:
+			return PALADIN;
+		case RANGER:
+			return RANGER;
+		case SHADOWKNIGHT:
+			return SHADOWKNIGHT;
+		case DRUID:
+			return DRUID;
+		case MONK:
+			return MONK;
+		case BARD:
+			return BARD;
+		case ROGUE:
+			return ROGUE;
+		case SHAMAN:
+			return SHAMAN;
+		case NECROMANCER:
+			return NECROMANCER;
+		case WIZARD:
+			return WIZARD;
+		case MAGICIAN:
+			return MAGICIAN;
+		case ENCHANTER:
+			return ENCHANTER;
+		case BEASTLORD:
+			return BEASTLORD;
+		case BERSERKER:
+			return BERSERKER;
+		default:
+			return 0;
+	}
+}
+
+uint8 GetEQArrayEQClass(uint8 eqclass) {
+	if (eqclass >= WARRIOR && eqclass <= BERSERKER)
+		return eqclass - WARRIOR;
+	if (eqclass >= WARRIORGM && eqclass <= BERSERKERGM)
+		return eqclass - WARRIORGM;
+	return WARRIOR;
+}
+

common/classes.h

@@ -86,5 +86,7 @@
 #define call_1 65536
 
 const char* GetEQClassName(uint8 class_, uint8 level = 0);
+uint32 GetArrayEQClass(uint8 eqclass);
+uint8 GetEQArrayEQClass(uint8 eqclass);
 #endif
 

common/clientversions.h

@@ -1,182 +1,76 @@
-/*
-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 CLIENTVERSIONS_H
 #define CLIENTVERSIONS_H
 
-#include "types.h"
-
-static const uint32 BIT_Client62			= 0x00000001; // 1 (unsupported - placeholder for scripts)
-
-static const uint32 BIT_Titanium			= 0x00000002; // 2
-static const uint32 BIT_SoF					= 0x00000004; // 4
-static const uint32 BIT_SoD					= 0x00000008; // 8
-static const uint32 BIT_UF					= 0x00000010; // 16
-static const uint32 BIT_RoF					= 0x00000020; // 32
-static const uint32 BIT_RoF2				= 0x00000040; // 64
-
-static const uint32 BIT_TitaniumAndEarlier	= 0x00000003; // 3
-static const uint32 BIT_SoFAndEarlier		= 0x00000007; // 7
-static const uint32 BIT_SoDAndEarlier		= 0x0000000F; // 15
-static const uint32 BIT_UFAndEarlier		= 0x0000001F; // 31
-static const uint32 BIT_RoFAndEarlier		= 0x0000003F; // 63
-
-static const uint32 BIT_SoFAndLater			= 0xFFFFFFFC; // 4294967292
-static const uint32 BIT_SoDAndLater			= 0xFFFFFFF8; // 4294967288
-static const uint32 BIT_UFAndLater			= 0xFFFFFFF0; // 4294967280
-static const uint32 BIT_RoFAndLater			= 0xFFFFFFE0; // 4294967264
-static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0; // 4294967232
+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_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_RoFAndLater			= 0xFFFFFFE0;
+static const uint32 BIT_RoF2AndLater		= 0xFFFFFFC0;
 static const uint32 BIT_AllClients			= 0xFFFFFFFF;
 
-enum class ClientVersion
+typedef enum
 {
-	Unknown = 0,
-	Client62,	// Build: 'Aug  4 2005 15:40:59'
-	Titanium,	// Build: 'Oct 31 2005 10:33:37'
-	SoF,		// Build: 'Sep  7 2007 09:11:49'
-	SoD,		// Build: 'Dec 19 2008 15:22:49'
-	UF,			// Build: 'Jun  8 2010 16:44:32'
-	RoF,		// Build: 'Dec 10 2012 17:35:44'
-	RoF2,		// Build: 'May 10 2013 23:30:08'
+	EQClientUnknown = 0,
+	EQClient62,				// Build: 'Aug  4 2005 15:40:59'
+	EQClientTitanium,		// Build: 'Oct 31 2005 10:33:37'
+	EQClientSoF,			// Build: 'Sep  7 2007 09:11:49'
+	EQClientSoD,			// Build: 'Dec 19 2008 15:22:49'
+	EQClientUnderfoot,		// Build: 'Jun  8 2010 16:44:32'
+	EQClientRoF,			// Build: 'Dec 10 2012 17:35:44'
+	EQClientRoF2,			// Build: 'May 10 2013 23:30:08'
 
-	MobNPC,
-	MobMerc,
-	MobBot,
-	MobPet,
-};
+	_EQClientCount,			// place new clients before this point (preferably, in release/attribute order)
 
-#define CLIENT_VERSION_COUNT 12
-#define LAST_PC_CLIENT ClientVersion::RoF2
-#define LAST_NPC_CLIENT ClientVersion::MobPet
+	// Values below are not implemented, as yet...
 
+	EmuNPC = _EQClientCount,
+	EmuMerc,
+	EmuBot,
+	EmuPet,
 
-static const char* ClientVersionName(ClientVersion version)
+	_EmuClientCount			// array size for EQLimits
+} EQClientVersion;
+
+static const char* EQClientVersionName(EQClientVersion version)
 {
 	switch (version)
 	{
-	case ClientVersion::Unknown:
-		return "Unknown";
-	case ClientVersion::Client62:
-		return "Client62";
-	case ClientVersion::Titanium:
-		return "Titanium";
-	case ClientVersion::SoF:
-		return "SoF";
-	case ClientVersion::SoD:
-		return "SoD";
-	case ClientVersion::UF:
-		return "UF";
-	case ClientVersion::RoF:
-		return "RoF";
-	case ClientVersion::RoF2:
-		return "RoF2";
-	case ClientVersion::MobNPC:
-		return "MobNPC";
-	case ClientVersion::MobMerc:
-		return "MobMerc";
-	case ClientVersion::MobBot:
-		return "MobBot";
-	case ClientVersion::MobPet:
-		return "MobPet";
+	case EQClientUnknown:
+		return "EQClientUnknown";
+	case EQClient62:
+		return "EQClient62";
+	case EQClientTitanium:
+		return "EQClientTitanium";
+	case EQClientSoF:
+		return "EQClientSoF";
+	case EQClientSoD:
+		return "EQClientSoD";
+	case EQClientUnderfoot:
+		return "EQClientUnderfoot";
+	case EQClientRoF:
+		return "EQClientRoF";
+	case EQClientRoF2:
+		return "EQClientRoF2";
+	case EmuNPC:
+		return "EmuNPC";
+	case EmuMerc:
+		return "EmuMerc";
+	case EmuBot:
+		return "EmuBot";
+	case EmuPet:
+		return "EmuPet";
 	default:
-		return "<ERROR> Invalid ClientVersion";
+		return "ERROR: Invalid EQClientVersion";
 	};
 }
 
-static uint32 ClientBitFromVersion(ClientVersion clientVersion)
-{
-	switch (clientVersion)
-	{
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-		return 0;
-	case ClientVersion::Titanium:
-	case ClientVersion::SoF:
-	case ClientVersion::SoD:
-	case ClientVersion::UF:
-	case ClientVersion::RoF:
-	case ClientVersion::RoF2:
-	case ClientVersion::MobNPC:
-	case ClientVersion::MobMerc:
-	case ClientVersion::MobBot:
-	case ClientVersion::MobPet:
-		return ((uint32)1 << (static_cast<unsigned int>(clientVersion) - 1));
-	default:
-		return 0;
-	}
-}
-
-static ClientVersion ClientVersionFromBit(uint32 clientVersionBit)
-{
-	switch (clientVersionBit)
-	{
-	case (uint32)static_cast<unsigned int>(ClientVersion::Unknown):
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Client62) - 1)):
-		return ClientVersion::Unknown;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::Titanium) - 1)):
-		return ClientVersion::Titanium;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoF) - 1)):
-		return ClientVersion::SoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::SoD) - 1)):
-		return ClientVersion::SoD;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::UF) - 1)):
-		return ClientVersion::UF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF) - 1)):
-		return ClientVersion::RoF;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::RoF2) - 1)):
-		return ClientVersion::RoF2;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobNPC) - 1)):
-		return ClientVersion::MobNPC;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobMerc) - 1)):
-		return ClientVersion::MobMerc;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobBot) - 1)):
-		return ClientVersion::MobBot;
-	case ((uint32)1 << (static_cast<unsigned int>(ClientVersion::MobPet) - 1)):
-		return ClientVersion::MobPet;
-	default:
-		return ClientVersion::Unknown;
-	}
-}
-
-static uint32 ExpansionFromClientVersion(ClientVersion clientVersion)
-{
-	switch(clientVersion)
-	{
-	case ClientVersion::Unknown:
-	case ClientVersion::Client62:
-	case ClientVersion::Titanium:
-		return 0x000007FFU;
-	case ClientVersion::SoF:
-		return 0x00007FFFU;
-	case ClientVersion::SoD:
-		return 0x0000FFFFU;
-	case ClientVersion::UF:
-		return 0x0001FFFFU;
-	case ClientVersion::RoF:
-	case ClientVersion::RoF2:
-		return 0x000FFFFFU;
-	default:
-		return 0;
-	}
-}
-
 #endif /* CLIENTVERSIONS_H */

common/condition.cpp

@@ -16,6 +16,7 @@
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
+#include "debug.h"
 #include "condition.h"
 
 #ifdef _WINDOWS

common/condition.h

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

common/crash.cpp

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

common/database.h

@@ -21,15 +21,11 @@
 #define AUTHENTICATION_TIMEOUT	60
 #define INVALID_ID				0xFFFFFFFF
 
-#include "global_define.h"
-#include "eqemu_logsys.h"
-
+#include "debug.h"
 #include "types.h"
 #include "dbcore.h"
 #include "linked_list.h"
 #include "eq_packet_structs.h"
-
-#include <cmath>
 #include <string>
 #include <vector>
 #include <map>
@@ -37,9 +33,22 @@
 //atoi is not uint32 or uint32 safe!!!!
 #define atoul(str) strtoul(str, nullptr, 10)
 
-class Inventory;
-class MySQLRequestResult;
+//class Spawn;
+class Corpse;
+class Spawn2;
+class NPC;
+class SpawnGroupList;
+class Petition;
 class Client;
+class Merc;
+struct Combine_Struct;
+//struct Faction;
+//struct FactionMods;
+//struct FactionValue;
+struct ZonePoint;
+struct NPCType;
+class Inventory;
+class ItemInst;
 
 struct EventLogDetails_Struct {
 	uint32	id;
@@ -54,206 +63,193 @@ struct EventLogDetails_Struct {
 };
 
 struct CharacterEventLog_Struct {
-	uint32	count;
-	uint8	eventid;
-	EventLogDetails_Struct eld[255];
+uint32	count;
+uint8	eventid;
+EventLogDetails_Struct eld[255];
 };
 
+
+// Added By Hogie
+// INSERT into variables (varname,value) values('decaytime [minlevel] [maxlevel]','[number of seconds]');
+// IE: decaytime 1 54 = Levels 1 through 54
+// decaytime 55 100 = Levels 55 through 100
+// It will always put the LAST time for the level (I think) from the Database
 struct npcDecayTimes_Struct {
 	uint16 minlvl;
 	uint16 maxlvl;
 	uint32 seconds;
 };
-
+// Added By Hogie -- End
 
 struct VarCache_Struct {
-	char varname[26];	
+	char varname[26];	// varname is char(25) in database
 	char value[0];
 };
 
+struct PlayerProfile_Struct;
+struct GuildRankLevel_Struct;
+struct GuildRanks_Struct;
+struct ExtendedProfile_Struct;
+struct GuildMember_Struct;
 class PTimerList;
 
-#ifdef _WINDOWS
-#if _MSC_VER > 1700 // greater than 2012 (2013+)
-#	define _ISNAN_(a) std::isnan(a)
-#else
-#	include <float.h>
-#	define _ISNAN_(a) _isnan(a)
-#endif
-#else
-#	define _ISNAN_(a) std::isnan(a)
-#endif
-
 class Database : public DBcore {
 public:
 	Database();
 	Database(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	bool Connect(const char* host, const char* user, const char* passwd, const char* database,uint32 port);
 	~Database();
+	bool	ThrowDBError(std::string ErrorMessage, std::string query_title, std::string query);
+
+
+	/*
+	* 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	ReserveName(uint32 account_id, char* name);
-	bool	SaveCharacterCreate(uint32 character_id, uint32 account_id, PlayerProfile_Struct* pp);
+	bool	UpdateName(const char* oldname, const char* newname);
 	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	UpdateName(const char* oldname, const char* newname);
+	bool	DeleteCharacter(char* name);
 
-	/* General Information 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);
+	/*
+	* General Information Getting Queries
+	*/
 	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 */
-
-	bool AddClientToInstance(uint16 instance_id, uint32 char_id);
+	/*
+	* 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);
-	bool CheckInstanceExists(uint16 instance_id);
+	void DeleteInstance(uint16 instance_id);
 	bool CheckInstanceExpired(uint16 instance_id);
-	bool CreateInstance(uint16 instance_id, uint32 zone_id, uint32 version, uint32 duration);
+	uint32 ZoneIDFromInstanceID(uint16 instance_id);
+	uint32 VersionFromInstanceID(uint16 instance_id);
+	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
 	bool GetUnusedInstanceID(uint16 &instance_id);
-	bool GlobalInstance(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 RemoveClientFromInstance(uint16 instance_id, uint32 char_id);
 	bool RemoveClientsFromInstance(uint16 instance_id);
-	bool VerifyInstanceAlive(uint16 instance_id, uint32 char_id);
-	bool VerifyZoneInstance(uint32 zone_id, uint16 instance_id);
-
+	bool CheckInstanceExists(uint16 instance_id);
+	void BuryCorpsesInInstance(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);
-	uint16 GetInstanceVersion(uint16 instance_id);
-	uint32 GetTimeRemainingInstance(uint16 instance_id, bool &is_perma);
-	uint32 VersionFromInstanceID(uint16 instance_id);
-	uint32 ZoneIDFromInstanceID(uint16 instance_id);
-
+	void GetCharactersInInstance(uint16 instance_id, std::list<uint32> &charid_list);
 	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 */
+	bool GetAdventureStats(uint32 char_id, uint32 &guk_w, uint32 &mir_w, uint32 &mmc_w, uint32 &ruj_w, uint32 &tak_w,
+		uint32 &guk_l, uint32 &mir_l, uint32 &mmc_l, uint32 &ruj_l, uint32 &tak_l);
 
+	/*
+	* 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);
-	uint32	GetMiniLoginAccount(char* ip);
+	bool	UpdateLiveChar(char* charname,uint32 lsaccount_id);
+	bool	GetLiveChar(uint32 account_id, char* cname);
 	uint8	GetAgreementFlag(uint32 acctid);
-
-	void	GetAccountFromID(uint32 id, char* oAccountName, int16* oStatus);
 	void	SetAgreementFlag(uint32 acctid);
 
-
-	/* Groups */
-	
-	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);
-	
+	/*
+	* Groups
+	*/
 	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	ClearGroup(uint32 gid = 0);
+	char*	GetGroupLeaderForLogin(const char* name,char* leaderbuf);
+
 	void	SetGroupLeaderName(uint32 gid, const char* name);
+	char*	GetGroupLeadershipInfo(uint32 gid, char* leaderbuf, char* maintank = nullptr, char* assist = nullptr, char* puller = nullptr, char *marknpc = nullptr,
+						GroupLeadershipAA_Struct* GLAA = nullptr);
+	void	ClearGroupLeader(uint32 gid = 0);
+	
 
-	/* Raids */
-
-	const char *GetRaidLeaderName(uint32 rid);
-
-	uint32	GetRaidID(const char* name);
-
+	/*
+	* Raids
+	*/
 	void	ClearRaid(uint32 rid = 0);
 	void	ClearRaidDetails(uint32 rid = 0);
-	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);
+	uint32	GetRaidID(const char* name);
+	const char *GetRaidLeaderName(uint32 rid);
 
-	/* Database Conversions 'database_conversions.cpp' */
-
-	bool	CheckDatabaseConversions();
-	bool	CheckDatabaseConvertCorpseDeblob();
-	bool	CheckDatabaseConvertPPDeblob();
-
-	/* Database Variables */
+	bool CheckDatabaseConversions();
 
+	/*
+	* 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 */
-
-	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); }
-	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);
-	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);
+	/*
+	* General Queries
+	*/
 	bool	LoadZoneNames();
-
-	const char*	GetZoneName(uint32 zoneID, bool ErrorUnknown = false);
-
+	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);
-	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	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);
-
-	void	AddReport(std::string who, std::string against, std::string lines);
-	struct TimeOfDay_Struct		LoadTime(time_t &realtime);
-	bool	SaveTime(int8 minute, int8 hour, int8 day, int8 month, int16 year);
-	void	ClearMerchantTemp();
+	uint8	GetRaceSkill(uint8 skillid, uint8 in_race);
+	bool	LoadPTimers(uint32 charid, PTimerList &into);
 	void	ClearPTimers(uint32 charid);
-	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
-	void	SetLFG(uint32 CharID, bool LFG);
+	void	ClearMerchantTemp();
 	void	SetLFP(uint32 CharID, bool LFP);
+	void	SetLFG(uint32 CharID, bool LFG);
+	void	SetFirstLogon(uint32 CharID, uint8 firstlogon);
 	void	SetLoginFlags(uint32 CharID, bool LFP, bool LFG, uint8 firstlogon);
-
-	void	ClearInvSnapshots(bool use_rule = true);
-
-	/* EQEmuLogSys */
-	void	LoadLogSettings(EQEmuLogSys::LogSettings* log_settings);
+	void	AddReport(std::string who, std::string against, std::string lines);
 
 private:
 	void DBInitVars();
@@ -265,14 +261,19 @@ 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();
 };
 
 #endif

common/database_instances.cpp

@@ -1,562 +0,0 @@
-/*	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

@@ -1,17 +1,17 @@
+#include "../common/debug.h"
+
 #ifdef _WINDOWS
 #include <winsock2.h>
 #endif
 
-#include "../common/misc_functions.h"
-#include "../common/eqemu_logsys.h"
-
-#include "dbcore.h"
-
-#include <errmsg.h>
-#include <fstream>
 #include <iostream>
+#include <errmsg.h>
 #include <mysqld_error.h>
+#include <limits.h>
+#include "dbcore.h"
 #include <string.h>
+#include "../common/misc_functions.h"
+#include <cstdlib>
 
 #ifdef _WINDOWS
 	#define snprintf	_snprintf
@@ -102,18 +102,17 @@ 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));
 
-		/* Implement Logging at the Root */
-		if (mysql_errno(&mysql) > 0 && strlen(query) > 0){
-			if (Log.log_settings[Logs::MySQLError].is_category_enabled == 1)
-				Log.Out(Logs::General, Logs::MySQLError, "%i: %s \n %s", mysql_errno(&mysql), mysql_error(&mysql), query);
-		}
-
+#ifdef _EQDEBUG
+		std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
+#endif
 		return MySQLRequestResult(nullptr, 0, 0, 0, 0, mysql_errno(&mysql),errorBuffer);
 
 	}
@@ -126,28 +125,113 @@ 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 (Log.log_settings[Logs::MySQLQuery].is_category_enabled == 1)
+
+
+#if DEBUG_MYSQL_QUERIES >= 1
+	if (requestResult.Success())
 	{
-		if ((strncasecmp(query, "select", 6) == 0))
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s returned)", query, requestResult.RowCount(), requestResult.RowCount() == 1 ? "" : "s");
-		else
-			Log.Out(Logs::General, Logs::MySQLQuery, "%s (%u row%s affected)", query, requestResult.RowsAffected(), requestResult.RowsAffected() == 1 ? "" : "s");
+		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;
 }
 
-void DBcore::TransactionBegin() {
-	QueryDatabase("START TRANSACTION");
-}
+bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum, bool retry) {
+	if (errnum)
+		*errnum = 0;
+	if (errbuf)
+		errbuf[0] = 0;
+	bool ret = false;
+	LockMutex lock(&MDatabase);
+	if (pStatus != Connected)
+		Open();
 
-void DBcore::TransactionCommit() {
-	QueryDatabase("COMMIT");
-}
-
-void DBcore::TransactionRollback() {
-	QueryDatabase("ROLLBACK");
+	if (mysql_real_query(&mysql, query, querylen)) {
+		if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR)
+			pStatus = Error;
+		if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) {
+			if (retry) {
+				std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
+				ret = RunQuery(query, querylen, errbuf, result, affected_rows, last_insert_id, errnum, false);
+				if (ret)
+					std::cout << "Reconnection to database successful." << std::endl;
+			}
+			else {
+				pStatus = Error;
+				if (errnum)
+					*errnum = mysql_errno(&mysql);
+				if (errbuf)
+					snprintf(errbuf, MYSQL_ERRMSG_SIZE, "#%i: %s", mysql_errno(&mysql), mysql_error(&mysql));
+				std::cout << "DB Query Error #" << mysql_errno(&mysql) << ": " << mysql_error(&mysql) << std::endl;
+				ret = false;
+			}
+		}
+		else {
+			if (errnum)
+				*errnum = mysql_errno(&mysql);
+			if (errbuf)
+				snprintf(errbuf, 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
+			ret = false;
+		}
+	}
+	else {
+		if (result && mysql_field_count(&mysql)) {
+			*result = mysql_store_result(&mysql);
+#ifdef _EQDEBUG
+			DBMemLeak::Alloc(*result, query);
+#endif
+		}
+		else if (result)
+			*result = 0;
+		if (affected_rows)
+			*affected_rows = mysql_affected_rows(&mysql);
+		if (last_insert_id)
+			*last_insert_id = (uint32)mysql_insert_id(&mysql);
+		if (result) {
+			if (*result) {
+				ret = true;
+			}
+			else {
+#ifdef _EQDEBUG
+				std::cout << "DB Query Error: No Result" << std::endl;
+#endif
+				if (errnum)
+					*errnum = UINT_MAX;
+				if (errbuf)
+					strcpy(errbuf, "DBcore::RunQuery: No Result");
+				ret = false;
+			}
+		}
+		else {
+			ret = true;
+		}
+	}
+#if DEBUG_MYSQL_QUERIES >= 1
+	if (ret) {
+		std::cout << "query successful";
+		if (result && (*result))
+			std::cout << ", " << (int) mysql_num_rows(*result) << " rows returned";
+		if (affected_rows)
+			std::cout << ", " << (*affected_rows) << " rows affected";
+		std::cout<< std::endl;
+	}
+	else {
+		std::cout << "QUERY: query FAILED" << std::endl;
+	}
+#endif
+	return ret;
 }
 
 uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {

common/dbcore.h

@@ -6,12 +6,15 @@
 	#include <windows.h>
 #endif
 
-#include "../common/mutex.h"
-#include "../common/mysql_request_result.h"
-#include "../common/types.h"
-
 #include <mysql.h>
 #include <string.h>
+#include "../common/types.h"
+#include "../common/mutex.h"
+#include "../common/linked_list.h"
+#include "../common/queue.h"
+#include "../common/timer.h"
+#include "../common/condition.h"
+#include "../common/mysql_request_result.h"
 
 class DBcore {
 public:
@@ -20,11 +23,9 @@ public:
 	DBcore();
 	~DBcore();
 	eStatus	GetStatus() { return pStatus; }
+	bool	RunQuery(const char* query, uint32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0, bool retry = true);
 	MySQLRequestResult	QueryDatabase(const char* query, uint32 querylen, bool retryOnFailureOnce = true);
 	MySQLRequestResult	QueryDatabase(std::string query, bool retryOnFailureOnce = true);
-	void TransactionBegin();
-	void TransactionCommit();
-	void TransactionRollback();
 	uint32	DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
 	void	ping();
 	MYSQL*	getMySQL(){ return &mysql; }

common/dbmemshare.cpp

@@ -0,0 +1,126 @@
+// 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

@@ -0,0 +1,441 @@
+#include <iostream>
+#include <string>
+#include <cstdarg>
+#include <time.h>
+
+#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 "string_util.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[Status] = LOG_LEVEL_STATUS;
+	pLogStatus[Normal] = LOG_LEVEL_NORMAL;
+	pLogStatus[Error] = LOG_LEVEL_ERROR;
+	pLogStatus[Debug] = LOG_LEVEL_DEBUG;
+	pLogStatus[Quest] = LOG_LEVEL_QUEST;
+	pLogStatus[Commands] = LOG_LEVEL_COMMANDS;
+	pLogStatus[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

@@ -0,0 +1,149 @@
+/*	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 "global_define.h"
+#include "debug.h"
 #include "emu_opcodes.h"
 
 const char *OpcodeNames[_maxEmuOpcode+1] = {

common/emu_oplist.h

@@ -74,9 +74,7 @@ N(OP_CharacterCreateRequest),
 N(OP_CharInventory),
 N(OP_Charm),
 N(OP_ChatMessage),
-N(OP_ClearAA),
 N(OP_ClearBlockedBuffs),
-N(OP_ClearLeadershipAbilities),
 N(OP_ClearNPCMarks),
 N(OP_ClearObject),
 N(OP_ClearSurname),
@@ -209,13 +207,11 @@ N(OP_GroupInvite2),
 N(OP_GroupLeaderChange),
 N(OP_GroupLeadershipAAUpdate),
 N(OP_GroupMakeLeader),
-N(OP_GroupMentor),
 N(OP_GroupRoles),
 N(OP_GroupUpdate),
 N(OP_GroupUpdateB),
 N(OP_GroupUpdateLeaderAA),
 N(OP_GuildBank),
-N(OP_GuildBankItemList),
 N(OP_GuildCreate),
 N(OP_GuildDelete),
 N(OP_GuildDemote),
@@ -248,7 +244,6 @@ N(OP_IncreaseStats),
 N(OP_InitialHPUpdate),
 N(OP_InitialMobHealth),
 N(OP_InspectAnswer),
-N(OP_InspectBuffs),
 N(OP_InspectMessageUpdate),
 N(OP_InspectRequest),
 N(OP_InstillDoubt),
@@ -349,7 +344,6 @@ N(OP_OpenTributeMaster),
 N(OP_PDeletePetition),
 N(OP_PetBuffWindow),
 N(OP_PetCommands),
-N(OP_PetHoTT),
 N(OP_Petition),
 N(OP_PetitionBug),
 N(OP_PetitionCheckIn),
@@ -366,8 +360,6 @@ N(OP_PetitionUnCheckout),
 N(OP_PetitionUpdate),
 N(OP_PickPocket),
 N(OP_PlayerProfile),
-N(OP_PlayerStateAdd),
-N(OP_PlayerStateRemove),
 N(OP_PlayEverquestRequest),
 N(OP_PlayEverquestResponse),
 N(OP_PlayMP3),
@@ -523,6 +515,8 @@ N(OP_VetRewardsAvaliable),
 N(OP_VoiceMacroIn),
 N(OP_VoiceMacroOut),
 N(OP_WeaponEquip1),
+N(OP_WeaponEquip2),
+N(OP_WeaponUnequip2),
 N(OP_WearChange),
 N(OP_Weather),
 N(OP_Weblink),
@@ -536,8 +530,6 @@ N(OP_WorldLogout),
 N(OP_WorldObjectsSent),
 N(OP_WorldUnknown001),
 N(OP_XTargetAutoAddHaters),
-N(OP_XTargetOpen),
-N(OP_XTargetOpenResponse),
 N(OP_XTargetRequest),
 N(OP_XTargetResponse),
 N(OP_YellForHelp),
@@ -551,5 +543,4 @@ N(OP_ZoneServerInfo),
 N(OP_ZoneServerReady),
 N(OP_ZoneSpawns),
 N(OP_ZoneUnavail),
-N(OP_ResetAA),
 // mail and chat opcodes located in ../mail_oplist.h

common/emu_tcp_connection.cpp

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

common/emu_tcp_connection.h

@@ -26,7 +26,6 @@
 
 struct SPackSendQueue;
 class EmuTCPServer;
-class ServerPacket;
 
 class EmuTCPConnection : public TCPConnection {
 public:

common/emu_tcp_server.cpp

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

common/eq_constants.h

@@ -19,54 +19,6 @@
 #define EQ_CONSTANTS_H
 
 #include "skills.h"
-#include "types.h"
-
-/*
-** Light Types
-**
-*/
-enum LightTypes
-{
-	lightTypeNone = 0,
-	lightTypeCandle,
-	lightTypeTorch,
-	lightTypeTinyGlowingSkull,
-	lightTypeSmallLantern,
-	lightTypeSteinOfMoggok,
-	lightTypeLargeLantern,
-	lightTypeFlamelessLantern,
-	lightTypeGlobeOfStars,
-	lightTypeLightGlobe,
-	lightTypeLightstone,
-	lightTypeGreaterLightstone,
-	lightTypeFireBeetleEye,
-	lightTypeColdlight,
-	lightTypeUnknown1,
-	lightTypeUnknown2
-};
-
-#define LIGHT_TYPES_COUNT 16
-
-/*
-** Light Levels
-**
-*/
-enum LightLevels
-{
-	lightLevelUnlit = 0,
-	lightLevelCandle,
-	lightLevelTorch,
-	lightLevelSmallMagic,
-	lightLevelRedLight,
-	lightLevelBlueLight,
-	lightLevelSmallLantern,
-	lightLevelMagicLantern,
-	lightLevelLargeLantern,
-	lightLevelLargeMagic,
-	lightLevelBrilliant
-};
-
-#define LIGHT_LEVELS_COUNT 11
 
 /*
 **	Item attributes
@@ -102,7 +54,7 @@ enum ItemClassTypes
 **
 **	(ref: database and eqstr_us.txt)
 **
-**	(Looking at a recent database, it's possible that some of the item values may be off [10-27-2013])
+**	(Looking at a recent database, it's possible that some of the item values may be off [10-27-2013] -U)
 */
 enum ItemUseTypes : uint8
 {
@@ -415,7 +367,7 @@ enum {
 #define AT_DamageState	44	// The damage state of a destructible object (0 through 4)
 //#define AT_Trader		300	// Bazzar Trader Mode
 
-// animations for AT_Anim
+// solar: animations for AT_Anim
 #define ANIM_FREEZE	102
 #define	ANIM_STAND		0x64
 #define	ANIM_SIT		0x6e
@@ -858,77 +810,12 @@ enum MaterialUseSlots : uint8
 **
 */
 
-enum InventoryMapTypes : int16 {
-	MapPossessions = 0,
-	MapBank,
-	MapSharedBank,
-	MapTrade,
-	MapWorld,
-	MapLimbo,
-	MapTribute,
-	MapTrophyTribute,
-	MapGuildTribute,
-	MapMerchant,
-	MapDeleted,
-	MapCorpse,
-	MapBazaar,
-	MapInspect,
-	MapRealEstate,
-	MapViewMODPC,
-	MapViewMODBank,
-	MapViewMODSharedBank,
-	MapViewMODLimbo,
-	MapAltStorage,
-	MapArchived,
-	MapMail,
-	MapGuildTrophyTribute,
-	MapKrono,
-	MapOther,
-	_MapCount
-};
-
-enum InventoryMainTypes : int16 {
-	MainCharm = 0,
-	MainEar1,
-	MainHead,
-	MainFace,
-	MainEar2,
-	MainNeck,
-	MainShoulders,
-	MainArms,
-	MainBack,
-	MainWrist1,
-	MainWrist2,
-	MainRange,
-	MainHands,
-	MainPrimary,
-	MainSecondary,
-	MainFinger1,
-	MainFinger2,
-	MainChest,
-	MainLegs,
-	MainFeet,
-	MainWaist,
-	MainPowerSource = 9999, // temp
-	MainAmmo = 21, // temp
-	MainGeneral1,
-	MainGeneral2,
-	MainGeneral3,
-	MainGeneral4,
-	MainGeneral5,
-	MainGeneral6,
-	MainGeneral7,
-	MainGeneral8,
-	//MainGeneral9,
-	//MainGeneral10,
-	MainCursor,
-	_MainCount
-};
-
 #define INVALID_INDEX	-1
 #define NOT_USED		0
 #define NO_ITEM			0
 
+#define DB_ITEM_CONTAINER_SIZE	255 // probably need to move to database.h
+
 // yes..these are redundant... but, they help to identify and define what is actually being performed
 // plus, since they're pre-op's, they don't affect the actual binary size
 #define MAP_BEGIN	0
@@ -1016,6 +903,4 @@ namespace legacy {
 	} InventorySlot;
 }
 
-static const uint32 MAX_SPELL_DB_ID_VAL = 65535;
-
 #endif

common/eq_dictionary.h

@@ -1,7 +1,7 @@
 /*
 EQEMu:  Everquest Server Emulator
 
-Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+Copyright (C) 2001-2014 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
@@ -26,10 +26,11 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #include "eq_constants.h"
 #include "clientversions.h"
 #include <string>
+#include "../common/patches/client62_constants.h"
 #include "../common/patches/titanium_constants.h"
 #include "../common/patches/sof_constants.h"
 #include "../common/patches/sod_constants.h"
-#include "../common/patches/uf_constants.h"
+#include "../common/patches/underfoot_constants.h"
 #include "../common/patches/rof_constants.h"
 #include "../common/patches/rof2_constants.h"
 
@@ -38,42 +39,38 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 // Hard-coded values usually indicate that further research is needed and the values given are from the old (known) system
 
-// (future use)
-//using namespace RoF2::maps;	// server inventory maps enumeration (code and database sync'd to reference)
-//using namespace RoF::slots;	// server possessions slots enumeration (code and database sync'd to reference)
+using namespace RoF2::maps;		// server inventory maps enumeration (code and database sync'd to reference)
+using namespace RoF2::slots;	// server possessions slots enumeration (code and database sync'd to reference)
 
-class EmuConstants
-{
+class EmuConstants {
 	// an immutable value is required to initialize arrays, etc... use this class as a repository for those
 public:
 	// database
-	static const ClientVersion CHARACTER_CREATION_CLIENT = ClientVersion::RoF2; // adjust according to starting item placement and target client
-
-	static const size_t CHARACTER_CREATION_LIMIT = RoF2::consts::CHARACTER_CREATION_LIMIT;
+	static const EQClientVersion CHARACTER_CREATION_CLIENT = EQClientRoF; // adjust according to starting item placement and target client
 
 	// inventory
-	static uint16 InventoryMapSize(int16 indexMap);
+	static uint16 InventoryMapSize(int16 map);
 	//static std::string InventoryLocationName(Location_Struct location);
-	static std::string InventoryMapName(int16 indexMap);
-	static std::string InventoryMainName(int16 indexMain);
-	static std::string InventorySubName(int16 indexSub);
-	static std::string InventoryAugName(int16 indexAug);
+	static std::string InventoryMapName(int16 map);
+	static std::string InventoryMainName(int16 main);
+	static std::string InventorySubName(int16 sub);
+	static std::string InventoryAugName(int16 aug);
 
 	// 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;
-	static const uint16 MAP_BANK_SIZE = 24;
-	static const uint16 MAP_SHARED_BANK_SIZE = 2;
-	static const uint16 MAP_TRADE_SIZE = 8;
-	static const uint16 MAP_WORLD_SIZE = 10;
-	static const uint16 MAP_LIMBO_SIZE = 36;
-	static const uint16 MAP_TRIBUTE_SIZE = 5; // (need client values)
+	static const uint16	MAP_POSSESSIONS_SIZE = RoF2::consts::MAP_POSSESSIONS_SIZE;
+	static const uint16 MAP_BANK_SIZE = RoF2::consts::MAP_BANK_SIZE;
+	static const uint16 MAP_SHARED_BANK_SIZE = RoF2::consts::MAP_SHARED_BANK_SIZE;
+	static const uint16 MAP_TRADE_SIZE = RoF2::consts::MAP_TRADE_SIZE;
+	static const uint16 MAP_WORLD_SIZE = RoF2::consts::MAP_WORLD_SIZE;
+	static const uint16 MAP_LIMBO_SIZE = RoF2::consts::MAP_LIMBO_SIZE;
+	static const uint16 MAP_TRIBUTE_SIZE = Titanium::consts::MAP_TRIBUTE_SIZE; // server is setup for 'presumed' Titanium value of 5..if Titanium::consts is changed, hard-code this to '5' until server/db is updated
 	static const uint16 MAP_TROPHY_TRIBUTE_SIZE = 0;
 	static const uint16 MAP_GUILD_TRIBUTE_SIZE = 0;
 	static const uint16 MAP_MERCHANT_SIZE = 0;
 	static const uint16 MAP_DELETED_SIZE = 0;
-	static const uint16 MAP_CORPSE_SIZE = _MainCount; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
-	static const uint16 MAP_BAZAAR_SIZE = 80;
-	static const uint16 MAP_INSPECT_SIZE = 22;
+	static const uint16 MAP_CORPSE_SIZE = RoF2::consts::MAP_CORPSE_SIZE; // no bitmask use..limits to size of client corpse window (see EQLimits::InventoryMapSize(MapCorpse, <EQClientVersion))
+	static const uint16 MAP_BAZAAR_SIZE = Titanium::consts::MAP_BAZAAR_SIZE;
+	static const uint16 MAP_INSPECT_SIZE = RoF2::consts::MAP_INSPECT_SIZE;
 	static const uint16 MAP_REAL_ESTATE_SIZE = 0;
 	static const uint16 MAP_VIEW_MOD_PC_SIZE = NOT_USED;
 	static const uint16 MAP_VIEW_MOD_BANK_SIZE = NOT_USED;
@@ -83,117 +80,126 @@ public:
 	static const uint16 MAP_ARCHIVED_SIZE = 0;
 	static const uint16 MAP_MAIL_SIZE = 0;
 	static const uint16 MAP_GUILD_TROPHY_TRIBUTE_SIZE = 0;
-	static const uint16 MAP_KRONO_SIZE = 0;
+	static const uint16 MAP_KRONO_SIZE = RoF::consts::MAP_KRONO_SIZE;
 	static const uint16 MAP_OTHER_SIZE = 0;
 
 	// most of these definitions will go away with the structure-based system..this maintains compatibility for now
 	// (these are mainly to assign specific values to constants used in conversions and to identify per-client ranges/offsets)
-	static const int16 EQUIPMENT_BEGIN = MainCharm;
-	static const int16 EQUIPMENT_END = MainAmmo;
-	static const uint16 EQUIPMENT_SIZE = 22; // does not account for 'Power Source' - used mainly for npc equipment arrays
+	static const int16 EQUIPMENT_BEGIN = RoF2::consts::EQUIPMENT_BEGIN;
+	static const int16 EQUIPMENT_END = RoF2::consts::EQUIPMENT_END;
+	static const uint16 EQUIPMENT_SIZE = RoF2::consts::EQUIPMENT_SIZE;
 
-	static const int16 GENERAL_BEGIN = MainGeneral1;
-	static const int16 GENERAL_END = MainGeneral8;
-	static const uint16 GENERAL_SIZE = 8;
-	static const int16 GENERAL_BAGS_BEGIN = 251;
-	static const int16 GENERAL_BAGS_END_OFFSET = 79;
-	static const int16 GENERAL_BAGS_END = GENERAL_BAGS_BEGIN + GENERAL_BAGS_END_OFFSET;
+	static const int16 GENERAL_BEGIN = RoF2::consts::GENERAL_BEGIN;
+	static const int16 GENERAL_END = RoF2::consts::GENERAL_END;
+	static const uint16 GENERAL_SIZE = RoF2::consts::GENERAL_SIZE;
+	static const int16 GENERAL_BAGS_BEGIN = RoF2::consts::GENERAL_BAGS_BEGIN;
+	static const int16 GENERAL_BAGS_END_OFFSET = RoF2::consts::GENERAL_BAGS_END_OFFSET;
+	static const int16 GENERAL_BAGS_END = RoF2::consts::GENERAL_BAGS_END;
 
-	static const int16 CURSOR_BAG_BEGIN = 331;
-	static const int16 CURSOR_BAG_END_OFFSET = 9;
-	static const int16 CURSOR_BAG_END = CURSOR_BAG_BEGIN + CURSOR_BAG_END_OFFSET;
+	static const int16 CURSOR_BAG_BEGIN = RoF2::consts::CURSOR_BAG_BEGIN;
+	static const int16 CURSOR_BAG_END_OFFSET = RoF2::consts::CURSOR_BAG_END_OFFSET;
+	static const int16 CURSOR_BAG_END = RoF2::consts::CURSOR_BAG_END;
 
-	static const int16 BANK_BEGIN = 2000;
-	static const int16 BANK_END = 2023;
-	static const int16 BANK_BAGS_BEGIN = 2031;
-	static const int16 BANK_BAGS_END_OFFSET = 239;
-	static const int16 BANK_BAGS_END = BANK_BAGS_BEGIN + BANK_BAGS_END_OFFSET;
+	static const int16 BANK_BEGIN = RoF2::consts::BANK_BEGIN;
+	static const int16 BANK_END = RoF2::consts::BANK_END;
+	static const int16 BANK_BAGS_BEGIN = RoF2::consts::BANK_BAGS_BEGIN;
+	static const int16 BANK_BAGS_END_OFFSET = RoF2::consts::BANK_BAGS_END_OFFSET;
+	static const int16 BANK_BAGS_END = RoF2::consts::BANK_BAGS_END;
 
-	static const int16 SHARED_BANK_BEGIN = 2500;
-	static const int16 SHARED_BANK_END = 2501;
-	static const int16 SHARED_BANK_BAGS_BEGIN = 2531;
-	static const int16 SHARED_BANK_BAGS_END_OFFSET = 19;
-	static const int16 SHARED_BANK_BAGS_END = SHARED_BANK_BAGS_BEGIN + SHARED_BANK_BAGS_END_OFFSET;
+	static const int16 SHARED_BANK_BEGIN = RoF2::consts::SHARED_BANK_BEGIN;
+	static const int16 SHARED_BANK_END = RoF2::consts::SHARED_BANK_END;
+	static const int16 SHARED_BANK_BAGS_BEGIN = RoF2::consts::SHARED_BANK_BAGS_BEGIN;
+	static const int16 SHARED_BANK_BAGS_END_OFFSET = RoF2::consts::SHARED_BANK_BAGS_END_OFFSET;
+	static const int16 SHARED_BANK_BAGS_END = RoF2::consts::SHARED_BANK_BAGS_END;
 
-	static const int16 TRADE_BEGIN = 3000;
-	static const int16 TRADE_END = 3007;
-	static const int16 TRADE_NPC_END = 3003;
-	static const int16 TRADE_BAGS_BEGIN = 3031;
-	static const int16 TRADE_BAGS_END_OFFSET = 79;
-	static const int16 TRADE_BAGS_END = TRADE_BAGS_BEGIN + TRADE_BAGS_END_OFFSET;
+	static const int16 TRADE_BEGIN = RoF2::consts::TRADE_BEGIN;
+	static const int16 TRADE_END = RoF2::consts::TRADE_END;
+	static const int16 TRADE_NPC_END = RoF2::consts::TRADE_NPC_END;
+	static const int16 TRADE_NPC_SIZE = RoF2::consts::TRADE_NPC_SIZE;
+	static const int16 TRADE_BAGS_BEGIN = RoF2::consts::TRADE_BAGS_BEGIN;
+	static const int16 TRADE_BAGS_END_OFFSET = RoF2::consts::TRADE_BAGS_END_OFFSET;
+	static const int16 TRADE_BAGS_END = RoF2::consts::TRADE_BAGS_END;
 
-	static const int16 WORLD_BEGIN = 4000;
-	static const int16 WORLD_END = 4009;
+	static const int16 WORLD_BEGIN = RoF2::consts::WORLD_BEGIN;
+	static const int16 WORLD_END = RoF2::consts::WORLD_END;
 	static const int16 WORLD_SIZE = MAP_WORLD_SIZE;
 
-	static const int16 TRIBUTE_BEGIN = 400;
-	static const int16 TRIBUTE_END = 404;
+	static const int16 TRIBUTE_BEGIN = RoF2::consts::TRIBUTE_BEGIN;
+	static const int16 TRIBUTE_END = RoF2::consts::TRIBUTE_END;
 	static const int16 TRIBUTE_SIZE = MAP_TRIBUTE_SIZE;
 
-	static const int16 CORPSE_BEGIN = 22;
-	//static const int16 CORPSE_END = RoF::consts::CORPSE_END; // not ready for use
+	static const int16 CORPSE_BEGIN = RoF2::consts::CORPSE_BEGIN;
+	static const int16 CORPSE_END = RoF2::consts::CORPSE_END;
 
-	static const int16 MATERIAL_BEGIN = MaterialHead;
-	static const int16 MATERIAL_END = MaterialSecondary;
-	static const int16 MATERIAL_TINT_END = MaterialFeet;
-	static const int16 MATERIAL_SIZE = _MaterialCount;
+	static const int16 MATERIAL_BEGIN = Underfoot::consts::MATERIAL_BEGIN;
+	static const int16 MATERIAL_END = Underfoot::consts::MATERIAL_END;
+	static const int16 MATERIAL_TINT_END = Underfoot::consts::MATERIAL_TINT_END;
+	static const int16 MATERIAL_SIZE = Underfoot::consts::MATERIAL_SIZE;
 
 	// items
 	// common and container sizes will not increase until the new 'location' struct is implemented
-	static const uint16 ITEM_COMMON_SIZE = RoF::consts::ITEM_COMMON_SIZE;
-	static const uint16 ITEM_CONTAINER_SIZE = Titanium::consts::ITEM_CONTAINER_SIZE;
+	static const uint16 ITEM_COMMON_SIZE = Underfoot::consts::ITEM_COMMON_SIZE;
+	static const uint16 ITEM_CONTAINER_SIZE = Underfoot::consts::ITEM_CONTAINER_SIZE;
 
-	// BANDOLIERS_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-	static const size_t BANDOLIERS_SIZE = RoF2::consts::BANDOLIERS_SIZE;			// number of bandolier instances
-	static const size_t BANDOLIER_ITEM_COUNT = RoF2::consts::BANDOLIER_ITEM_COUNT;	// number of equipment slots in bandolier instance
+	// player profile
+	//static const uint32 CLASS_BITMASK = 0;	// needs value
+	//static const uint32 RACE_BITMASK = 0;	// needs value
 
-	// POTION_BELT_SIZE sets maximum limit..active limit will need to be handled by the appropriate AA or spell (or item?)
-	static const size_t POTION_BELT_ITEM_COUNT = RoF2::consts::POTION_BELT_ITEM_COUNT;
+	// BANDOLIERS_COUNT sets maximum limit..active limit will need to be handled by the appropriate AA
+	static const uint32 BANDOLIERS_COUNT = Titanium::consts::BANDOLIERS_COUNT;	// count = number of bandolier instances
+	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 = RoF2::consts::TEXT_LINK_BODY_LENGTH;
+	// legacy-related functions
+	//static int ServerToPerlSlot(int slot);	// encode
+	//static int PerlToServerSlot(int slot);	// decode
 };
 
-class EQLimits
-{
+class EQLimits {
 	// values should default to a non-beneficial value..unless value conflicts with intended operation
 	//
 	// EmuConstants may be used as references..but, not every reference needs to be in EmuConstants (i.e., AllowsEmptyBagInBag(), CoinHasWeight(), etc...)
 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 IsValidPCClientVersion(ClientVersion clientVersion);
-	static ClientVersion ValidatePCClientVersion(ClientVersion clientVersion);
+	static bool				IsValidClientVersion(uint32 version);
+	static uint32			ValidateClientVersion(uint32 version);
+	static EQClientVersion	ValidateClientVersion(EQClientVersion version);
 
 	// basically..any non-client classes - do not when setting a valid client
-	static bool IsValidNPCClientVersion(ClientVersion clientVersion);
-	static ClientVersion ValidateNPCClientVersion(ClientVersion clientVersion);
+	static bool				IsValidNPCVersion(uint32 version);
+	static uint32			ValidateNPCVersion(uint32 version);
+	static EQClientVersion	ValidateNPCVersion(EQClientVersion version);
 
 	// these are 'universal' - do not when setting a valid client
-	static bool IsValidMobClientVersion(ClientVersion clientVersion);
-	static ClientVersion ValidateMobClientVersion(ClientVersion clientVersion);
-
-	// database
-	static size_t CharacterCreationLimit(ClientVersion clientVersion);
+	static bool				IsValidMobVersion(uint32 version);
+	static uint32			ValidateMobVersion(uint32 version);
+	static EQClientVersion	ValidateMobVersion(EQClientVersion version);
 
 	// inventory
-	static uint16 InventoryMapSize(int16 indexMap, ClientVersion clientVersion);
-	static uint64 PossessionsBitmask(ClientVersion clientVersion);
-	static uint64 EquipmentBitmask(ClientVersion clientVersion);
-	static uint64 GeneralBitmask(ClientVersion clientVersion);
-	static uint64 CursorBitmask(ClientVersion clientVersion);
+	static uint16	InventoryMapSize(int16 map, uint32 version);
+	static uint64	PossessionsBitmask(uint32 version);
+	static uint64	EquipmentBitmask(uint32 version);
+	static uint64	GeneralBitmask(uint32 version);
+	static uint64	CursorBitmask(uint32 version);
 
-	static bool AllowsEmptyBagInBag(ClientVersion clientVersion);
-	static bool AllowsClickCastFromBag(ClientVersion clientVersion);
+	static bool	AllowsEmptyBagInBag(uint32 version);
+	static bool AllowsClickCastFromBag(uint32 version);
 
 	// items
-	static uint16 ItemCommonSize(ClientVersion clientVersion);
-	static uint16 ItemContainerSize(ClientVersion clientVersion);
+	static uint16	ItemCommonSize(uint32 version);
+	static uint16	ItemContainerSize(uint32 version);
 
 	// player profile
-	static bool CoinHasWeight(ClientVersion clientVersion);
+	static bool	CoinHasWeight(uint32 version);
+
+	static uint32	BandoliersCount(uint32 version);
+	static uint32	BandolierSize(uint32 version);
+
+	static uint32	PotionBeltSize(uint32 version);
 };
 
-#endif /* EQ_DICTIONARY_H */
+#endif /* EQ_LIMITS_H */
 
 /*
 Working Notes:

common/eq_packet.cpp

@@ -15,22 +15,18 @@
 	along with this program; if not, write to the Free Software
 	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
-
-#include "crc16.h"
-#include "global_define.h"
+#include "debug.h"
+#include <stdio.h>
+#include <iostream>
+#include <iomanip>
 #include "eq_packet.h"
 #include "misc.h"
 #include "op_codes.h"
+#include "crc16.h"
 #include "platform.h"
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <stdio.h>
-
 #ifndef STATIC_OPCODE
 #include "opcodemgr.h"
 #endif
-
 #include "packet_dump.h"
 #include "packet_functions.h"
 #include <cstdlib>
@@ -511,8 +507,3 @@ 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

@@ -19,8 +19,9 @@
 #define _EQPACKET_H
 
 #include "base_packet.h"
+#include "eq_stream_type.h"
+#include "op_codes.h"
 #include "platform.h"
-#include <iostream>
 
 #ifdef STATIC_OPCODE
 	typedef unsigned short EmuOpcode;
@@ -29,6 +30,9 @@
 #include "emu_opcodes.h"
 #endif
 
+class EQStream;
+class EQStreamPair;
+
 class EQPacket : public BasePacket {
 	friend class EQStream;
 public:
@@ -147,6 +151,6 @@ protected:
 };
 
 extern void DumpPacket(const EQApplicationPacket* app, bool iShowInfo = false);
-extern std::string DumpPacketToString(const EQApplicationPacket* app);
+
 
 #endif

common/eq_stream.h

@@ -1,26 +1,22 @@
 #ifndef _EQSTREAM_H
 #define _EQSTREAM_H
 
+#include <string>
 #include <vector>
 #include <map>
 #include <queue>
 #include <deque>
-
 #ifndef WIN32
 #include <netinet/in.h>
 #endif
-
-#include "../common/misc.h"
-#include "../common/opcodemgr.h"
-#include "../common/timer.h"
-
+#include "eq_stream_type.h"
 #include "eq_packet.h"
 #include "eq_stream_intf.h"
-#include "eq_stream_type.h"
 #include "mutex.h"
-
-class EQApplicationPacket;
-class EQProtocolPacket;
+#include "../common/opcodemgr.h"
+#include "../common/misc.h"
+#include "../common/condition.h"
+#include "../common/timer.h"
 
 #define FLAG_COMPRESSED	0x01
 #define FLAG_ENCODED	0x04
@@ -49,10 +45,6 @@ class EQProtocolPacket;
 #define RETRANSMIT_ACKED_PACKETS true
 #endif
 
-#ifndef MAX_SESSION_RETRIES
-#define MAX_SESSION_RETRIES 30
-#endif
-
 #pragma pack(1)
 struct SessionRequest {
 	uint32 UnknownA;
@@ -71,7 +63,7 @@ struct SessionResponse {
 };
 
 //Deltas are in ms, representing round trip times
-struct ClientSessionStats {
+struct SessionStats {
 /*000*/	uint16 RequestID;
 /*002*/	uint32 last_local_delta;
 /*006*/	uint32 average_delta;
@@ -83,19 +75,10 @@ struct ClientSessionStats {
 /*038*/
 };
 
-struct ServerSessionStats {
-/*000*/	uint16 RequestID;
-/*002*/	uint32 ServerTime;
-/*006*/	uint64 packets_sent_echo;
-/*014*/	uint64 packets_received_echo;
-/*022*/	uint64 packets_sent;
-/*030*/	uint64 packets_received;
-/*038*/
-};
-
 #pragma pack()
 
 class OpcodeManager;
+class EQStreamPair;
 class EQRawApplicationPacket;
 
 class EQStream : public EQStreamInterface {
@@ -118,9 +101,6 @@ class EQStream : public EQStreamInterface {
 		uint32 retransmittimer;
 		uint32 retransmittimeout;
 
-		uint16 sessionAttempts;
-		bool streamactive;
-
 		//uint32 buffer_len;
 
 		uint32 Session, Key;
@@ -168,9 +148,6 @@ class EQStream : public EQStreamInterface {
 
 		int32 BytesWritten;
 
-		uint64 sent_packet_count;
-		uint64 received_packet_count;
-
 		Mutex MRate;
 		int32 RateThreshold;
 		int32 DecayRate;
@@ -217,16 +194,10 @@ class EQStream : public EQStreamInterface {
 
 		void _SendDisconnect();
 
-		void init(bool resetSession=true);
+		void init();
 	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(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(); }
+		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(); }
+		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; }
 
@@ -250,9 +221,6 @@ class EQStream : public EQStreamInterface {
 		void SetLastPacketTime(uint32 t) {LastPacket=t;}
 		void Write(int eq_fd);
 
-		// whether or not the stream has been assigned (we passed our stream match)
-		void SetActive(bool val) { streamactive = val; }
-
 		//
 		inline bool IsInUse() { bool flag; MInUse.lock(); flag=(active_users>0); MInUse.unlock(); return flag; }
 		inline void PutInUse() { MInUse.lock(); active_users++; MInUse.unlock(); }
@@ -278,13 +246,11 @@ class EQStream : public EQStreamInterface {
 		void AddBytesSent(uint32 bytes)
 		{
 			bytes_sent += bytes;
-			++sent_packet_count;
 		}
 
 		void AddBytesRecv(uint32 bytes)
 		{
 			bytes_recv += bytes;
-			++received_packet_count;
 		}
 
 		virtual const uint32 GetBytesSent() const { return bytes_sent; }
@@ -303,9 +269,6 @@ class EQStream : public EQStreamInterface {
 			return bytes_recv / (Timer::GetTimeSeconds() - create_time);
 		}
 
-		const uint64 GetPacketsSent() { return sent_packet_count; }
-		const uint64 GetPacketsReceived() { return received_packet_count; }
-
 		//used for dynamic stream identification
 		class Signature {
 		public:

common/eq_stream_factory.cpp

@@ -1,7 +1,5 @@
-#include "global_define.h"
-#include "eqemu_logsys.h"
+#include "debug.h"
 #include "eq_stream_factory.h"
-
 #ifdef _WINDOWS
 	#include <winsock.h>
 	#include <process.h>
@@ -15,24 +13,24 @@
 	#include <netdb.h>
 	#include <pthread.h>
 #endif
-
-#include <iostream>
 #include <fcntl.h>
-
+#include <iostream>
 #include "op_codes.h"
+#include "eq_stream.h"
+#include "logsys.h"
 
 ThreadReturnType EQStreamFactoryReaderLoop(void *eqfs)
 {
 EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	_log(COMMON__THREADS, "Starting EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->ReaderLoop();
 
 #ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
+	_log(COMMON__THREADS, "Ending EQStreamFactoryReaderLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -43,13 +41,13 @@ ThreadReturnType EQStreamFactoryWriterLoop(void *eqfs)
 	EQStreamFactory *fs=(EQStreamFactory *)eqfs;
 
 #ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	_log(COMMON__THREADS, "Starting EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	fs->WriterLoop();
 
 #ifndef WIN32
-	Log.Out(Logs::Detail, Logs::None,  "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
+	_log(COMMON__THREADS, "Ending EQStreamFactoryWriterLoop with thread ID %d", pthread_self());
 #endif
 
 	THREAD_RETURN(nullptr);
@@ -106,6 +104,8 @@ 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);
@@ -116,39 +116,44 @@ struct sockaddr_in address;
 	return true;
 }
 
-std::shared_ptr<EQStream> EQStreamFactory::Pop()
+EQStream *EQStreamFactory::Pop()
 {
-	std::shared_ptr<EQStream> s = nullptr;
+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(std::shared_ptr<EQStream> s)
+void EQStreamFactory::Push(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;
-	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-	int num;
-	int length;
-	unsigned char buffer[2048];
-	sockaddr_in from;
-	int socklen = sizeof(sockaddr_in);
-	timeval sleep_time;
-	ReaderRunning = true;
+fd_set readset;
+std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+int num;
+int length;
+unsigned char buffer[2048];
+sockaddr_in from;
+int socklen=sizeof(sockaddr_in);
+timeval sleep_time;
+//time_t now;
 
+	ReaderRunning=true;
 	while(sock!=-1) {
 		MReaderRunning.lock();
 		if (!ReaderRunning)
@@ -179,10 +184,10 @@ void EQStreamFactory::ReaderLoop()
 				// 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) {
-						std::shared_ptr<EQStream> s = std::make_shared<EQStream>(from);
+						EQStream *s = new EQStream(from);
 						s->SetStreamType(StreamType);
 						Streams[std::make_pair(from.sin_addr.s_addr, from.sin_port)]=s;
 						WriterWork.Signal();
@@ -193,13 +198,13 @@ void EQStreamFactory::ReaderLoop()
 					}
 					MStreams.unlock();
 				} else {
-					std::shared_ptr<EQStream> curstream = stream_itr->second;
+					EQStream *curstream = stream_itr->second;
 					//dont bother processing incoming packets for closed connections
 					if(curstream->CheckClosed())
 						curstream = nullptr;
 					else
 						curstream->PutInUse();
-						//the in use flag prevents the stream from being deleted while we are using it.
+					MStreams.unlock();	//the in use flag prevents the stream from being deleted while we are using it.
 
 					if(curstream) {
 						curstream->AddBytesRecv(length);
@@ -207,7 +212,6 @@ void EQStreamFactory::ReaderLoop()
 						curstream->SetLastPacketTime(Timer::GetCurrentTime());
 						curstream->ReleaseFromUse();
 					}
-					MStreams.unlock();
 				}
 			}
 		}
@@ -220,10 +224,10 @@ void EQStreamFactory::CheckTimeout()
 	MStreams.lock();
 
 	unsigned long now=Timer::GetCurrentTime();
-	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
+	std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
 
-	for(stream_itr = Streams.begin(); stream_itr != Streams.end();) {
-		std::shared_ptr<EQStream> s = stream_itr->second;
+	for(stream_itr=Streams.begin();stream_itr!=Streams.end();) {
+		EQStream *s = stream_itr->second;
 
 		s->CheckTimeout(now, stream_timeout);
 
@@ -235,9 +239,11 @@ void EQStreamFactory::CheckTimeout()
 				//give it a little time for everybody to finish with it
 			} else {
 				//everybody is done, we can delete it now
-				std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator temp = stream_itr;
+				//std::cout << "Removing connection" << std::endl;
+				std::map<std::pair<uint32, uint16>,EQStream *>::iterator temp=stream_itr;
 				++stream_itr;
-				temp->second = nullptr;
+				//let whoever has the stream outside delete it
+				delete temp->second;
 				Streams.erase(temp);
 				continue;
 			}
@@ -250,17 +256,21 @@ void EQStreamFactory::CheckTimeout()
 
 void EQStreamFactory::WriterLoop()
 {
-	std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>>::iterator stream_itr;
-	bool havework=true;
-	std::vector<std::shared_ptr<EQStream>> wants_write;
-	std::vector<std::shared_ptr<EQStream>>::iterator cur, end;
-	bool decay = false;
-	uint32 stream_count;
-	Timer DecayTimer(20);
-	WriterRunning = true;
-	DecayTimer.Enable();
+std::map<std::pair<uint32, uint16>,EQStream *>::iterator stream_itr;
+bool havework=true;
+std::vector<EQStream *> wants_write;
+std::vector<EQStream *>::iterator cur,end;
+bool decay=false;
+uint32 stream_count;
 
+Timer DecayTimer(20);
+
+	WriterRunning=true;
+	DecayTimer.Enable();
 	while(sock!=-1) {
+		//if (!havework) {
+			//WriterWork.Wait();
+		//}
 		MWriterRunning.lock();
 		if (!WriterRunning)
 			break;
@@ -281,7 +291,7 @@ void EQStreamFactory::WriterLoop()
 
 			//bullshit checking, to see if this is really happening, GDB seems to think so...
 			if(stream_itr->second == nullptr) {
-				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i:%i", stream_itr->first.first, stream_itr->first.second);
+				fprintf(stderr, "ERROR: nullptr Stream encountered in EQStreamFactory::WriterLoop for: %i", stream_itr->first.first, stream_itr->first.second);
 				continue;
 			}
 
@@ -304,10 +314,12 @@ void EQStreamFactory::WriterLoop()
 		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,16 +2,13 @@
 
 #define _EQSTREAMFACTORY_H
 
-#include <memory>
 #include <queue>
 #include <map>
-
 #include "../common/eq_stream.h"
 #include "../common/condition.h"
 #include "../common/timeoutmgr.h"
-
-class EQStream;
-class Timer;
+#include "../common/opcodemgr.h"
+#include "../common/timer.h"
 
 class EQStreamFactory : private Timeoutable {
 	private:
@@ -27,10 +24,10 @@ class EQStreamFactory : private Timeoutable {
 
 		EQStreamType StreamType;
 
-		std::queue<std::shared_ptr<EQStream>> NewStreams;
+		std::queue<EQStream *> NewStreams;
 		Mutex MNewStreams;
 
-		std::map<std::pair<uint32, uint16>, std::shared_ptr<EQStream>> Streams;
+		std::map<std::pair<uint32, uint16>,EQStream *> Streams;
 		Mutex MStreams;
 
 		virtual void CheckTimeout();
@@ -43,8 +40,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);
 
-		std::shared_ptr<EQStream> Pop();
-		void Push(std::shared_ptr<EQStream> s);
+		EQStream *Pop();
+		void Push(EQStream *s);
 
 		bool Open();
 		bool Open(unsigned long port) { Port=port; return Open(); }

common/eq_stream_ident.cpp

@@ -1,20 +1,20 @@
-#include "global_define.h"
-#include "eqemu_logsys.h"
+#include "debug.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;
-		r.stream->ReleaseFromUse();
+		Record *r = *cur;
+		r->stream->ReleaseFromUse();
+		delete r;
 	}
 	std::vector<Patch *>::iterator curp, endp;
 	curp = m_patches.begin();
@@ -34,52 +34,54 @@ 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.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d before timeout.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
-			r.stream->ReleaseFromUse();
+			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before timeout.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			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.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())
+			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d before it closed.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			switch(r->stream->GetState())
 			{
 			case ESTABLISHED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Established");
+				_log(NET__IDENTIFY, "Stream state was Established");
 				break;
 			case CLOSING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closing");
+				_log(NET__IDENTIFY, "Stream state was Closing");
 				break;
 			case DISCONNECTING:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Disconnecting");
+				_log(NET__IDENTIFY, "Stream state was Disconnecting");
 				break;
 			case CLOSED:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Closed");
+				_log(NET__IDENTIFY, "Stream state was Closed");
 				break;
 			default:
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Stream state was Unestablished or unknown");
+				_log(NET__IDENTIFY, "Stream state was Unestablished or unknown");
 				break;
 			}
-			r.stream->ReleaseFromUse();
+			r->stream->ReleaseFromUse();
+			delete r;
 			cur = m_streams.erase(cur);
 			continue;
 		}
@@ -96,23 +98,20 @@ 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.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());
+//				_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());
 				all_ready = false;
 				break;
 			case EQStream::MatchSuccessful: {
 				//yay, a match.
 
-				Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Identified stream %s:%d with signature %s", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
-
-				// 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);
+				_log(NET__IDENTIFY, "Identified stream %s:%d with signature %s", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()), p->name.c_str());
 
 				//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;
@@ -120,7 +119,7 @@ void EQStreamIdentifier::Process() {
 			}
 			case EQStream::MatchFailed:
 				//do nothing...
-				Log.Out(Logs::General, Logs::Netcode, "[IDENT_TRACE] %s:%d: Tried patch %s, and it did not match.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()), p->name.c_str());
+				_log(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());
 				break;
 			}
 		}
@@ -128,13 +127,14 @@ void EQStreamIdentifier::Process() {
 		//if we checked all patches and did not find a match.
 		if(all_ready && !found_one) {
 			//the stream cannot be identified.
-			Log.Out(Logs::General, Logs::Netcode, "[IDENTIFY] Unable to identify stream from %s:%d, no match found.", long2ip(r.stream->GetRemoteIP()).c_str(), ntohs(r.stream->GetRemotePort()));
-			r.stream->ReleaseFromUse();
+			_log(NET__IDENTIFY, "Unable to identify stream from %s:%d, no match found.", long2ip(r->stream->GetRemoteIP()).c_str(), ntohs(r->stream->GetRemotePort()));
+			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;
@@ -142,8 +142,8 @@ void EQStreamIdentifier::Process() {
 	}	//end foreach stream
 }
 
-void EQStreamIdentifier::AddStream(std::shared_ptr<EQStream> &eqs) {
-	m_streams.push_back(Record(eqs));
+void EQStreamIdentifier::AddStream(EQStream *&eqs) {
+	m_streams.push_back(new Record(eqs));
 	eqs = nullptr;
 }
 
@@ -155,7 +155,7 @@ EQStreamInterface *EQStreamIdentifier::PopIdentified() {
 	return(res);
 }
 
-EQStreamIdentifier::Record::Record(std::shared_ptr<EQStream> s)
+EQStreamIdentifier::Record::Record(EQStream *s)
 :	stream(s),
 	expire(STREAM_IDENT_WAIT_MS)
 {

common/eq_stream_ident.h

@@ -4,14 +4,13 @@
 #include "eq_stream.h"
 #include "timer.h"
 #include <vector>
+#include <string>
 #include <queue>
-#include <memory>
 
 #define STREAM_IDENT_WAIT_MS 10000
 
 class OpcodeManager;
 class StructStrategy;
-class EQStreamInterface;
 
 class EQStreamIdentifier {
 public:
@@ -22,7 +21,7 @@ public:
 
 	//main processing interface
 	void Process();
-	void AddStream(std::shared_ptr<EQStream> &eqs);
+	void AddStream(EQStream *& eqs);
 	EQStreamInterface *PopIdentified();
 
 protected:
@@ -40,11 +39,11 @@ protected:
 	//pending streams..
 	class Record {
 	public:
-		Record(std::shared_ptr<EQStream> s);
-		std::shared_ptr<EQStream> stream;		//we own this
+		Record(EQStream *s);
+		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 ClientVersion GetClientVersion() const { return ClientVersion::Unknown; }
+	virtual const EQClientVersion ClientVersion() const { return EQClientUnknown; }
 };
 
 #endif /*EQSTREAMINTF_H_*/

common/eq_stream_proxy.cpp

@@ -1,11 +1,11 @@
 
-#include "global_define.h"
+#include "debug.h"
 #include "eq_stream_proxy.h"
 #include "eq_stream.h"
 #include "struct_strategy.h"
 
 
-EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes)
+EQStreamProxy::EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes)
 :	m_stream(stream),
 	m_structs(structs),
 	m_opcodes(opcodes)
@@ -15,15 +15,16 @@ EQStreamProxy::EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStra
 }
 
 EQStreamProxy::~EQStreamProxy() {
+	//delete m_stream;	//released by the stream factory.
 }
 
 std::string EQStreamProxy::Describe() const {
 	return(m_structs->Describe());
 }
 
-const ClientVersion EQStreamProxy::GetClientVersion() const
+const EQClientVersion EQStreamProxy::ClientVersion() const
 {
-	return m_structs->GetClientVersion();
+	return m_structs->ClientVersion();
 }
 
 void EQStreamProxy::QueuePacket(const EQApplicationPacket *p, bool ack_req) {
@@ -84,6 +85,12 @@ 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,9 +4,8 @@
 
 #include "types.h"
 #include "eq_stream_intf.h"
-#include "eq_stream.h"
-#include <memory>
 
+class EQStream;
 class StructStrategy;
 class OpcodeManager;
 class EQApplicationPacket;
@@ -14,7 +13,7 @@ class EQApplicationPacket;
 class EQStreamProxy : public EQStreamInterface {
 public:
 	//takes ownership of the stream.
-	EQStreamProxy(std::shared_ptr<EQStream> &stream, const StructStrategy *structs, OpcodeManager **opcodes);
+	EQStreamProxy(EQStream *&stream, const StructStrategy *structs, OpcodeManager **opcodes);
 	virtual ~EQStreamProxy();
 
 	//EQStreamInterface:
@@ -28,7 +27,7 @@ public:
 	virtual void RemoveData();
 	virtual bool CheckState(EQStreamState state);
 	virtual std::string Describe() const;
-	virtual const ClientVersion GetClientVersion() const;
+	virtual const EQClientVersion ClientVersion() const;
 
 	virtual const uint32 GetBytesSent() const;
 	virtual const uint32 GetBytesRecieved() const;
@@ -36,7 +35,7 @@ public:
 	virtual const uint32 GetBytesRecvPerSecond() const;
 
 protected:
-	std::shared_ptr<EQStream> const					m_stream;	//we own this stream object.
+	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 "global_define.h"
+#include "debug.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 "global_define.h"
+#include "debug.h"
 #include "eqdb_res.h"
 #include <mysql.h>
 

common/eqemu_config.cpp

@@ -1,4 +1,4 @@
-/*	 EQEMu: Everquest Server Emulator
+/*	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
@@ -15,65 +15,62 @@
 	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/debug.h"
 #include "eqemu_config.h"
 #include "misc_functions.h"
-
 #include <iostream>
 #include <sstream>
 
 std::string EQEmuConfig::ConfigFile = "eqemu_config.xml";
 EQEmuConfig *EQEmuConfig::_config = nullptr;
 
-void EQEmuConfig::do_world(TiXmlElement *ele)
-{
+void EQEmuConfig::do_world(TiXmlElement *ele) {
 	const char *text;
 	TiXmlElement * sub_ele;;
-	text = ParseTextBlock(ele, "shortname");
-	if (text) {
-		ShortName = text;
-	}
-	text = ParseTextBlock(ele, "longname");
-	if (text) {
-		LongName = text;
-	}
-	text = ParseTextBlock(ele, "address", true);
-	if (text) {
-		WorldAddress = text;
-	}
-	text = ParseTextBlock(ele, "localaddress", true);
-	if (text) {
-		LocalAddress = text;
-	}
-	text = ParseTextBlock(ele, "maxclients", true);
-	if (text) {
-		MaxClients = atoi(text);
-	}
+
+	text= ParseTextBlock(ele,"shortname");
+	if (text)
+		ShortName=text;
+
+	text = ParseTextBlock(ele,"longname");
+	if (text)
+		LongName=text;
+
+	text = ParseTextBlock(ele,"address",true);
+	if (text)
+		WorldAddress=text;
+
+	text = ParseTextBlock(ele,"localaddress",true);
+	if (text)
+		LocalAddress=text;
+
+	text = ParseTextBlock(ele,"maxclients",true);
+	if (text)
+		MaxClients=atoi(text);
+
 	// Get the <key> element
-	text = ParseTextBlock(ele, "key", true);
-	if (text) {
-		SharedKey = text;
-	}
+	text = ParseTextBlock(ele,"key",true);
+	if (text)
+		SharedKey=text;
+
 	// Get the <loginserver> element
 	sub_ele = ele->FirstChildElement("loginserver");
 	if (sub_ele) {
-		text = ParseTextBlock(sub_ele, "host", true);
-		if (text) {
-			LoginHost = text;
-		}
-		text = ParseTextBlock(sub_ele, "port", true);
-		if (text) {
-			LoginPort = atoi(text);
-		}
-		text = ParseTextBlock(sub_ele, "account", true);
-		if (text) {
-			LoginAccount = text;
-		}
-		text = ParseTextBlock(sub_ele, "password", true);
-		if (text) {
-			LoginPassword = text;
-		}
+		text=ParseTextBlock(sub_ele,"host",true);
+		if (text)
+			LoginHost=text;
+
+		text=ParseTextBlock(sub_ele,"port",true);
+		if (text)
+			LoginPort=atoi(text);
+
+		text=ParseTextBlock(sub_ele,"account",true);
+		if (text)
+			LoginAccount=text;
+
+		text=ParseTextBlock(sub_ele,"password",true);
+		if (text)
+			LoginPassword=text;
 	} else {
 		char	str[32];
 		do {
@@ -81,359 +78,329 @@ void EQEmuConfig::do_world(TiXmlElement *ele)
 			sub_ele = ele->FirstChildElement(str);
 			if (sub_ele) {
 				LoginConfig* loginconfig = new LoginConfig;
-				text = ParseTextBlock(sub_ele, "host", true);
-				if (text) {
-					loginconfig->LoginHost = text;
-				}
-				text = ParseTextBlock(sub_ele, "port", true);
-				if (text) {
-					loginconfig->LoginPort = atoi(text);
-				}
-				text = ParseTextBlock(sub_ele, "account", true);
-				if (text) {
-					loginconfig->LoginAccount = text;
-				}
-				text = ParseTextBlock(sub_ele, "password", true);
-				if (text) {
-					loginconfig->LoginPassword = text;
-				}
+				text=ParseTextBlock(sub_ele,"host",true);
+				if (text)
+					loginconfig->LoginHost=text;
+
+				text=ParseTextBlock(sub_ele,"port",true);
+				if (text)
+					loginconfig->LoginPort=atoi(text);
+
+				text=ParseTextBlock(sub_ele,"account",true);
+				if (text)
+					loginconfig->LoginAccount=text;
+
+				text=ParseTextBlock(sub_ele,"password",true);
+				if (text)
+					loginconfig->LoginPassword=text;
 				loginlist.Insert(loginconfig);
 			}
-		} while (sub_ele);
+		} while(sub_ele);
 	}
+
 	// Check for locked
 	sub_ele = ele->FirstChildElement("locked");
-	if (sub_ele != nullptr) {
-		Locked = true;
-	}
+	if (sub_ele != nullptr)
+		Locked=true;
+
 	// Get the <tcp> element
 	sub_ele = ele->FirstChildElement("tcp");
-	if (sub_ele != nullptr) {
+	if(sub_ele != nullptr) {
+
 		text = sub_ele->Attribute("ip");
-		if (text) {
-			WorldIP = text;
-		}
+		if (text)
+			WorldIP=text;
+
 		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldTCPPort = atoi(text);
-		}
+		if (text)
+			WorldTCPPort=atoi(text);
+
 		text = sub_ele->Attribute("telnet");
-		if (text && !strcasecmp(text, "enabled")) {
-			TelnetEnabled = true;
-		}
+		if (text && !strcasecmp(text,"enabled"))
+			TelnetEnabled=true;
+
 	}
+
 	// Get the <http> element
 	sub_ele = ele->FirstChildElement("http");
-	if (sub_ele != nullptr) {
+	if(sub_ele != nullptr) {
+
 //		text = sub_ele->Attribute("ip");
 //		if (text)
 //			WorldIP=text;
+
 		text = sub_ele->Attribute("mimefile");
-		if (text) {
-			WorldHTTPMimeFile = text;
-		}
+		if (text)
+			WorldHTTPMimeFile=text;
+
 		text = sub_ele->Attribute("port");
-		if (text) {
-			WorldHTTPPort = atoi(text);
-		}
+		if (text)
+			WorldHTTPPort=atoi(text);
+
 		text = sub_ele->Attribute("enabled");
-		if (text && !strcasecmp(text, "true")) {
-			WorldHTTPEnabled = true;
-		}
+		if (text && !strcasecmp(text,"true"))
+			WorldHTTPEnabled=true;
+
 	}
 }
 
-void EQEmuConfig::do_chatserver(TiXmlElement *ele)
-{
+void EQEmuConfig::do_chatserver(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		ChatHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		ChatPort = atoi(text);
-	}
+
+	text=ParseTextBlock(ele,"host",true);
+	if (text)
+		ChatHost=text;
+
+	text=ParseTextBlock(ele,"port",true);
+	if (text)
+		ChatPort=atoi(text);
 }
 
-void EQEmuConfig::do_mailserver(TiXmlElement *ele)
-{
+void EQEmuConfig::do_mailserver(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		MailHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		MailPort = atoi(text);
-	}
+
+	text=ParseTextBlock(ele,"host",true);
+	if (text)
+		MailHost=text;
+
+	text=ParseTextBlock(ele,"port",true);
+	if (text)
+		MailPort=atoi(text);
 }
 
-void EQEmuConfig::do_database(TiXmlElement *ele)
-{
+void EQEmuConfig::do_database(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		DatabaseHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		DatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		DatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		DatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		DatabaseDB = text;
-	}
+
+	text=ParseTextBlock(ele,"host",true);
+	if (text)
+		DatabaseHost=text;
+
+	text=ParseTextBlock(ele,"port",true);
+	if (text)
+		DatabasePort=atoi(text);
+
+	text=ParseTextBlock(ele,"username",true);
+	if (text)
+		DatabaseUsername=text;
+
+	text=ParseTextBlock(ele,"password",true);
+	if (text)
+		DatabasePassword=text;
+
+	text=ParseTextBlock(ele,"db",true);
+	if (text)
+		DatabaseDB=text;
 }
 
 
-void EQEmuConfig::do_qsdatabase(TiXmlElement *ele)
-{
+void EQEmuConfig::do_qsdatabase(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "host", true);
-	if (text) {
-		QSDatabaseHost = text;
-	}
-	text = ParseTextBlock(ele, "port", true);
-	if (text) {
-		QSDatabasePort = atoi(text);
-	}
-	text = ParseTextBlock(ele, "username", true);
-	if (text) {
-		QSDatabaseUsername = text;
-	}
-	text = ParseTextBlock(ele, "password", true);
-	if (text) {
-		QSDatabasePassword = text;
-	}
-	text = ParseTextBlock(ele, "db", true);
-	if (text) {
-		QSDatabaseDB = text;
-	}
+
+	text=ParseTextBlock(ele,"host",true);
+	if (text)
+		QSDatabaseHost=text;
+
+	text=ParseTextBlock(ele,"port",true);
+	if (text)
+		QSDatabasePort=atoi(text);
+
+	text=ParseTextBlock(ele,"username",true);
+	if (text)
+		QSDatabaseUsername=text;
+
+	text=ParseTextBlock(ele,"password",true);
+	if (text)
+		QSDatabasePassword=text;
+
+	text=ParseTextBlock(ele,"db",true);
+	if (text)
+		QSDatabaseDB=text;
 }
 
-void EQEmuConfig::do_zones(TiXmlElement *ele)
-{
+void EQEmuConfig::do_zones(TiXmlElement *ele) {
 	const char *text;
 	TiXmlElement *sub_ele;
 //	TiXmlNode *node,*sub_node;
-	text = ParseTextBlock(ele, "defaultstatus", true);
-	if (text) {
-		DefaultStatus = atoi(text);
-	}
+
+	text=ParseTextBlock(ele,"defaultstatus",true);
+	if (text)
+		DefaultStatus=atoi(text);
+
 	// Get the <ports> element
 	sub_ele = ele->FirstChildElement("ports");
-	if (sub_ele != nullptr) {
+	if(sub_ele != nullptr) {
+
 		text = sub_ele->Attribute("low");
-		if (text) {
-			ZonePortLow = atoi(text);
-		};
+		if (text)
+			ZonePortLow=atoi(text);;
+
 		text = sub_ele->Attribute("high");
-		if (text) {
-			ZonePortHigh = atoi(text);
-		}
+		if (text)
+			ZonePortHigh=atoi(text);
 	}
 }
 
-void EQEmuConfig::do_files(TiXmlElement *ele)
-{
+void EQEmuConfig::do_files(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "spells", true);
-	if (text) {
-		SpellsFile = text;
-	}
-	text = ParseTextBlock(ele, "opcodes", true);
-	if (text) {
-		OpCodesFile = text;
-	}
+
+	text=ParseTextBlock(ele,"spells",true);
+	if (text)
+		SpellsFile=text;
+
+	text=ParseTextBlock(ele,"opcodes",true);
+	if (text)
+		OpCodesFile=text;
+
+	text=ParseTextBlock(ele,"logsettings",true);
+	if (text)
+		LogSettingsFile=text;
+
+	text=ParseTextBlock(ele,"eqtime",true);
+	if (text)
+		EQTimeFile=text;
 }
 
-void EQEmuConfig::do_directories(TiXmlElement *ele)
-{
+void EQEmuConfig::do_directories(TiXmlElement *ele) {
 	const char *text;
-	text = ParseTextBlock(ele, "maps", true);
-	if (text) {
-		MapDir = text;
-	}
-	text = ParseTextBlock(ele, "quests", true);
-	if (text) {
-		QuestDir = text;
-	}
-	text = ParseTextBlock(ele, "plugins", true);
-	if (text) {
-		PluginDir = text;
-	}
+
+	text=ParseTextBlock(ele,"maps",true);
+	if (text)
+		MapDir=text;
+
+	text=ParseTextBlock(ele,"quests",true);
+	if (text)
+		QuestDir=text;
+
+	text=ParseTextBlock(ele,"plugins",true);
+	if (text)
+		PluginDir=text;
+
 }
 
-void EQEmuConfig::do_launcher(TiXmlElement *ele)
-{
+void EQEmuConfig::do_launcher(TiXmlElement *ele) {
 	const char *text;
 	TiXmlElement *sub_ele;
-	text = ParseTextBlock(ele, "logprefix", true);
-	if (text) {
+
+	text=ParseTextBlock(ele,"logprefix",true);
+	if (text)
 		LogPrefix = text;
-	}
-	text = ParseTextBlock(ele, "logsuffix", true);
-	if (text) {
+
+	text=ParseTextBlock(ele,"logsuffix",true);
+	if (text)
 		LogSuffix = text;
-	}
+
 	// Get the <exe> element
-	text = ParseTextBlock(ele, "exe", true);
-	if (text) {
+	text = ParseTextBlock(ele,"exe",true);
+	if (text)
 		ZoneExe = text;
-	}
+
 	// Get the <timers> element
 	sub_ele = ele->FirstChildElement("timers");
-	if (sub_ele != nullptr) {
+	if(sub_ele != nullptr) {
 		text = sub_ele->Attribute("restart");
-		if (text) {
+		if (text)
 			RestartWait = atoi(text);
-		}
+
 		text = sub_ele->Attribute("reterminate");
-		if (text) {
+		if (text)
 			TerminateWait = atoi(text);
-		}
+
 		text = sub_ele->Attribute("initial");
-		if (text) {
+		if (text)
 			InitialBootWait = atoi(text);
-		}
+
 		text = sub_ele->Attribute("interval");
-		if (text) {
+		if (text)
 			ZoneBootInterval = atoi(text);
-		}
 	}
 }
 
-std::string EQEmuConfig::GetByName(const std::string &var_name) const
-{
-	if (var_name == "ShortName") {
-		return (ShortName);
-	}
-	if (var_name == "LongName") {
-		return (LongName);
-	}
-	if (var_name == "WorldAddress") {
-		return (WorldAddress);
-	}
-	if (var_name == "LoginHost") {
-		return (LoginHost);
-	}
-	if (var_name == "LoginAccount") {
-		return (LoginAccount);
-	}
-	if (var_name == "LoginPassword") {
-		return (LoginPassword);
-	}
-	if (var_name == "LoginPort") {
-		return (itoa(LoginPort));
-	}
-	if (var_name == "Locked") {
-		return (Locked ? "true" : "false");
-	}
-	if (var_name == "WorldTCPPort") {
-		return (itoa(WorldTCPPort));
-	}
-	if (var_name == "WorldIP") {
-		return (WorldIP);
-	}
-	if (var_name == "TelnetEnabled") {
-		return (TelnetEnabled ? "true" : "false");
-	}
-	if (var_name == "WorldHTTPPort") {
-		return (itoa(WorldHTTPPort));
-	}
-	if (var_name == "WorldHTTPMimeFile") {
-		return (WorldHTTPMimeFile);
-	}
-	if (var_name == "WorldHTTPEnabled") {
-		return (WorldHTTPEnabled ? "true" : "false");
-	}
-	if (var_name == "ChatHost") {
-		return (ChatHost);
-	}
-	if (var_name == "ChatPort") {
-		return (itoa(ChatPort));
-	}
-	if (var_name == "MailHost") {
-		return (MailHost);
-	}
-	if (var_name == "MailPort") {
-		return (itoa(MailPort));
-	}
-	if (var_name == "DatabaseHost") {
-		return (DatabaseHost);
-	}
-	if (var_name == "DatabaseUsername") {
-		return (DatabaseUsername);
-	}
-	if (var_name == "DatabasePassword") {
-		return (DatabasePassword);
-	}
-	if (var_name == "DatabaseDB") {
-		return (DatabaseDB);
-	}
-	if (var_name == "DatabasePort") {
-		return (itoa(DatabasePort));
-	}
-	if (var_name == "QSDatabaseHost") {
-		return (QSDatabaseHost);
-	}
-	if (var_name == "QSDatabaseUsername") {
-		return (QSDatabaseUsername);
-	}
-	if (var_name == "QSDatabasePassword") {
-		return (QSDatabasePassword);
-	}
-	if (var_name == "QSDatabaseDB") {
-		return (QSDatabaseDB);
-	}
-	if (var_name == "QSDatabasePort") {
-		return (itoa(QSDatabasePort));
-	}
-	if (var_name == "SpellsFile") {
-		return (SpellsFile);
-	}
-	if (var_name == "OpCodesFile") {
-		return (OpCodesFile);
-	}
-	if (var_name == "MapDir") {
-		return (MapDir);
-	}
-	if (var_name == "QuestDir") {
-		return (QuestDir);
-	}
-	if (var_name == "PluginDir") {
-		return (PluginDir);
-	}
-	if (var_name == "LogPrefix") {
-		return (LogPrefix);
-	}
-	if (var_name == "LogSuffix") {
-		return (LogSuffix);
-	}
-	if (var_name == "ZoneExe") {
-		return (ZoneExe);
-	}
-	if (var_name == "ZonePortLow") {
-		return (itoa(ZonePortLow));
-	}
-	if (var_name == "ZonePortHigh") {
-		return (itoa(ZonePortHigh));
-	}
-	if (var_name == "DefaultStatus") {
-		return (itoa(DefaultStatus));
-	}
+std::string EQEmuConfig::GetByName(const std::string &var_name) const {
+	if(var_name == "ShortName")
+		return(ShortName);
+	if(var_name == "LongName")
+		return(LongName);
+	if(var_name == "WorldAddress")
+		return(WorldAddress);
+	if(var_name == "LoginHost")
+		return(LoginHost);
+	if(var_name == "LoginAccount")
+		return(LoginAccount);
+	if(var_name == "LoginPassword")
+		return(LoginPassword);
+	if(var_name == "LoginPort")
+		return(itoa(LoginPort));
+	if(var_name == "Locked")
+		return(Locked?"true":"false");
+	if(var_name == "WorldTCPPort")
+		return(itoa(WorldTCPPort));
+	if(var_name == "WorldIP")
+		return(WorldIP);
+	if(var_name == "TelnetEnabled")
+		return(TelnetEnabled?"true":"false");
+	if(var_name == "WorldHTTPPort")
+		return(itoa(WorldHTTPPort));
+	if(var_name == "WorldHTTPMimeFile")
+		return(WorldHTTPMimeFile);
+	if(var_name == "WorldHTTPEnabled")
+		return(WorldHTTPEnabled?"true":"false");
+	if(var_name == "ChatHost")
+		return(ChatHost);
+	if(var_name == "ChatPort")
+		return(itoa(ChatPort));
+	if(var_name == "MailHost")
+		return(MailHost);
+	if(var_name == "MailPort")
+		return(itoa(MailPort));
+	if(var_name == "DatabaseHost")
+		return(DatabaseHost);
+	if(var_name == "DatabaseUsername")
+		return(DatabaseUsername);
+	if(var_name == "DatabasePassword")
+		return(DatabasePassword);
+	if(var_name == "DatabaseDB")
+		return(DatabaseDB);
+	if(var_name == "DatabasePort")
+		return(itoa(DatabasePort));
+	if(var_name == "QSDatabaseHost")
+		return(QSDatabaseHost);
+	if(var_name == "QSDatabaseUsername")
+		return(QSDatabaseUsername);
+	if(var_name == "QSDatabasePassword")
+		return(QSDatabasePassword);
+	if(var_name == "QSDatabaseDB")
+		return(QSDatabaseDB);
+	if(var_name == "QSDatabasePort")
+		return(itoa(QSDatabasePort));
+	if(var_name == "SpellsFile")
+		return(SpellsFile);
+	if(var_name == "OpCodesFile")
+		return(OpCodesFile);
+	if(var_name == "EQTimeFile")
+		return(EQTimeFile);
+	if(var_name == "LogSettingsFile")
+		return(LogSettingsFile);
+	if(var_name == "MapDir")
+		return(MapDir);
+	if(var_name == "QuestDir")
+		return(QuestDir);
+	if(var_name == "PluginDir")
+		return(PluginDir);
+	if(var_name == "LogPrefix")
+		return(LogPrefix);
+	if(var_name == "LogSuffix")
+		return(LogSuffix);
+	if(var_name == "ZoneExe")
+		return(ZoneExe);
+	if(var_name == "ZonePortLow")
+		return(itoa(ZonePortLow));
+	if(var_name == "ZonePortHigh")
+		return(itoa(ZonePortHigh));
+	if(var_name == "DefaultStatus")
+		return(itoa(DefaultStatus));
 //	if(var_name == "DynamicCount")
 //		return(itoa(DynamicCount));
-	return ("");
+	return("");
 }
 
 void EQEmuConfig::Dump() const
@@ -468,6 +435,8 @@ void EQEmuConfig::Dump() const
 	std::cout << "QSDatabasePort = " << QSDatabasePort << std::endl;
 	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

@@ -1,4 +1,4 @@
-/*	 EQEMu: Everquest Server Emulator
+/*	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
@@ -28,188 +28,200 @@ struct LoginConfig {
 	uint16 LoginPort;
 };
 
-class EQEmuConfig : public XMLParser
-{
-	public:
-		virtual std::string GetByName(const std::string &var_name) const;
+class EQEmuConfig : public XMLParser {
+public:
+	virtual std::string GetByName(const std::string &var_name) const;
 
-		// From <world/>
-		std::string ShortName;
-		std::string LongName;
-		std::string WorldAddress;
-		std::string LocalAddress;
-		std::string LoginHost;
-		std::string LoginAccount;
-		std::string LoginPassword;
-		uint16 LoginPort;
-		uint32 LoginCount;
-		LinkedList<LoginConfig*> loginlist;
-		bool Locked;
-		uint16 WorldTCPPort;
-		std::string WorldIP;
-		bool TelnetEnabled;
-		int32 MaxClients;
-		bool WorldHTTPEnabled;
-		uint16 WorldHTTPPort;
-		std::string WorldHTTPMimeFile;
-		std::string SharedKey;
+	// From <world/>
+	std::string ShortName;
+	std::string LongName;
+	std::string WorldAddress;
+	std::string LocalAddress;
+	std::string LoginHost;
+	std::string LoginAccount;
+	std::string LoginPassword;
+	uint16 LoginPort;
+	uint32 LoginCount;
+	LinkedList<LoginConfig*> loginlist;
+	bool Locked;
+	uint16 WorldTCPPort;
+	std::string WorldIP;
+	bool TelnetEnabled;
+	int32 MaxClients;
+	bool WorldHTTPEnabled;
+	uint16 WorldHTTPPort;
+	std::string WorldHTTPMimeFile;
+	std::string SharedKey;
 
-		// From <chatserver/>
-		std::string ChatHost;
-		uint16 ChatPort;
+	// From <chatserver/>
+	std::string ChatHost;
+	uint16 ChatPort;
 
-		// From <mailserver/>
-		std::string MailHost;
-		uint16 MailPort;
+	// From <mailserver/>
+	std::string MailHost;
+	uint16 MailPort;
 
-		// From <database/>
-		std::string DatabaseHost;
-		std::string DatabaseUsername;
-		std::string DatabasePassword;
-		std::string DatabaseDB;
-		uint16 DatabasePort;
+	// From <database/>
+	std::string DatabaseHost;
+	std::string DatabaseUsername;
+	std::string DatabasePassword;
+	std::string DatabaseDB;
+	uint16 DatabasePort;
 
-		// From <qsdatabase> // QueryServ
-		std::string QSDatabaseHost;
-		std::string QSDatabaseUsername;
-		std::string QSDatabasePassword;
-		std::string QSDatabaseDB;
-		uint16 QSDatabasePort;
+	// From <qsdatabase> // QueryServ
+	std::string QSDatabaseHost;
+	std::string QSDatabaseUsername;
+	std::string QSDatabasePassword;
+	std::string QSDatabaseDB;
+	uint16 QSDatabasePort;
 
-		// From <files/>
-		std::string SpellsFile;
-		std::string OpCodesFile;
+	// From <files/>
+	std::string SpellsFile;
+	std::string OpCodesFile;
+	std::string EQTimeFile;
+	std::string LogSettingsFile;
 
-		// From <directories/>
-		std::string MapDir;
-		std::string QuestDir;
-		std::string PluginDir;
+	// From <directories/>
+	std::string MapDir;
+	std::string QuestDir;
+	std::string PluginDir;
 
-		// From <launcher/>
-		std::string LogPrefix;
-		std::string LogSuffix;
-		std::string ZoneExe;
-		uint32 RestartWait;
-		uint32 TerminateWait;
-		uint32 InitialBootWait;
-		uint32 ZoneBootInterval;
+	// From <launcher/>
+	std::string LogPrefix;
+	std::string LogSuffix;
+	std::string ZoneExe;
+	uint32 RestartWait;
+	uint32 TerminateWait;
+	uint32 InitialBootWait;
+	uint32 ZoneBootInterval;
 
-		// From <zones/>
-		uint16 ZonePortLow;
-		uint16 ZonePortHigh;
-		uint8 DefaultStatus;
+	// From <zones/>
+	uint16 ZonePortLow;
+	uint16 ZonePortHigh;
+	uint8 DefaultStatus;
 
 //	uint16 DynamicCount;
 
 //	map<string,uint16> StaticZones;
 
-	protected:
+protected:
 
-		static EQEmuConfig *_config;
+	static EQEmuConfig *_config;
 
-		static std::string ConfigFile;
+	static std::string ConfigFile;
 
 #define ELEMENT(name) \
 	void do_##name(TiXmlElement *ele);
-#include "eqemu_config_elements.h"
+	#include "eqemu_config_elements.h"
 
 
-		EQEmuConfig()
-		{
-			// import the needed handler prototypes
+	EQEmuConfig() {
+		// import the needed handler prototypes
 #define ELEMENT(name) \
-	Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
-#include "eqemu_config_elements.h"
-			// Set sane defaults
-			// Login server
-			LoginHost = "eqemulator.net";
-			LoginPort = 5998;
-			// World
-			Locked = false;
-			WorldTCPPort = 9000;
-			TelnetEnabled = false;
-			WorldHTTPEnabled = false;
-			WorldHTTPPort = 9080;
-			WorldHTTPMimeFile = "mime.types";
-			SharedKey = "";	//blank disables authentication
-			// Mail
-			ChatHost = "eqchat.eqemulator.net";
-			ChatPort = 7778;
-			// Mail
-			MailHost = "eqmail.eqemulator.net";
-			MailPort = 7779;
-			// Mysql
-			DatabaseHost = "localhost";
-			DatabasePort = 3306;
-			DatabaseUsername = "eq";
-			DatabasePassword = "eq";
-			DatabaseDB = "eq";
-			// QueryServ Database
-			QSDatabaseHost = "localhost";
-			QSDatabasePort = 3306;
-			QSDatabaseUsername = "eq";
-			QSDatabasePassword = "eq";
-			QSDatabaseDB = "eq";
-			// Files
-			SpellsFile = "spells_us.txt";
-			OpCodesFile = "opcodes.conf";
-			// Dirs
-			MapDir = "Maps";
-			QuestDir = "quests";
-			PluginDir = "plugins";
-			// Launcher
-			LogPrefix = "logs/zone-";
-			LogSuffix = ".log";
-			RestartWait = 10000;		//milliseconds
-			TerminateWait = 10000;		//milliseconds
-			InitialBootWait = 20000;	//milliseconds
-			ZoneBootInterval = 2000;	//milliseconds
-			#ifdef WIN32
-			ZoneExe = "zone.exe";
-			#else
-			ZoneExe = "./zone";
-			#endif
-			// Zones
-			ZonePortLow = 7000;
-			ZonePortHigh = 7999;
-			DefaultStatus = 0;
-			// For where zones need to connect to.
-			WorldIP = "127.0.0.1";
-			// Dynamics to start
-			//DynamicCount=5;
-			MaxClients = -1;
-			LoginCount = 0;
-		}
-		virtual ~EQEmuConfig() {}
+		Handlers[#name]=(ElementHandler)&EQEmuConfig::do_##name;
+	#include "eqemu_config_elements.h"
 
-	public:
+		// Set sane defaults
 
-		// Produce a const singleton
-		static const EQEmuConfig *get()
-		{
-			if (_config == nullptr) {
-				LoadConfig();
-			}
-			return (_config);
-		}
+		// Login server
+		LoginHost="eqemulator.net";
+		LoginPort=5998;
 
-		// Allow the use to set the conf file to be used.
-		static void SetConfigFile(std::string file)
-		{
-			EQEmuConfig::ConfigFile = file;
-		}
+		// World
+		Locked=false;
+		WorldTCPPort=9000;
+		TelnetEnabled=false;
+		WorldHTTPEnabled=false;
+		WorldHTTPPort=9080;
+		WorldHTTPMimeFile="mime.types";
+		SharedKey = "";	//blank disables authentication
 
-		// Load the config
-		static bool LoadConfig()
-		{
-			if (_config != nullptr) {
-				delete _config;
-			}
-			_config = new EQEmuConfig;
-			return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(), "server");
-		}
+		// Mail
+		ChatHost="eqchat.eqemulator.net";
+		ChatPort=7778;
 
-		void Dump() const;
+		// Mail
+		MailHost="eqmail.eqemulator.net";
+		MailPort=7779;
+
+		// Mysql
+		DatabaseHost="localhost";
+		DatabasePort=3306;
+		DatabaseUsername="eq";
+		DatabasePassword="eq";
+		DatabaseDB="eq";
+
+		// QueryServ Database
+		QSDatabaseHost="localhost";
+		QSDatabasePort=3306;
+		QSDatabaseUsername="eq";
+		QSDatabasePassword="eq";
+		QSDatabaseDB="eq";
+
+		// Files
+		SpellsFile="spells_us.txt";
+		OpCodesFile="opcodes.conf";
+		EQTimeFile="eqtime.cfg";
+		LogSettingsFile="log.ini";
+
+		// Dirs
+		MapDir="Maps";
+		QuestDir="quests";
+		PluginDir="plugins";
+
+		// Launcher
+		LogPrefix = "logs/zone-";
+		LogSuffix = ".log";
+		RestartWait = 10000;		//milliseconds
+		TerminateWait = 10000;		//milliseconds
+		InitialBootWait = 20000;	//milliseconds
+		ZoneBootInterval = 2000;	//milliseconds
+#ifdef WIN32
+		ZoneExe = "zone.exe";
+#else
+		ZoneExe = "./zone";
+#endif
+
+		// Zones
+		ZonePortLow=7000;
+		ZonePortHigh=7999;
+		DefaultStatus=0;
+
+		// For where zones need to connect to.
+		WorldIP="127.0.0.1";
+
+		// Dynamics to start
+		//DynamicCount=5;
+
+		MaxClients=-1;
+
+		LoginCount=0;
+
+	}
+	virtual ~EQEmuConfig() {}
+
+public:
+
+	// Produce a const singleton
+	static const EQEmuConfig *get() {
+		if (_config == nullptr)
+			LoadConfig();
+		return(_config);
+	}
+
+	// Allow the use to set the conf file to be used.
+	static void SetConfigFile(std::string file) { EQEmuConfig::ConfigFile = file; }
+
+	// Load the config
+	static bool LoadConfig() {
+		if (_config != nullptr)
+			delete _config;
+		_config=new EQEmuConfig;
+
+		return _config->ParseFile(EQEmuConfig::ConfigFile.c_str(),"server");
+	}
+
+	void Dump() const;
 };
 
 #endif

common/eqemu_error.cpp

@@ -0,0 +1,135 @@
+/*	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,5 +1,5 @@
 /*	EQEMu: Everquest Server Emulator
-	Copyright (C) 2001-2015 EQEMu Development Team (http://eqemulator.net)
+	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
@@ -15,42 +15,22 @@
 	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
 
-#ifndef EQEMU_ZONE_AA_RANK_H
-#define EQEMU_ZONE_AA_RANK_H
+#include "../common/types.h"
 
-namespace AA
-{
+enum eEQEMuError { EQEMuError_NoError,
+	EQEMuError_Mysql_1405,
+	EQEMuError_Mysql_2003,
+	EQEMuError_Mysql_2005,
+	EQEMuError_Mysql_2007,
+	EQEMuError_MaxErrorID };
 
-class Ability;
-class Rank
-{
-public:
-	Rank() { }
-	~Rank() { }
-
-	int id;
-	int upper_hotkey_sid;
-	int lower_hotkey_sid;
-	int title_sid;
-	int desc_sid;
-	int cost;
-	int level_req;
-	int spell;
-	int spell_type;
-	int recast_time;
-	int prev_id;
-	Rank *prev;
-	int next_id;
-	Rank *next;
-	int current_value;
-	int expansion;
-	int total_cost;
-	Ability *base_ability;
-	std::vector<RankEffect> effects;
-	std::map<int, int> prereqs;
-};
-
-}
+void AddEQEMuError(eEQEMuError iError, bool iExitNow = false);
+void AddEQEMuError(char* iError, bool iExitNow = false);
+uint32 CheckEQEMuError();
+void CheckEQEMuErrorAndPause();
 
 #endif
+

common/eqemu_logsys.cpp

@@ -1,343 +0,0 @@
-/*	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;
-	log_settings[Logs::Login_Server].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::ExePlatformLaunch)
-		platform_file_name = "launcher";
-}
-
-std::string EQEmuLogSys::FormatOutMessageString(uint16 log_category, const std::string &in_message)
-{
-	std::string ret;
-	ret.push_back('[');
-	ret.append(Logs::LogCategoryName[log_category]);
-	ret.push_back(']');
-	ret.push_back(' ');
-	ret.append(in_message);
-	return ret;
-}
-
-void EQEmuLogSys::ProcessGMSay(uint16 debug_level, uint16 log_category, const std::string &message)
-{
-	/* Enabling Netcode based GMSay output creates a feedback loop that ultimately ends in a crash */
-	if (log_category == Logs::LogCategory::Netcode)
-		return;
-
-	/* Check to see if the process that actually ran this is zone */
-	if (EQEmuLogSys::log_platform == EQEmuExePlatform::ExePlatformZone)
-		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();
-	}
-
-	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)
-{
-
-	#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, ...)
-{
-	bool log_to_console = true;
-	if (log_settings[log_category].log_to_console < debug_level) {
-		log_to_console = false;
-	}
-
-	bool log_to_file = true;
-	if (log_settings[log_category].log_to_file < debug_level) {
-		log_to_file = false;
-	}
-
-	bool log_to_gmsay = true;
-	if (log_settings[log_category].log_to_gmsay < debug_level) {
-		log_to_gmsay = false;
-	}
-
-	const bool nothing_to_log = !log_to_console && !log_to_file && !log_to_gmsay;
-	if (nothing_to_log)
-		return;
-
-	va_list args;
-	va_start(args, message);
-	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

@@ -1,206 +0,0 @@
-/*	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,
-		Login_Server,
-		MaxCategoryID	/* Don't Remove this*/
-	};
-
-	/* If you add to this, make sure you update LogCategory */
-	static const char* LogCategoryName[LogCategory::MaxCategoryID] = {
-		"",
-		"AA",
-		"AI",
-		"Aggro",
-		"Attack",
-		"Packet :: Client -> Server",
-		"Combat",
-		"Commands",
-		"Crash",
-		"Debug",
-		"Doors",
-		"Error",
-		"Guilds",
-		"Inventory",
-		"Launcher",
-		"Netcode",
-		"Normal",
-		"Object",
-		"Pathing",
-		"QS Server",
-		"Quests",
-		"Rules",
-		"Skills",
-		"Spawns",
-		"Spells",
-		"Status",
-		"TCP Connection",
-		"Tasks",
-		"Tradeskills",
-		"Trading",
-		"Tribute",
-		"UCS Server",
-		"WebInterface Server",
-		"World Server",
-		"Zone Server",
-		"MySQL Error",
-		"MySQL Query",
-		"Mercenaries",
-		"Quest Debug",
-		"Packet :: Server -> Client",
-		"Packet :: Client -> Server Unhandled",
-		"Packet :: Server -> Client (Dump)",
-		"Packet :: Client -> Server (Dump)",
-		"Login Server"
-	};
-}
-
-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,8 +17,7 @@
 */
 
 #include <fstream>
-#include "../common/global_define.h"
-#include "../common/eqemu_logsys.h"
+#include "../common/debug.h"
 #include "../common/eqtime.h"
 #include "../common/eq_packet_structs.h"
 #include <memory.h>
@@ -43,19 +42,19 @@ EQTime::EQTime(TimeOfDay_Struct start_eq, time_t start_real)
 
 EQTime::EQTime()
 {
-	timezone = 0;
+	timezone=0;
 	memset(&eqTime, 0, sizeof(eqTime));
 	//Defaults for time
 	TimeOfDay_Struct start;
-	start.day = 1;
-	start.hour = 9;
-	start.minute = 0;
-	start.month = 1;
-	start.year = 3100;
+	start.day=1;
+	start.hour=9;
+	start.minute=0;
+	start.month=1;
+	start.year=3100;
 	//Set default time zone
-	timezone = 0;
+	timezone=0;
 	//Start EQTimer
-	SetCurrentEQTimeOfDay(start, time(0));
+	setEQTimeOfDay(start, time(0));
 }
 
 EQTime::~EQTime()
@@ -67,10 +66,10 @@ EQTime::~EQTime()
 //Input: Current Time (as a time_t), a pointer to the TimeOfDay_Struct that will be written to.
 //Output: 0=Error, 1=Sucess
 
-int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *eqTimeOfDay)
+int EQTime::getEQTimeOfDay( time_t timeConvert, struct TimeOfDay_Struct *eqTimeOfDay )
 {
 	/* check to see if we have a reference time to go by. */
-	if (eqTime.start_realtime == 0)
+	if( eqTime.start_realtime == 0 )
 		return 0;
 
 	unsigned long diff = timeConvert - eqTime.start_realtime;
@@ -83,7 +82,7 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 	int32 ntz = timezone;
 
 	/* The minutes range from 0 - 59 */
-	diff += eqTime.start_eqtime.minute + (ntz % 60);
+	diff += eqTime.start_eqtime.minute + (ntz%60);
 	eqTimeOfDay->minute = diff % 60;
 	diff /= 60;
 	ntz /= 60;
@@ -97,24 +96,24 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 	//
 	// Modify it so that it works from
 	// 0-23 for our calculations
-	diff += (eqTime.start_eqtime.hour - 1) + (ntz % 24);
-	eqTimeOfDay->hour = (diff % 24) + 1;
+	diff += ( eqTime.start_eqtime.hour - 1) + (ntz%24);
+	eqTimeOfDay->hour = (diff%24) + 1;
 	diff /= 24;
 	ntz /= 24;
 
 	// The days range from 1-28
 	// Modify it so that it works from
 	// 0-27 for our calculations
-	diff += (eqTime.start_eqtime.day - 1) + (ntz % 28);
-	eqTimeOfDay->day = (diff % 28) + 1;
+	diff += ( eqTime.start_eqtime.day - 1 ) + (ntz%28);
+	eqTimeOfDay->day = (diff%28) + 1;
 	diff /= 28;
 	ntz /= 28;
 
 	// The months range from 1-12
 	// Modify it so that it works from
 	// 0-11 for our calculations
-	diff += (eqTime.start_eqtime.month - 1) + (ntz % 12);
-	eqTimeOfDay->month = (diff % 12) + 1;
+	diff += ( eqTime.start_eqtime.month - 1 ) + (ntz%12);
+	eqTimeOfDay->month = (diff%12) + 1;
 	diff /= 12;
 	ntz /= 12;
 
@@ -124,34 +123,102 @@ int EQTime::GetCurrentEQTimeOfDay(time_t timeConvert, struct TimeOfDay_Struct *e
 }
 
 //setEQTimeOfDay
-int EQTime::SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real)
+int EQTime::setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real)
 {
-	if (start_real == 0)
+	if(start_real==0)
 		return 0;
-	eqTime.start_eqtime = start_eq;
-	eqTime.start_realtime = start_real;
+	eqTime.start_eqtime=start_eq;
+	eqTime.start_realtime=start_real;
 	return 1;
 }
 
+//saveFile and loadFile need to use long for the save datatype...
+//For some reason, ifstream/ofstream have problems with EQEmu datatypes in files.
+bool EQTime::saveFile(const char *filename)
+{
+	std::ofstream of;
+	of.open(filename);
+	if(!of)
+	{
+		LogFile->write(EQEMuLog::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;
+	of << (long)eqTime.start_eqtime.minute << std::endl;
+	of << (long)eqTime.start_eqtime.month << std::endl;
+	of << eqTime.start_eqtime.year << std::endl;
+	of << eqTime.start_realtime << std::endl;
+	of.close();
+	return true;
+}
+
+bool EQTime::loadFile(const char *filename)
+{
+	int version=0;
+	long in_data=0;
+	std::ifstream in;
+	in.open(filename);
+	if(!in)
+	{
+		LogFile->write(EQEMuLog::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);
+		return false;
+	}
+	//in >> eqTime.start_eqtime.day;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.day = in_data;
+	//in >> eqTime.start_eqtime.hour;
+	in >> in_data;
+	eqTime.start_eqtime.hour = in_data;
+	in.ignore(80, '\n');
+	//in >> eqTime.start_eqtime.minute;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.minute = in_data;
+	//in >> eqTime.start_eqtime.month;
+	in >> in_data;
+	in.ignore(80, '\n');
+	eqTime.start_eqtime.month = in_data;
+	in >> eqTime.start_eqtime.year;
+	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;
+}
+
+
 bool EQTime::IsTimeBefore(TimeOfDay_Struct *base, TimeOfDay_Struct *test) {
-	if (base->year > test->year)
+	if(base->year > test->year)
 		return(true);
-	if (base->year < test->year)
+	if(base->year < test->year)
 		return(false);
 	//same years
-	if (base->month > test->month)
+	if(base->month > test->month)
 		return(true);
-	if (base->month < test->month)
+	if(base->month < test->month)
 		return(false);
 	//same month
-	if (base->day > test->day)
+	if(base->day > test->day)
 		return(true);
-	if (base->day < test->day)
+	if(base->day < test->day)
 		return(false);
 	//same day
-	if (base->hour > test->hour)
+	if(base->hour > test->hour)
 		return(true);
-	if (base->hour < test->hour)
+	if(base->hour < test->hour)
 		return(false);
 	//same hour...
 	return(base->minute > test->minute);
@@ -164,7 +231,7 @@ void EQTime::AddMinutes(uint32 minutes, TimeOfDay_Struct *to) {
 	//minutes start at 0, everything else starts at 1
 	cur = to->minute;
 	cur += minutes;
-	if (cur < 60) {
+	if(cur < 60) {
 		to->minute = cur;
 		return;
 	}
@@ -172,29 +239,29 @@ void EQTime::AddMinutes(uint32 minutes, TimeOfDay_Struct *to) {
 	//carry hours
 	cur /= 60;
 	cur += to->hour;
-	if (cur <= 24) {
+	if(cur <= 24) {
 		to->hour = cur;
 		return;
 	}
-	to->hour = ((cur - 1) % 24) + 1;
+	to->hour = ((cur-1) % 24) + 1;
 	//carry days
-	cur = (cur - 1) / 24;
+	cur = (cur-1) / 24;
 	cur += to->day;
-	if (cur <= 28) {
+	if(cur <= 28) {
 		to->day = cur;
 		return;
 	}
-	to->day = ((cur - 1) % 28) + 1;
+	to->day = ((cur-1) % 28) + 1;
 	//carry months
-	cur = (cur - 1) / 28;
+	cur = (cur-1) / 28;
 	cur += to->month;
-	if (cur <= 12) {
+	if(cur <= 12) {
 		to->month = cur;
 		return;
 	}
-	to->month = ((cur - 1) % 12) + 1;
+	to->month = ((cur-1) % 12) + 1;
 	//carry years
-	to->year += (cur - 1) / 12;
+	to->year += (cur-1) / 12;
 }
 
 void EQTime::ToString(TimeOfDay_Struct *t, std::string &str) {
@@ -203,4 +270,5 @@ void EQTime::ToString(TimeOfDay_Struct *t, std::string &str) {
 		t->month, t->day, t->year, t->hour, t->minute);
 	buf[127] = '\0';
 	str = buf;
-}
+}
+

common/eqtime.h

@@ -21,8 +21,8 @@ public:
 	~EQTime();
 
 	//Get functions
-	int GetCurrentEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(GetCurrentEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
-	int GetCurrentEQTimeOfDay( time_t timeConvert, TimeOfDay_Struct *eqTimeOfDay );
+	int getEQTimeOfDay( TimeOfDay_Struct *eqTimeOfDay ) { return(getEQTimeOfDay(time(nullptr), eqTimeOfDay)); }
+	int getEQTimeOfDay( time_t timeConvert, TimeOfDay_Struct *eqTimeOfDay );
 	TimeOfDay_Struct getStartEQTime() { return eqTime.start_eqtime; }
 	time_t getStartRealTime() { return eqTime.start_realtime; }
 	uint32 getEQTimeZone() { return timezone; }
@@ -30,7 +30,7 @@ public:
 	uint32 getEQTimeZoneMin() { return timezone%60; }
 
 	//Set functions
-	int SetCurrentEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
+	int setEQTimeOfDay(TimeOfDay_Struct start_eq, time_t start_real);
 	void setEQTimeZone(int32 in_timezone) { timezone=in_timezone; }
 
 	//Time math/logic functions
@@ -39,6 +39,12 @@ public:
 
 	static void ToString(TimeOfDay_Struct *t, std::string &str);
 
+	//Database functions
+	//bool loadDB(Database q);
+	//bool setDB(Database q);
+	bool loadFile(const char *filename);
+	bool saveFile(const char *filename);
+
 private:
 	//This is our reference clock.
 	eqTimeOfDay eqTime;

common/extprofile.cpp

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

common/extprofile.h

@@ -54,8 +54,6 @@ struct ExtendedProfile_Struct {
 	uint32				mercTimerRemaining; /* Not Used */
 	uint8				mercGender; /* Not Used */
 	int32				mercState; /* Not Used */
-	uint32				last_invsnapshot_time; /* Used */
-	uint32				next_invsnapshot_time; /* Used */
 };
 
 #pragma pack()

common/faction.cpp

@@ -1,4 +1,4 @@
-/*	 EQEMu: Everquest Server Emulator
+/*	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
@@ -15,40 +15,39 @@
 	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 "faction.h"
 #include "races.h"
 
-const char *FactionValueToString(FACTION_VALUE fv)
-{
-	switch (fv) {
-		case FACTION_ALLY:
-			return ("Ally");
-		case FACTION_WARMLY:
-			return ("Warmly");
-		case FACTION_KINDLY:
-			return ("Kindly");
-		case FACTION_AMIABLE:
-			return ("Amiable");
-		case FACTION_INDIFFERENT:
-			return ("Indifferent");
-		case FACTION_APPREHENSIVE:
-			return ("Apprehensive");
-		case FACTION_DUBIOUS:
-			return ("Dubious");
-		case FACTION_THREATENLY:
-			return ("Threatenly");
-		case FACTION_SCOWLS:
-			return ("Scowls, ready to attack.");
-		default:
-			break;
+const char *FactionValueToString(FACTION_VALUE fv) {
+	switch(fv) {
+	case FACTION_ALLY:
+		return("Ally");
+	case FACTION_WARMLY:
+		return("Warmly");
+	case FACTION_KINDLY:
+		return("Kindly");
+	case FACTION_AMIABLE:
+		return("Amiable");
+	case FACTION_INDIFFERENT:
+		return("Indifferent");
+	case FACTION_APPREHENSIVE:
+		return("Apprehensive");
+	case FACTION_DUBIOUS:
+		return("Dubious");
+	case FACTION_THREATENLY:
+		return("Threatenly");
+	case FACTION_SCOWLS:
+		return("Scowls, ready to attack.");
+	default:
+		break;
 	}
-	return ("Unknown Faction Con");
+	return("Unknown Faction Con");
 }
 
 
 //o--------------------------------------------------------------
-//| Name: CalculateFaction; Dec. 16, 2001
+//| Name: CalculateFaction; rembrant, Dec. 16, 2001
 //o--------------------------------------------------------------
 //| Notes: Returns the faction message value.
 //|		Modify these values to taste.
@@ -56,112 +55,86 @@ const char *FactionValueToString(FACTION_VALUE fv)
 FACTION_VALUE CalculateFaction(FactionMods* fm, int32 tmpCharacter_value)
 {
 	int32 character_value = tmpCharacter_value;
-	if (fm) {
+	if (fm)
 		character_value += fm->base + fm->class_mod + fm->race_mod + fm->deity_mod;
-	}
-	if (character_value >= 1101) {
-		return FACTION_ALLY;
-	}
-	if (character_value >= 701 && character_value <= 1100) {
-		return FACTION_WARMLY;
-	}
-	if (character_value >= 401 && character_value <= 700) {
-		return FACTION_KINDLY;
-	}
-	if (character_value >= 101 && character_value <= 400) {
-		return FACTION_AMIABLE;
-	}
-	if (character_value >= 0 && character_value <= 100) {
-		return FACTION_INDIFFERENT;
-	}
-	if (character_value >= -100 && character_value <= -1) {
-		return FACTION_APPREHENSIVE;
-	}
-	if (character_value >= -700 && character_value <= -101) {
-		return FACTION_DUBIOUS;
-	}
-	if (character_value >= -999 && character_value <= -701) {
-		return FACTION_THREATENLY;
-	}
-	if (character_value <= -1000) {
-		return FACTION_SCOWLS;
-	}
+	if(character_value >= 1101) return FACTION_ALLY;
+	if(character_value >= 701 && character_value <= 1100) return FACTION_WARMLY;
+	if(character_value >= 401 && character_value <= 700) return FACTION_KINDLY;
+	if(character_value >= 101 && character_value <= 400) return FACTION_AMIABLE;
+	if(character_value >= 0 && character_value <= 100) return FACTION_INDIFFERENT;
+	if(character_value >= -100 && character_value <= -1) return FACTION_APPREHENSIVE;
+	if(character_value >= -700 && character_value <= -101) return FACTION_DUBIOUS;
+	if(character_value >= -999 && character_value <= -701) return FACTION_THREATENLY;
+	if(character_value <= -1000) return FACTION_SCOWLS;
 	return FACTION_INDIFFERENT;
 }
 
-// this function should check if some races have more than one race define
+// neotokyo: this function should check if some races have more than one race define
 bool IsOfEqualRace(int r1, int r2)
 {
-	if (r1 == r2) {
+	if (r1 == r2)
 		return true;
-	}
 	// TODO: add more values
-	switch (r1) {
-		case DARK_ELF:
-			if (r2 == 77) {
-				return true;
-			}
-			break;
-		case BARBARIAN:
-			if (r2 == 90) {
-				return true;
-			}
+	switch(r1)
+	{
+	case DARK_ELF:
+		if (r2 == 77)
+			return true;
+		break;
+	case BARBARIAN:
+		if (r2 == 90)
+			return true;
 	}
 	return false;
 }
 
-// trolls endure ogres, dark elves, ...
+// neotokyo: trolls endure ogres, dark elves, ...
 bool IsOfIndiffRace(int r1, int r2)
 {
-	if (r1 == r2) {
+	if (r1 == r2)
 		return true;
-	}
 	// TODO: add more values
-	switch (r1) {
-		case DARK_ELF:
-		case OGRE:
-		case TROLL:
-			if (r2 == OGRE || r2 == TROLL || r2 == DARK_ELF) {
-				return true;
-			}
-			break;
-		case HUMAN:
-		case BARBARIAN:
-		case HALF_ELF:
-		case GNOME:
-		case HALFLING:
-		case WOOD_ELF:
-			if (r2 == HUMAN ||
-			    r2 == BARBARIAN ||
-			    r2 == ERUDITE ||
-			    r2 == HALF_ELF ||
-			    r2 == GNOME ||
-			    r2 == HALFLING ||
-			    r2 == DWARF ||
-			    r2 == HIGH_ELF ||
-			    r2 == WOOD_ELF) {
-				return true;
-			}
-			break;
-		case ERUDITE:
-			if (r2 == HUMAN || r2 == HALF_ELF) {
-				return true;
-			}
-			break;
-		case DWARF:
-			if (r2 == HALFLING || r2 == GNOME) {
-				return true;
-			}
-			break;
-		case HIGH_ELF:
-			if (r2 == WOOD_ELF) {
-				return true;
-			}
-			break;
-		case VAHSHIR:
+	switch(r1)
+	{
+	case DARK_ELF:
+	case OGRE:
+	case TROLL:
+		if (r2 == OGRE || r2 == TROLL || r2 == DARK_ELF)
 			return true;
-		case IKSAR:
-			return false;
+		break;
+	case HUMAN:
+	case BARBARIAN:
+	case HALF_ELF:
+	case GNOME:
+	case HALFLING:
+	case WOOD_ELF:
+		if (r2 == HUMAN ||
+			r2 == BARBARIAN ||
+			r2 == ERUDITE ||
+			r2 == HALF_ELF ||
+			r2 == GNOME ||
+			r2 == HALFLING ||
+			r2 == DWARF ||
+			r2 == HIGH_ELF ||
+			r2 == WOOD_ELF)
+			return true;
+		break;
+	case ERUDITE:
+		if (r2 == HUMAN || r2 == HALF_ELF)
+			return true;
+		break;
+	case DWARF:
+		if (r2 == HALFLING || r2 == GNOME)
+			return true;
+		break;
+	case HIGH_ELF:
+		if (r2 == WOOD_ELF)
+			return true;
+		break;
+	case VAHSHIR:
+		return true;
+	case IKSAR:
+		return false;
 	}
 	return false;
 }

common/features.h

@@ -154,17 +154,16 @@ enum {	//reuse times
 enum {	//timer settings, all in milliseconds
 	AImovement_duration = 100,
 	AIthink_duration = 150,
-	AIscanarea_delay = 6000,
+	AIscanarea_delay = 500,
 	AIfeignremember_delay = 500,
 	AItarget_check_duration = 500,
 	AIClientScanarea_delay = 750,	//used in REVERSE_AGGRO
 	AIassistcheck_delay = 3000,		//now often a fighting NPC will yell for help
-	AI_check_signal_timer_delay = 500, // How often EVENT_SIGNAL checks are processed
 	ClientProximity_interval = 150,
 	CombatEventTimer_expire = 12000,
 	Tribute_duration = 600000,
 	ZoneTimerResolution = 3,			//sleep time between zone main loop runs (milliseconds)
-	FeignMemoryDuration = 120000, // Duration player must feign death to clear zonewide agro.
+	FeignMemoryDuration = 120000, // EverHood - Duration player must feign death to clear zonewide agro.
 	EnragedTimer = 360000,
 	EnragedDurationTimer = 10000
 };
@@ -209,12 +208,12 @@ enum {	//some random constants
 //chance ratio that a
 #define THREATENLY_ARRGO_CHANCE 32 // 32/128 (25%) chance that a mob will arrgo on con Threatenly
 
-//max factions per npc faction list
+// max factions per npc faction list
 #define MAX_NPC_FACTIONS 20
 
-//individual faction pool
-#define MAX_PERSONAL_FACTION 1200
-#define MIN_PERSONAL_FACTION -3000
+//value caps
+#define MAX_FACTION 1500
+#define MIN_FACTION -1500
 
 //The Level Cap:
 //#define LEVEL_CAP RuleI(Character, MaxLevel)	//hard cap is 127
@@ -233,8 +232,6 @@ enum {	//some random constants
 #define GROUP_EXP_PER_POINT 1000
 #define RAID_EXP_PER_POINT 2000
 
-#define ZONE_CONTROLLER_NPC_ID 10
-
 //Some hard coded statuses from commands and other places:
 enum {
 	minStatusToBeGM = 40,
@@ -264,8 +261,7 @@ enum {
 	commandChangeFlags = 200,		//ability to set/refresh flags
 	commandBanPlayers = 100,		//can set bans on players
 	commandChangeDatarate = 201,	//edit client's data rate
-	commandZoneToCoords = 0,		//can #zone with coords
-	commandInterrogateInv = 100		//below this == only log on error state and self-only target dump
+	commandZoneToCoords = 0			//can #zone with coords
 };
 
 //default states for logging flag on NPCs and clients (having NPCs on by default is prolly a bad idea)
@@ -273,9 +269,6 @@ enum {
 #define NPC_DEFAULT_LOGGING_ENABLED false
 
 
-// This is the item ID we use for say links, we use the max that fits in 5 ASCII chars
-#define SAYLINK_ITEM_ID 0xFFFFF
-
 
 /*
 

common/glm/glm/CMakeLists.txt

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

common/glm/glm/common.hpp

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

common/glm/glm/detail/_features.hpp

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

common/glm/glm/detail/_fixes.hpp

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

common/glm/glm/detail/_literals.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -24,47 +20,32 @@
 /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 /// THE SOFTWARE.
 ///
-/// @ref gtx_matrix_decompose
-/// @file glm/gtx/matrix_decompose.hpp
-/// @date 2014-08-29 / 2014-08-29
+/// @ref core
+/// @file glm/core/_literals.hpp
+/// @date 2013-05-06 / 2013-05-06
 /// @author Christophe Riccio
-/// 
-/// @see core (dependence)
-///
-/// @defgroup gtx_matrix_decompose GLM_GTX_matrix_decompose
-/// @ingroup gtx
-/// 
-/// @brief Decomposes a model matrix to translations, rotation and scale components
-/// 
-/// <glm/gtx/decomposition.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
-
-// Dependencies
-#include "../mat4x4.hpp"
-#include "../vec3.hpp"
-#include "../vec4.hpp"
-#include "../gtc/quaternion.hpp"
-#include "../gtc/matrix_transform.hpp"
-
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
-#	pragma message("GLM: GLM_GTX_matrix_decompose extension included")
-#endif
+#ifndef glm_core_literals
+#define glm_core_literals
 
 namespace glm
 {
-	/// @addtogroup gtx_matrix_decompose
-	/// @{
+#define GLM_CXX11_USER_LITERALS
+#ifdef GLM_CXX11_USER_LITERALS
+/*
+	GLM_FUNC_QUALIFIER detail::half operator "" _h(long double const s)
+	{
+		return detail::half(s);
+	}
 
-	/// Decomposes a model matrix to translations, rotation and scale components 
-	/// @see gtx_matrix_decompose
-	template <typename T, precision P>
-	GLM_FUNC_DECL bool decompose(
-		tmat4x4<T, P> const & modelMatrix,
-		tvec3<T, P> & scale, tquat<T, P> & orientation, tvec3<T, P> & translation, tvec3<T, P> & skew, tvec4<T, P> & perspective);
+	GLM_FUNC_QUALIFIER float operator "" _f(long double const s)
+	{
+		return static_cast<float>(s);
+	}
+*/
+#endif//GLM_CXX11_USER_LITERALS
 
-	/// @}
 }//namespace glm
 
-#include "matrix_decompose.inl"
+#endif//glm_core_literals

common/glm/glm/detail/_noise.hpp

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

common/glm/glm/detail/_swizzle_func.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -25,12 +21,13 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/_swizzle_func.hpp
+/// @file glm/core/_swizzle_func.hpp
 /// @date 2011-10-16 / 2011-10-16
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_core_swizzle_func
+#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												\
@@ -723,3 +720,5 @@
 	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,10 +12,6 @@
 /// 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
@@ -25,136 +21,197 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/_vectorize.hpp
+/// @file glm/core/_vectorize.hpp
 /// @date 2011-10-14 / 2011-10-14
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef GLM_CORE_DETAIL_INCLUDED
+#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 <typename R, typename T, precision P, template <typename, precision> class vecType>
-	struct functor1{};
-
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec1>
+	template<bool C>
+	struct If
 	{
-		GLM_FUNC_QUALIFIER static tvec1<R, P> call(R (*Func) (T x), tvec1<T, P> const & v)
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
 		{
-			return tvec1<R, P>(Func(v.x));
+			return functor(val);
 		}
 	};
 
-	template <typename R, typename T, precision P>
-	struct functor1<R, T, P, tvec2>
+	template<>
+	struct If<false>
 	{
-		GLM_FUNC_QUALIFIER static tvec2<R, P> call(R (*Func) (T x), tvec2<T, P> const & v)
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F, const T& 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));
+			return val;
 		}
 	};
 }//namespace detail
 }//namespace glm
+
+#endif//GLM_CORE_DETAIL_INCLUDED

common/glm/glm/detail/dummy.cpp

@@ -12,10 +12,6 @@
 /// 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
@@ -33,6 +29,7 @@
 /// dummy.cpp exist only a wordaround for CMake file.
 ///////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #include "../glm.hpp"
 #include <limits>
@@ -45,7 +42,6 @@ struct material
 	glm::vec4 specular; // Scm
 	float shininess; // Srm
 };
-
 struct light
 {
 	glm::vec4 ambient; // Acli
@@ -64,7 +60,6 @@ struct light
 	float quadraticAttenuation;// K2
 };
 
-
 // Sample 1
 #include <glm/vec3.hpp>// glm::vec3
 #include <glm/geometric.hpp>// glm::cross, glm::normalize
@@ -189,34 +184,7 @@ 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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_common.hpp
+/// @file glm/core/func_common.hpp
 /// @date 2008-03-08 / 2010-01-26
 /// @author Christophe Riccio
 /// 
@@ -37,7 +33,8 @@
 /// These all operate component-wise. The description is per component.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef GLM_FUNC_COMMON_INCLUDED
+#define GLM_FUNC_COMMON_INCLUDED
 
 #include "setup.hpp"
 #include "precision.hpp"
@@ -56,10 +53,7 @@ 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 x);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> abs(vecType<T, P> const & x);
+	GLM_FUNC_DECL genType abs(genType const & x);
 
 	/// Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
 	/// 
@@ -67,17 +61,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> sign(vecType<T, P> const & x);
-
+	template <typename genType>
+	GLM_FUNC_DECL genType sign(genType const & x);
+	
 	/// Returns a value equal to the nearest integer that is less then or equal to x. 
 	/// 
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> floor(vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType floor(genType const & x);
 
 	/// Returns a value equal to the nearest integer to x
 	/// whose absolute value is not larger than the absolute value of x.
@@ -86,8 +80,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> trunc(vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType trunc(genType const & x);
 
 	/// Returns a value equal to the nearest integer to x.
 	/// The fraction 0.5 will round in a direction chosen by the
@@ -99,9 +93,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> round(vecType<T, P> const & x);
-
+	template <typename genType>
+	GLM_FUNC_DECL genType round(genType const & x);
+	
 	/// Returns a value equal to the nearest integer to x.
 	/// A fractional part of 0.5 will round toward the nearest even
 	/// integer. (Both 3.5 and 4.5 for x will return 4.0.)
@@ -111,8 +105,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> roundEven(vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType roundEven(genType const & x);
 
 	/// Returns a value equal to the nearest integer
 	/// that is greater than or equal to x.
@@ -121,8 +115,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> ceil(vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType ceil(genType const & x);
 
 	/// Return x - floor(x).
 	/// 
@@ -131,10 +125,7 @@ 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 x);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> fract(vecType<T, P> const & x);
+	GLM_FUNC_DECL genType fract(genType const & x);
 
 	/// Modulus. Returns x - y * floor(x / y)
 	/// for each component in x using the floating point value y.
@@ -144,13 +135,21 @@ 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(genType x, genType y);
+	GLM_FUNC_DECL genType mod(
+		genType const & x,
+		genType const & y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, T y);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mod(vecType<T, P> const & x, vecType<T, P> const & y);
+	/// Modulus. Returns x - y * floor(x / y)
+	/// for each component in x using the floating point value y.
+	/// 
+	/// @tparam genType Floating-point scalar or vector types.
+	/// 
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	template <typename genType>
+	GLM_FUNC_DECL genType mod(
+		genType 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
@@ -162,22 +161,25 @@ 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(genType x, genType & i);
+	GLM_FUNC_DECL genType modf(
+		genType const & x,
+		genType & i);
 
 	/// Returns y if y < x; otherwise, it returns x.
 	///
 	/// @tparam genType Floating-point or integer; scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
+	/// @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
 	template <typename genType>
-	GLM_FUNC_DECL genType min(genType x, genType y);
+	GLM_FUNC_DECL genType min(
+		genType const & x,
+		genType const & y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, T y);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> min(vecType<T, P> const & x, vecType<T, P> const & y);
+	template <typename genType>
+	GLM_FUNC_DECL genType min(
+		genType const & x,
+		typename genType::value_type const & y);
 
 	/// Returns y if x < y; otherwise, it returns x.
 	/// 
@@ -186,13 +188,14 @@ 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(genType x, genType y);
+	GLM_FUNC_DECL genType max(
+		genType const & x,
+		genType const & y);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, T y);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> max(vecType<T, P> const & x, vecType<T, P> const & y);
+	template <typename genType>
+	GLM_FUNC_DECL genType max(
+		genType const & x,
+		typename genType::value_type const & y);
 
 	/// Returns min(max(x, minVal), maxVal) for each component in x 
 	/// using the floating-point values minVal and maxVal.
@@ -202,13 +205,16 @@ 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(genType x, genType minVal, genType maxVal);
+	GLM_FUNC_DECL genType clamp(
+		genType const & x,
+		genType const & minVal,
+		genType const & maxVal);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, T minVal, T maxVal);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> clamp(vecType<T, P> const & x, vecType<T, P> const & minVal, vecType<T, P> const & maxVal);
+	template <typename genType, precision P>
+	GLM_FUNC_DECL genType clamp(
+		genType const & x,
+		typename genType::value_type const & minVal,
+		typename genType::value_type const & maxVal);
 
 	/// If genTypeU is a floating scalar or vector:
 	/// Returns x * (1.0 - a) + y * a, i.e., the linear blend of
@@ -253,34 +259,40 @@ 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(vecType<T, P> const & x, vecType<T, P> const & y, vecType<U, P> const & a);
+	GLM_FUNC_DECL vecType<T, P> mix(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y,
+		vecType<U, P> const & a);
 
 	template <typename T, typename U, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> mix(vecType<T, P> const & x, vecType<T, P> const & y, U a);
+	GLM_FUNC_DECL vecType<T, P> mix(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y,
+		U const & a);
 
 	template <typename genTypeT, typename genTypeU>
-	GLM_FUNC_DECL genTypeT mix(genTypeT x, genTypeT y, genTypeU a);
+	GLM_FUNC_DECL genTypeT mix(
+		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(genType edge, genType x);
+	GLM_FUNC_DECL genType step(
+		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(T edge, vecType<T, P> const & x);
-
-	/// Returns 0.0 if x < edge, otherwise it returns 1.0.
-	/// 
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.3 Common Functions</a>
-	template <template <typename, precision> class vecType, typename T, precision P>
-	GLM_FUNC_DECL vecType<T, P> step(vecType<T, P> const & edge, vecType<T, P> const & x);
+	GLM_FUNC_DECL vecType<T, P> step(
+		T 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
@@ -297,13 +309,16 @@ 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(genType edge0, genType edge1, genType x);
+	GLM_FUNC_DECL genType smoothstep(
+		genType const & edge0,
+		genType const & edge1,
+		genType const & x);
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> smoothstep(T edge0, T edge1, vecType<T, P> const & x);
-
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> smoothstep(vecType<T, P> const & edge0, vecType<T, P> const & edge1, vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType smoothstep(
+		typename genType::value_type const & edge0,
+		typename genType::value_type const & edge1,
+		genType const & x);
 
 	/// Returns true if x holds a NaN (not a number)
 	/// representation in the underlying implementation's set of
@@ -317,8 +332,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isnan(vecType<T, P> const & x);
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::bool_type isnan(genType const & x);
 
 	/// Returns true if x holds a positive infinity or negative
 	/// infinity representation in the underlying implementation's
@@ -330,8 +345,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<bool, P> isinf(vecType<T, P> const & x);
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::bool_type isinf(genType const & x);
 
 	/// Returns a signed integer value representing
 	/// the encoding of a floating-point value. The floating-point
@@ -454,3 +469,4 @@ namespace glm
 
 #include "func_common.inl"
 
+#endif//GLM_FUNC_COMMON_INCLUDED

common/glm/glm/detail/func_exponential.hpp

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

common/glm/glm/detail/func_exponential.inl

@@ -12,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_exponential.inl
+/// @file glm/core/func_exponential.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -33,28 +29,25 @@
 #include "func_vector_relational.hpp"
 #include "_vectorize.hpp"
 #include <limits>
-#include <cmath>
 #include <cassert>
 
 namespace glm{
 namespace detail
 {
-#	if GLM_HAS_CXX11_STL
-		using std::log2;
-#	else
-		template <typename genType>
-		genType log2(genType Value)
-		{
-			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
-		}
-#	endif
-
-	template <typename T, precision P, template <class, precision> class vecType, bool isFloat = true>
+	template <bool isFloat>
 	struct compute_log2
 	{
-		GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<T, P> const & vec)
+		template <typename T>
+		T operator() (T const & Value) const;
+	};
+
+	template <>
+	struct compute_log2<true>
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER T operator() (T const & Value) const
 		{
-			return detail::functor1<T, T, P, vecType>::call(log2, vec);
+			return static_cast<T>(::std::log(Value)) * static_cast<T>(1.4426950408889634073599246810019);
 		}
 	};
 
@@ -85,77 +78,170 @@ namespace detail
 }//namespace detail
 
 	// pow
-	using std::pow;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> pow(vecType<T, P> const & base, vecType<T, P> const & exponent)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
 	{
-		return detail::functor2<T, P, vecType>::call(pow, base, exponent);
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'pow' only accept floating-point inputs");
+
+		return std::pow(x, y);
 	}
 
+	VECTORIZE_VEC_VEC(pow)
+
 	// exp
-	using std::exp;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp(vecType<T, P> const & x)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType exp
+	(
+		genType const & x
+	)
 	{
-		return detail::functor1<T, T, P, vecType>::call(exp, x);
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'exp' only accept floating-point inputs");
+
+		return std::exp(x);
 	}
 
+	VECTORIZE_VEC(exp)
+
 	// log
-	using std::log;
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log(vecType<T, P> const & x)
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType log
+	(
+		genType const & x
+	)
 	{
-		return detail::functor1<T, T, P, vecType>::call(log, x);
+		GLM_STATIC_ASSERT(
+			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 x)
+	GLM_FUNC_QUALIFIER genType exp2(genType const & x)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
+		GLM_STATIC_ASSERT(
+			std::numeric_limits<genType>::is_iec559,
+			"'exp2' only accept floating-point inputs");
 
 		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> exp2(vecType<T, P> const & x)
-	{
-		return detail::functor1<T, T, P, vecType>::call(exp2, x);
-	}
+	VECTORIZE_VEC(exp2)
 
 	// log2, ln2 = 0.69314718055994530941723212145818f
 	template <typename genType>
 	GLM_FUNC_QUALIFIER genType log2(genType x)
 	{
-		return log2(tvec1<genType>(x)).x;
+		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559 || std::numeric_limits<genType>::is_integer,
+			"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);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> log2(vecType<T, P> const & x)
+	VECTORIZE_VEC(log2)
+
+	namespace detail
 	{
-		return detail::compute_log2<T, P, vecType, std::numeric_limits<T>::is_iec559>::call(x);
+		template <template <class, precision> class vecType, typename T, precision P>
+		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)
+	{
+#		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
 	}
 
-	// sqrt
-	using std::sqrt;
+	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::functor1<T, T, P, vecType>::call(sqrt, x);
+		return detail::compute_sqrt<vecType, T, P>::call(x);
 	}
 
 	// inversesqrt
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
+	GLM_FUNC_QUALIFIER float inversesqrt(float const & x)
 	{
-		return static_cast<genType>(1) / sqrt(x);
+		return 1.0f / sqrt(x);
 	}
 	
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> inversesqrt(vecType<T, P> const & x)
+	GLM_FUNC_QUALIFIER double inversesqrt(double 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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_geometric.hpp
+/// @file glm/core/func_geometric.hpp
 /// @date 2008-08-03 / 2011-06-14
 /// @author Christophe Riccio
 ///
@@ -37,7 +33,8 @@
 /// These operate on vectors as vectors, not component-wise.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_core_func_geometric
+#define glm_core_func_geometric
 
 #include "type_vec3.hpp"
 
@@ -52,9 +49,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T length(
-		vecType<T, P> const & x);
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::value_type length(
+		genType const & x); 
 
 	/// Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
 	///
@@ -62,10 +59,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 T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL T distance(
-		vecType<T, P> const & p0,
-		vecType<T, P> const & p1);
+	template <typename genType> 
+	GLM_FUNC_DECL typename genType::value_type distance(
+		genType const & p0, 
+		genType const & p1);
 
 	/// Returns the dot product of x and y, i.e., result = x * y.
 	///
@@ -78,6 +75,17 @@ 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.
@@ -85,18 +93,17 @@ 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 tvec3<T, P> cross(
-		tvec3<T, P> const & x,
-		tvec3<T, P> const & y);
+	GLM_FUNC_DECL detail::tvec3<T, P> cross(
+		detail::tvec3<T, P> const & x,
+		detail::tvec3<T, P> const & y);
 
 	/// Returns a vector in the same direction as x but with length of 1.
-	/// According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefined and generate an error.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.5 Geometric Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> normalize(
-		vecType<T, P> const & x);
+	template <typename genType>
+	GLM_FUNC_DECL genType normalize(
+		genType const & x);
 
 	/// If dot(Nref, I) < 0.0, return N, otherwise, return -N.
 	///
@@ -134,9 +141,11 @@ namespace glm
 	GLM_FUNC_DECL vecType<T, P> refract(
 		vecType<T, P> const & I,
 		vecType<T, P> const & N,
-		T eta);
+		T const & eta);
 
 	/// @}
 }//namespace glm
 
 #include "func_geometric.inl"
+
+#endif//glm_core_func_geometric

common/glm/glm/detail/func_geometric.inl

@@ -12,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_geometric.inl
+/// @file glm/core/func_geometric.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -43,40 +39,45 @@ namespace detail
 	struct compute_dot{};
 
 	template <typename T, precision P>
-	struct compute_dot<tvec1, T, P>
+	struct compute_dot<detail::tvec1, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec1<T, P> const & a, tvec1<T, P> const & b)
+		GLM_FUNC_QUALIFIER static T call(detail::tvec1<T, P> const & x, detail::tvec1<T, P> const & y)
 		{
-			return a.x * b.x;
+#			ifdef __CUDACC__ // Wordaround for a CUDA compiler bug up to CUDA6
+				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<tvec2, T, P>
+	struct compute_dot<detail::tvec2, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec2<T, P> const & x, tvec2<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(detail::tvec2<T, P> const & x, detail::tvec2<T, P> const & y)
 		{
-			tvec2<T, P> tmp(x * y);
+			detail::tvec2<T, P> tmp(x * y);
 			return tmp.x + tmp.y;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<tvec3, T, P>
+	struct compute_dot<detail::tvec3, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec3<T, P> const & x, tvec3<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(detail::tvec3<T, P> const & x, detail::tvec3<T, P> const & y)
 		{
-			tvec3<T, P> tmp(x * y);
+			detail::tvec3<T, P> tmp(x * y);
 			return tmp.x + tmp.y + tmp.z;
 		}
 	};
 
 	template <typename T, precision P>
-	struct compute_dot<tvec4, T, P>
+	struct compute_dot<detail::tvec4, T, P>
 	{
-		GLM_FUNC_QUALIFIER static T call(tvec4<T, P> const & x, tvec4<T, P> const & y)
+		GLM_FUNC_QUALIFIER static T call(detail::tvec4<T, P> const & x, detail::tvec4<T, P> const & y)
 		{
-			tvec4<T, P> tmp(x * y);
+			detail::tvec4<T, P> tmp(x * y);
 			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
 		}
 	};
@@ -84,58 +85,144 @@ namespace detail
 
 	// length
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType length(genType x)
+	GLM_FUNC_QUALIFIER genType length
+	(
+		genType const & x
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' only accept floating-point inputs");
 
-		return abs(x);
+		genType sqr = x * x;
+		return sqrt(sqr);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T length(vecType<T, P> const & v)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T length(detail::tvec2<T, P> const & v)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' only accept floating-point inputs");
 
-		return sqrt(dot(v, v));
+		T sqr = v.x * v.x + v.y * v.y;
+		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(genType const & p0, genType const & p1)
+	GLM_FUNC_QUALIFIER genType distance
+	(
+		genType const & p0,
+		genType const & p1
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' only accept floating-point inputs");
 
 		return length(p1 - p0);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T distance(vecType<T, P> const & p0, vecType<T, P> const & p1)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER T distance
+	(
+		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(T x, T y)
+	GLM_FUNC_QUALIFIER T dot
+	(
+		T const & x,
+		T const & y
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
-		return x * y;
+		return detail::compute_dot<detail::tvec1, T, highp>::call(x, y);
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER T dot(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER T dot
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' only accept floating-point inputs");
 		return detail::compute_dot<vecType, T, P>::call(x, y);
 	}
 
+/* // 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 tvec3<T, P> cross(tvec3<T, P> const & x, tvec3<T, P> const & y)
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> cross
+	(
+		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 tvec3<T, P>(
+		return detail::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);
@@ -143,53 +230,111 @@ namespace detail
 
 	// normalize
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType normalize(genType const & x)
+	GLM_FUNC_QUALIFIER genType normalize
+	(
+		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);
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> normalize(vecType<T, P> const & x)
+	// 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>
+	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");
 
-		return x * inversesqrt(dot(x, x));
+		T sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+		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(genType const & N, genType const & I, genType const & Nref)
+	GLM_FUNC_QUALIFIER genType faceforward
+	(
+		genType const & N,
+		genType const & I,
+		genType const & Nref
+	)
 	{
-		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
+		return dot(Nref, I) < 0 ? N : -N;
 	}
 
 	// reflect
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType reflect(genType const & I, genType const & N)
+	GLM_FUNC_QUALIFIER genType reflect
+	(
+		genType const & I,
+		genType const & N
+	)
 	{
-		return I - N * dot(N, I) * static_cast<genType>(2);
+		return I - N * dot(N, I) * genType(2);
 	}
 
 	// refract
 	template <typename genType>
-	GLM_FUNC_QUALIFIER genType refract(genType const & I, genType const & N, genType const & eta)
+	GLM_FUNC_QUALIFIER genType refract
+	(
+		genType const & I,
+		genType const & N,
+		genType const & eta
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' only accept floating-point inputs");
 
-		genType const dotValue(dot(N, I));
-		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
+		genType dotValue = dot(N, I);
+		genType k = genType(1) - eta * eta * (genType(1) - dotValue * dotValue);
+		if(k < genType(0))
+			return genType(0);
+		else
+			return eta * I - (eta * dotValue + sqrt(k)) * N;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> refract(vecType<T, P> const & I, vecType<T, P> const & N, T eta)
+	GLM_FUNC_QUALIFIER vecType<T, P> refract
+	(
+		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 const dotValue(dot(N, I));
-		T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
+		T dotValue = dot(N, I);
+		T k = T(1) - eta * eta * (T(1) - dotValue * dotValue);
+		if(k < 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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_integer.hpp
+/// @file glm/core/func_integer.hpp
 /// @date 2010-03-17 / 2011-06-18
 /// @author Christophe Riccio
 ///
@@ -39,12 +35,10 @@
 /// b, inclusive. The lowest-order bit is bit 0.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_core_func_integer
+#define glm_core_func_integer
 
 #include "setup.hpp"
-#include "precision.hpp"
-#include "func_common.hpp"
-#include "func_vector_relational.hpp"
 
 namespace glm
 {
@@ -59,11 +53,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 <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint, P> uaddCarry(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & carry);
+	template <typename genUType>
+	GLM_FUNC_DECL genUType uaddCarry(
+		genUType const & x,
+		genUType const & y,
+		genUType & carry);
 
 	/// Subtracts the 32-bit unsigned integer y from x, returning
 	/// the difference if non-negative, or pow(2, 32) plus the difference
@@ -73,12 +67,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 <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<uint, P> usubBorrow(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & borrow);
-
+	template <typename genUType>
+	GLM_FUNC_DECL genUType usubBorrow(
+		genUType const & x,
+		genUType const & y,
+		genUType & borrow);
+		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
 	/// The 32 most-significant bits are returned in msb.
@@ -87,12 +81,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 <precision P, template <typename, precision> class vecType>
+	template <typename genUType>
 	GLM_FUNC_DECL void umulExtended(
-		vecType<uint, P> const & x,
-		vecType<uint, P> const & y,
-		vecType<uint, P> & msb,
-		vecType<uint, P> & lsb);
+		genUType const & x,
+		genUType const & y,
+		genUType & msb,
+		genUType & lsb);
 		
 	/// Multiplies 32-bit integers x and y, producing a 64-bit
 	/// result. The 32 least-significant bits are returned in lsb.
@@ -102,12 +96,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 <precision P, template <typename, precision> class vecType>
+	template <typename genIType>
 	GLM_FUNC_DECL void imulExtended(
-		vecType<int, P> const & x,
-		vecType<int, P> const & y,
-		vecType<int, P> & msb,
-		vecType<int, P> & lsb);
+		genIType const & x,
+		genIType const & y,
+		genIType & msb,
+		genIType & lsb);
 
 	/// Extracts bits [offset, offset + bits - 1] from value,
 	/// returning them in the least significant bits of the result.
@@ -120,15 +114,15 @@ namespace glm
 	/// offset and bits is greater than the number of bits used
 	/// to store the operand.
 	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldExtract(
-		vecType<T, P> const & Value,
-		int Offset,
-		int Bits);
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldExtract(
+		genIUType const & Value,
+		int const & Offset,
+		int const & Bits);
 
 	/// Returns the insertion the bits least-significant bits of insert into base.
 	///
@@ -140,93 +134,70 @@ namespace glm
 	/// offset and bits is greater than the number of bits used to
 	/// store the operand.
 	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldInsert(
-		vecType<T, P> const & Base,
-		vecType<T, P> const & Insert,
-		int Offset,
-		int Bits);
+	template <typename genIUType>
+	GLM_FUNC_DECL genIUType bitfieldInsert(
+		genIUType const & Base,
+		genIUType const & Insert,
+		int const & Offset,
+		int const & Bits);
 
 	/// Returns the reversal of the bits of value. 
 	/// The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
 	/// where bits is the total number of bits used to represent value.
 	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<T, P> bitfieldReverse(vecType<T, P> const & v);
-
-	/// Returns the number of bits set to 1 in the binary representation of value.
-	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genType>
-	GLM_FUNC_DECL int bitCount(genType v);
-
-	/// Returns the number of bits set to 1 in the binary representation of value.
-	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
-
-	/// Returns the bit number of the least significant bit set to
-	/// 1 in the binary representation of value. 
-	/// If value is zero, -1 will be returned.
-	///
-	/// @tparam T Signed or unsigned integer scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename genIUType>
-	GLM_FUNC_DECL int findLSB(genIUType x);
+	GLM_FUNC_DECL genIUType bitfieldReverse(genIUType const & Value);
+		
+	/// Returns the number of bits set to 1 in the binary representation of value.
+	///
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
+	///
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type bitCount(genIUType<T> const & Value);
 
 	/// Returns the bit number of the least significant bit set to
 	/// 1 in the binary representation of value. 
 	/// If value is zero, -1 will be returned.
 	///
-	/// @tparam T Signed or unsigned integer scalar types.
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
+	///
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findLSB(genIUType<T> const & Value);
 
 	/// Returns the bit number of the most significant bit in the binary representation of value.
 	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
 	/// For negative integers, the result will be the bit number of the most significant
 	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @tparam T Signed or unsigned integer scalar types.
+	/// @tparam genIUType Signed or unsigned integer scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename genIUType>
-	GLM_FUNC_DECL int findMSB(genIUType x);
-
-	/// Returns the bit number of the most significant bit in the binary representation of value.
-	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
-	/// For negative integers, the result will be the bit number of the most significant
-	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @tparam T Signed or unsigned integer scalar types.
-	///
-	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
-	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
+	/// @todo Clarify the declaration to specify that scalars are suported.
+	template <typename T, template <typename> class genIUType>
+	GLM_FUNC_DECL typename genIUType<T>::signed_type findMSB(genIUType<T> const & Value);
 
 	/// @}
 }//namespace glm
 
 #include "func_integer.inl"
+
+#endif//glm_core_func_integer
+

common/glm/glm/detail/func_integer.inl

@@ -12,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_integer.inl
+/// @file glm/core/func_integer.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -43,186 +39,73 @@
 #endif//(GLM_ARCH != GLM_ARCH_PURE)
 #include <limits>
 
-namespace glm{
-namespace detail
+namespace glm
 {
-	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
-	GLM_FUNC_QUALIFIER uint uaddCarry(uint const & x, uint const & y, uint & Carry)
+	template <>
+	GLM_FUNC_QUALIFIER uint uaddCarry
+	(
+		uint const & x,
+		uint const & y,
+		uint & Carry
+	)
 	{
-		uint64 const Value64(static_cast<uint64>(x) + static_cast<uint64>(y));
-		uint64 const Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-		Carry = Value64 > Max32 ? 1 : 0;
-		return static_cast<uint32>(Value64 % (Max32 + static_cast<uint64>(1)));
+		uint64 Value64 = static_cast<uint64>(x) + static_cast<uint64>(y);
+		uint32 Result = static_cast<uint32>(Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32)));
+		Carry = (Value64 % (static_cast<uint64>(1) << static_cast<uint64>(32))) > 1 ? static_cast<uint32>(1) : static_cast<uint32>(0);
+		return Result;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> uaddCarry(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Carry)
+	template <>
+	GLM_FUNC_QUALIFIER uvec2 uaddCarry
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & Carry
+	)
 	{
-		vecType<uint64, P> Value64(vecType<uint64, P>(x) + vecType<uint64, P>(y));
-		vecType<uint64, P> Max32((static_cast<uint64>(1) << static_cast<uint64>(32)) - static_cast<uint64>(1));
-		Carry = mix(vecType<uint32, P>(0), vecType<uint32, P>(1), greaterThan(Value64, Max32));
-		return vecType<uint32,P>(Value64 % (Max32 + static_cast<uint64>(1)));
+		return uvec2(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[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
-	GLM_FUNC_QUALIFIER uint usubBorrow(uint const & x, uint const & y, uint & Borrow)
+	template <>
+	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");
 
@@ -233,17 +116,57 @@ namespace detail
 			return static_cast<uint32>((static_cast<int64>(1) << static_cast<int64>(32)) + (static_cast<int64>(y) - static_cast<int64>(x)));
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<uint, P> usubBorrow(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & Borrow)
+	template <>
+	GLM_FUNC_QUALIFIER uvec2 usubBorrow
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & Borrow
+	)
 	{
-		Borrow = mix(vecType<uint, P>(1), vecType<uint, P>(0), greaterThanEqual(x, y));
-		vecType<uint, P> const YgeX(y - x);
-		vecType<uint, P> const XgeY(vecType<uint32, P>((static_cast<int64>(1) << static_cast<int64>(32)) + (vecType<int64, P>(y) - vecType<int64, P>(x))));
-		return mix(XgeY, YgeX, greaterThanEqual(y, x));
+		return uvec2(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]));
+	}
+
+	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
-	GLM_FUNC_QUALIFIER void umulExtended(uint const & x, uint const & y, uint & msb, uint & lsb)
+	template <>
+	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");
 
@@ -254,18 +177,57 @@ namespace detail
 		lsb = *PointerLSB;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void umulExtended(vecType<uint, P> const & x, vecType<uint, P> const & y, vecType<uint, P> & msb, vecType<uint, P> & lsb)
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		uvec2 const & x,
+		uvec2 const & y,
+		uvec2 & msb,
+		uvec2 & lsb
+	)
 	{
-		GLM_STATIC_ASSERT(sizeof(uint) == sizeof(uint32), "uint and uint32 size mismatch");
+		umulExtended(x[0], y[0], msb[0], lsb[0]);
+		umulExtended(x[1], y[1], msb[1], lsb[1]);
+	}
 
-		vecType<uint64, P> Value64(vecType<uint64, P>(x) * vecType<uint64, P>(y));
-		msb = vecType<uint32, P>(Value64 >> static_cast<uint64>(32));
-		lsb = vecType<uint32, P>(Value64);
+	template <>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		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
-	GLM_FUNC_QUALIFIER void imulExtended(int x, int y, int & msb, int & lsb)
+	template <>
+	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");
 
@@ -276,118 +238,417 @@ namespace detail
 		lsb = *PointerLSB;
 	}
 
-	template <precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER void imulExtended(vecType<int, P> const & x, vecType<int, P> const & y, vecType<int, P> & msb, vecType<int, P> & lsb)
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		ivec2 const & x,
+		ivec2 const & y,
+		ivec2 & msb,
+		ivec2 & lsb
+	)
 	{
-		GLM_STATIC_ASSERT(sizeof(int) == sizeof(int32), "int and int32 size mismatch");
+		imulExtended(x[0], y[0], msb[0], lsb[0]),
+		imulExtended(x[1], y[1], msb[1], lsb[1]);
+	}
 
-		vecType<int64, P> Value64(vecType<int64, P>(x) * vecType<int64, P>(y));
-		lsb = vecType<int32, P>(Value64 & static_cast<int64>(0xFFFFFFFF));
-		msb = vecType<int32, P>((Value64 >> static_cast<int64>(32)) & static_cast<int64>(0xFFFFFFFF));
+	template <>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		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(genIUType Value, int Offset, int Bits)
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
+	(
+		genIUType const & Value,
+		int const & Offset,
+		int const & Bits
+	)
 	{
-		return bitfieldExtract(tvec1<genIUType>(Value), Offset, Bits).x;
+		int GenSize = int(sizeof(genIUType)) << int(3);
+
+		assert(Offset + Bits <= GenSize);
+
+		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
+		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
+
+		return ShiftBack;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldExtract(vecType<T, P> const & Value, int Offset, int Bits)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> bitfieldExtract
+	(
+		detail::tvec2<T, P> const & Value,
+		int const & Offset,
+		int const & Bits
+	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldExtract' only accept integer inputs");
+		return detail::tvec2<T, P>(
+			bitfieldExtract(Value[0], Offset, Bits),
+			bitfieldExtract(Value[1], Offset, Bits));
+	}
 
-		return (Value >> static_cast<T>(Offset)) & static_cast<T>(detail::mask(Bits));
+	template <typename T, precision P>
+	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(genIUType const & Base, genIUType const & Insert, int Offset, int Bits)
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
+	(
+		genIUType const & Base,
+		genIUType const & Insert,
+		int const & Offset,
+		int const & Bits
+	)
 	{
-		return bitfieldInsert(tvec1<genIUType>(Base), tvec1<genIUType>(Insert), Offset, Bits).x;
-	}
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+		assert(Offset + Bits <= sizeof(genIUType));
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldInsert(vecType<T, P> const & Base, vecType<T, P> const & Insert, int Offset, int Bits)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'bitfieldInsert' only accept integer values");
+		if(Bits == 0)
+			return Base;
+
+		genIUType Mask = 0;
+		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);
 	}
 
-	// bitfieldReverse
-	template <typename genType>
-	GLM_FUNC_QUALIFIER genType bitfieldReverse(genType x)
+	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 bitfieldReverse(glm::tvec1<genType, glm::defaultp>(x)).x;
+		return detail::tvec2<T, P>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T, P> bitfieldReverse(vecType<T, P> const & v)
+	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
+	)
 	{
-		vecType<T, P> x(v);
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
-		x = detail::compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
-		return x;
+		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>
+	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		genIUType Out = 0;
+		std::size_t BitSize = sizeof(genIUType) * 8;
+		for(std::size_t i = 0; i < BitSize; ++i)
+			if(Value & (genIUType(1) << i))
+				Out |= genIUType(1) << (BitSize - 1 - i);
+		return Out;
+	}	
+
+	VECTORIZE_VEC(bitfieldReverse)
+
 	// bitCount
-	template <typename genType>
-	GLM_FUNC_QUALIFIER int bitCount(genType x)
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
 	{
-		return bitCount(glm::tvec1<genType, glm::defaultp>(x)).x;
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+		int Count = 0;
+		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+		{
+			if(Value & (1 << i))
+				++Count;
+		}
+		return Count;
 	}
 
-	template <typename T, glm::precision P, template <typename, glm::precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> bitCount(vecType<T, P> const & v)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<int, P> bitCount
+	(
+		detail::tvec2<T, P> const & value
+	)
 	{
-		vecType<typename detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<typename detail::make_unsigned<T>::type, P> const *>(&v));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename detail::make_unsigned<T>::type(0x5555555555555555ull), typename detail::make_unsigned<T>::type( 1));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename detail::make_unsigned<T>::type(0x3333333333333333ull), typename detail::make_unsigned<T>::type( 2));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename detail::make_unsigned<T>::type( 4));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename detail::make_unsigned<T>::type( 8));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename detail::make_unsigned<T>::type(16));
-		x = detail::compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename detail::make_unsigned<T>::type(32));
-		return vecType<int, P>(x);
+		return detail::tvec2<int, P>(
+			bitCount(value[0]),
+			bitCount(value[1]));
+	}
+
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<int, P> bitCount
+	(
+		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(genIUType Value)
+	GLM_FUNC_QUALIFIER int findLSB
+	(
+		genIUType const & Value
+	)
 	{
 		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+		if(Value == 0)
+			return -1;
 
-		return detail::compute_findLSB<genIUType, sizeof(genIUType) * 8>::call(Value);
+		genIUType Bit;
+		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
+		return Bit;
 	}
 
-	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> findLSB(vecType<T, P> const & x)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec2<int, P> findLSB
+	(
+		detail::tvec2<T, P> const & value
+	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findLSB' only accept integer values");
+		return detail::tvec2<int, P>(
+			findLSB(value[0]),
+			findLSB(value[1]));
+	}
 
-		return detail::functor1<int, T, P, vecType>::call(findLSB, x);
+	template <typename T, precision P>
+	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(genIUType x)
+	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;
 
-		return findMSB(tvec1<genIUType>(x)).x;
+		unsigned long Result(0);
+		_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, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<int, P> findMSB(vecType<T, P> const & x)
+	template <typename T, precision P>
+	GLM_FUNC_QUALIFIER detail::tvec3<int, P> findMSB
+	(
+		detail::tvec3<T, P> const & value
+	)
 	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, "'findMSB' only accept integer values");
+		return detail::tvec3<int, P>(
+			findMSB(value[0]),
+			findMSB(value[1]),
+			findMSB(value[2]));
+	}
 
-		return detail::compute_findMSB_vec<T, P, vecType, sizeof(T) * 8>::call(x);
+	template <typename T, precision P>
+	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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_matrix.hpp
+/// @file glm/core/func_matrix.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///
@@ -41,7 +37,8 @@
 /// floating point version is shown.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef GLM_CORE_func_matrix
+#define GLM_CORE_func_matrix
 
 // Dependencies
 #include "../detail/precision.hpp"
@@ -140,6 +137,8 @@ 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);
 
@@ -149,7 +148,7 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2012))
+#	if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC11))
 		template <typename T, precision P, template <typename, precision> class matType>
 		GLM_FUNC_DECL typename matType<T, P>::transpose_type transpose(matType<T, P> const & x);
 #	endif
@@ -176,3 +175,5 @@ namespace detail
 }//namespace glm
 
 #include "func_matrix.inl"
+
+#endif//GLM_CORE_func_matrix

common/glm/glm/detail/func_matrix.inl

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

common/glm/glm/detail/func_noise.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_noise.hpp
+/// @file glm/core/func_noise.hpp
 /// @date 2008-08-01 / 2011-06-18
 /// @author Christophe Riccio
 ///
@@ -39,7 +35,8 @@
 /// appearance of randomness, but are not truly random.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_core_func_noise
+#define glm_core_func_noise
 
 #include "type_vec1.hpp"
 #include "type_vec2.hpp"
@@ -67,7 +64,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 tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
+	GLM_FUNC_DECL detail::tvec2<typename genType::value_type, defaultp> noise2(genType const & x);
 
 	/// Returns a 3D noise value based on the input value x.
 	///
@@ -76,7 +73,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 tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
+	GLM_FUNC_DECL detail::tvec3<typename genType::value_type, defaultp> noise3(genType const & x);
 
 	/// Returns a 4D noise value based on the input value x.
 	///
@@ -85,9 +82,11 @@ 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 tvec4<typename genType::value_type, defaultp> noise4(genType const & x);
+	GLM_FUNC_DECL detail::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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_noise.inl
+/// @file glm/core/func_noise.inl
 /// @date 2008-08-01 / 2011-09-27
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -37,43 +33,43 @@ namespace glm{
 namespace detail
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> grad4(T const & j, tvec4<T, P> const & ip)
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> grad4(T const & j, detail::tvec4<T, P> const & ip)
 	{
-		tvec3<T, P> pXYZ = floor(fract(tvec3<T, P>(j) * tvec3<T, P>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = static_cast<T>(1.5) - dot(abs(pXYZ), tvec3<T, P>(1));
-		tvec4<T, P> s = tvec4<T, P>(lessThan(tvec4<T, P>(pXYZ, pW), tvec4<T, P>(0.0)));
-		pXYZ = pXYZ + (tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
-		return tvec4<T, P>(pXYZ, pW);
+		detail::tvec3<T, P> pXYZ = floor(fract(detail::tvec3<T, P>(j) * detail::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));
+		detail::tvec4<T, P> s = detail::tvec4<T, P>(lessThan(detail::tvec4<T, P>(pXYZ, pW), detail::tvec4<T, P>(0.0)));
+		pXYZ = pXYZ + (detail::tvec3<T, P>(s) * T(2) - T(1)) * s.w; 
+		return detail::tvec4<T, P>(pXYZ, pW);
 	}
 }//namespace detail
 
 	template <typename T>
 	GLM_FUNC_QUALIFIER T noise1(T const & x)
 	{
-		return noise1(tvec2<T, defaultp>(x, T(0)));
+		return noise1(detail::tvec2<T, defaultp>(x, T(0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec2<T, defaultp> noise2(T const & x)
+	GLM_FUNC_QUALIFIER detail::tvec2<T, defaultp> noise2(T const & x)
 	{
-		return tvec2<T, defaultp>(
+		return detail::tvec2<T, defaultp>(
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec3<T, defaultp> noise3(T const & x)
+	GLM_FUNC_QUALIFIER detail::tvec3<T, defaultp> noise3(T const & x)
 	{
-		return tvec3<T, defaultp>(
+		return detail::tvec3<T, defaultp>(
 			noise1(x - T(1.0)),
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)));
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tvec4<T, defaultp> noise4(T const & x)
+	GLM_FUNC_QUALIFIER detail::tvec4<T, defaultp> noise4(T const & x)
 	{
-		return tvec4<T, defaultp>(
+		return detail::tvec4<T, defaultp>(
 			noise1(x - T(1.0)),
 			noise1(x + T(0.0)),
 			noise1(x + T(1.0)),
@@ -81,38 +77,38 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec2<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec2<T, P> const & v)
 	{
-		tvec4<T, P> const C = tvec4<T, P>(
+		detail::tvec4<T, P> const C = detail::tvec4<T, P>(
 			T( 0.211324865405187),		// (3.0 -  sqrt(3.0)) / 6.0
 			T( 0.366025403784439),		//  0.5 * (sqrt(3.0)  - 1.0)
 			T(-0.577350269189626),		// -1.0 + 2.0 * C.x
 			T( 0.024390243902439));		//  1.0 / 41.0
 		
 		// First corner
-		tvec2<T, P> i  = floor(v + dot(v, tvec2<T, P>(C[1])));
-		tvec2<T, P> x0 = v -   i + dot(i, tvec2<T, P>(C[0]));
+		detail::tvec2<T, P> i  = floor(v + dot(v, detail::tvec2<T, P>(C[1])));
+		detail::tvec2<T, P> x0 = v -   i + dot(i, detail::tvec2<T, P>(C[0]));
 		
 		// Other corners
 		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
 		//i1.y = 1.0 - i1.x;
-		tvec2<T, P> i1 = (x0.x > x0.y) ? tvec2<T, P>(1, 0) : tvec2<T, P>(0, 1);
+		detail::tvec2<T, P> i1 = (x0.x > x0.y) ? detail::tvec2<T, P>(1, 0) : detail::tvec2<T, P>(0, 1);
 
 		// x0 = x0 - 0.0 + 0.0 * C.xx ;
 		// x1 = x0 - i1 + 1.0 * C.xx ;
 		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		tvec4<T, P> x12 = tvec4<T, P>(x0.x, x0.y, x0.x, x0.y) + tvec4<T, P>(C.x, C.x, C.z, C.z);
-		x12 = tvec4<T, P>(tvec2<T, P>(x12) - i1, x12.z, x12.w);
+		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);
+		x12 = detail::tvec4<T, P>(detail::tvec2<T, P>(x12) - i1, x12.z, x12.w);
 		
 		// Permutations
 		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		tvec3<T, P> p = detail::permute(
-			detail::permute(i.y + tvec3<T, P>(T(0), i1.y, T(1))) + i.x + tvec3<T, P>(T(0), i1.x, T(1)));
+		detail::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)));
 		
-		tvec3<T, P> m = max(T(0.5) - tvec3<T, P>(
+		detail::tvec3<T, P> m = max(T(0.5) - detail::tvec3<T, P>(
 			dot(x0, x0),
-			dot(tvec2<T, P>(x12.x, x12.y), tvec2<T, P>(x12.x, x12.y)),
-			dot(tvec2<T, P>(x12.z, x12.w), tvec2<T, P>(x12.z, x12.w))), T(0));
+			dot(detail::tvec2<T, P>(x12.x, x12.y), detail::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));
 		
 		m = m * m;
 		m = m * m;
@@ -120,17 +116,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)
 		
-		tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
-		tvec3<T, P> h = abs(x) - T(0.5);
-		tvec3<T, P> ox = floor(x + T(0.5));
-		tvec3<T, P> a0 = x - ox;
+		detail::tvec3<T, P> x = static_cast<T>(2) * fract(p * C.w) - T(1);
+		detail::tvec3<T, P> h = abs(x) - T(0.5);
+		detail::tvec3<T, P> ox = floor(x + T(0.5));
+		detail::tvec3<T, P> a0 = x - ox;
 		
 		// Normalise gradients implicitly by scaling m
 		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
 		m *= static_cast<T>(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
 		
 		// Compute final noise value at P
-		tvec3<T, P> g;
+		detail::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;
@@ -139,84 +135,84 @@ namespace detail
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec3<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec3<T, P> const & v)
 	{
-		tvec2<T, P> const C(1.0 / 6.0, 1.0 / 3.0);
-		tvec4<T, P> const D(0.0, 0.5, 1.0, 2.0);
+		detail::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);
 		
 		// First corner
-		tvec3<T, P> i(floor(v + dot(v, tvec3<T, P>(C.y))));
-		tvec3<T, P> x0(v - i + dot(i, tvec3<T, P>(C.x)));
+		detail::tvec3<T, P> i(floor(v + dot(v, detail::tvec3<T, P>(C.y))));
+		detail::tvec3<T, P> x0(v - i + dot(i, detail::tvec3<T, P>(C.x)));
 		
 		// Other corners
-		tvec3<T, P> g(step(tvec3<T, P>(x0.y, x0.z, x0.x), x0));
-		tvec3<T, P> l(T(1) - g);
-		tvec3<T, P> i1(min(g, tvec3<T, P>(l.z, l.x, l.y)));
-		tvec3<T, P> i2(max(g, tvec3<T, P>(l.z, l.x, l.y)));
+		detail::tvec3<T, P> g(step(detail::tvec3<T, P>(x0.y, x0.z, x0.x), x0));
+		detail::tvec3<T, P> l(T(1) - g);
+		detail::tvec3<T, P> i1(min(g, detail::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)));
 		
 		// x0 = x0 - 0.0 + 0.0 * C.xxx;
 		// x1 = x0 - i1  + 1.0 * C.xxx;
 		// x2 = x0 - i2  + 2.0 * C.xxx;
 		// x3 = x0 - 1.0 + 3.0 * C.xxx;
-		tvec3<T, P> x1(x0 - i1 + C.x);
-		tvec3<T, P> x2(x0 - i2 + C.y);		// 2.0*C.x = 1/3 = C.y
-		tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
+		detail::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
+		detail::tvec3<T, P> x3(x0 - D.y);			// -1.0+3.0*C.x = -0.5 = -D.y
 		
 		// Permutations
 		i = mod289(i); 
-		tvec4<T, P> p(detail::permute(detail::permute(detail::permute(
-			i.z + tvec4<T, P>(T(0), i1.z, i2.z, T(1))) +
-			i.y + tvec4<T, P>(T(0), i1.y, i2.y, T(1))) +
-			i.x + tvec4<T, P>(T(0), i1.x, i2.x, T(1))));
+		detail::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.y + detail::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))));
 		
 		// Gradients: 7x7 points over a square, mapped onto an octahedron.
 		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
 		T n_ = static_cast<T>(0.142857142857); // 1.0/7.0
-		tvec3<T, P> ns(n_ * tvec3<T, P>(D.w, D.y, D.z) - tvec3<T, P>(D.x, D.z, D.x));
+		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));
 		
-		tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
+		detail::tvec4<T, P> j(p - T(49) * floor(p * ns.z * ns.z));	// mod(p,7*7)
 		
-		tvec4<T, P> x_(floor(j * ns.z));
-		tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
+		detail::tvec4<T, P> x_(floor(j * ns.z));
+		detail::tvec4<T, P> y_(floor(j - T(7) * x_));				// mod(j,N)
 		
-		tvec4<T, P> x(x_ * ns.x + ns.y);
-		tvec4<T, P> y(y_ * ns.x + ns.y);
-		tvec4<T, P> h(T(1) - abs(x) - abs(y));
+		detail::tvec4<T, P> x(x_ * ns.x + ns.y);
+		detail::tvec4<T, P> y(y_ * ns.x + ns.y);
+		detail::tvec4<T, P> h(T(1) - abs(x) - abs(y));
 		
-		tvec4<T, P> b0(x.x, x.y, y.x, y.y);
-		tvec4<T, P> b1(x.z, x.w, y.z, y.w);
+		detail::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);
 		
 		// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
 		// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		tvec4<T, P> s0(floor(b0) * T(2) + T(1));
-		tvec4<T, P> s1(floor(b1) * T(2) + T(1));
-		tvec4<T, P> sh(-step(h, tvec4<T, P>(0.0)));
+		detail::tvec4<T, P> s0(floor(b0) * T(2) + T(1));
+		detail::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> a0 = tvec4<T, P>(b0.x, b0.z, b0.y, b0.w) + tvec4<T, P>(s0.x, s0.z, s0.y, s0.w) * tvec4<T, P>(sh.x, sh.x, sh.y, sh.y);
-		tvec4<T, P> a1 = tvec4<T, P>(b1.x, b1.z, b1.y, b1.w) + tvec4<T, P>(s1.x, s1.z, s1.y, s1.w) * tvec4<T, P>(sh.z, sh.z, sh.w, sh.w);
+		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);
+		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);
 		
-		tvec3<T, P> p0(a0.x, a0.y, h.x);
-		tvec3<T, P> p1(a0.z, a0.w, h.y);
-		tvec3<T, P> p2(a1.x, a1.y, h.z);
-		tvec3<T, P> p3(a1.z, a1.w, h.w);
+		detail::tvec3<T, P> p0(a0.x, a0.y, h.x);
+		detail::tvec3<T, P> p1(a0.z, a0.w, h.y);
+		detail::tvec3<T, P> p2(a1.x, a1.y, h.z);
+		detail::tvec3<T, P> p3(a1.z, a1.w, h.w);
 		
 		// Normalise gradients
-		tvec4<T, P> norm = taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		detail::tvec4<T, P> norm = taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
 		p3 *= norm.w;
 		
 		// Mix final noise value
-		tvec4<T, P> m = max(T(0.6) - tvec4<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), T(0));
+		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));
 		m = m * m;
-		return T(42) * dot(m * m, tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
+		return T(42) * dot(m * m, detail::tvec4<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T noise1(tvec4<T, P> const & v)
+	GLM_FUNC_QUALIFIER T noise1(detail::tvec4<T, P> const & v)
 	{
-		tvec4<T, P> const C(
+		detail::tvec4<T, P> const C(
 			0.138196601125011,		// (5 - sqrt(5))/20  G4
 			0.276393202250021,		// 2 * G4
 			0.414589803375032,		// 3 * G4
@@ -226,66 +222,66 @@ namespace detail
 		T const F4 = static_cast<T>(0.309016994374947451);
 		
 		// First corner
-		tvec4<T, P> i  = floor(v + dot(v, tvec4<T, P>(F4)));
-		tvec4<T, P> x0 = v -   i + dot(i, tvec4<T, P>(C.x));
+		detail::tvec4<T, P> i  = floor(v + dot(v, detail::tvec4<T, P>(F4)));
+		detail::tvec4<T, P> x0 = v -   i + dot(i, detail::tvec4<T, P>(C.x));
 		
 		// Other corners
 		
 		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		tvec4<T, P> i0;
-		tvec3<T, P> isX = step(tvec3<T, P>(x0.y, x0.z, x0.w), tvec3<T, P>(x0.x));
-		tvec3<T, P> isYZ = step(tvec3<T, P>(x0.z, x0.w, x0.w), tvec3<T, P>(x0.y, x0.y, x0.z));
+		detail::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));
+		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));
 		
 		//  i0.x = dot(isX, vec3(1.0));
 		//i0.x = isX.x + isX.y + isX.z;
 		//i0.yzw = static_cast<T>(1) - isX;
-		i0 = tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
+		i0 = detail::tvec4<T, P>(isX.x + isX.y + isX.z, T(1) - isX);
 		
 		//  i0.y += dot(isYZ.xy, vec2(1.0));
 		i0.y += isYZ.x + isYZ.y;
 		
-		//i0.zw += 1.0 - tvec2<T, P>(isYZ.x, isYZ.y);
+		//i0.zw += 1.0 - detail::tvec2<T, P>(isYZ.x, isYZ.y);
 		i0.z += static_cast<T>(1) - isYZ.x;
 		i0.w += static_cast<T>(1) - isYZ.y;
 		i0.z += isYZ.z;
 		i0.w += static_cast<T>(1) - isYZ.z;
 		
 		// i0 now contains the unique values 0,1,2,3 in each channel
-		tvec4<T, P> i3 = clamp(i0, T(0), T(1));
-		tvec4<T, P> i2 = clamp(i0 - T(1), T(0), T(1));
-		tvec4<T, P> i1 = clamp(i0 - T(2), T(0), T(1));
+		detail::tvec4<T, P> i3 = clamp(i0, T(0), T(1));
+		detail::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));
 		
 		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
 		//  x1 = x0 - i1  + 0.0 * C.xxxx
 		//  x2 = x0 - i2  + 0.0 * C.xxxx
 		//  x3 = x0 - i3  + 0.0 * C.xxxx
 		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		tvec4<T, P> x1 = x0 - i1 + C.x;
-		tvec4<T, P> x2 = x0 - i2 + C.y;
-		tvec4<T, P> x3 = x0 - i3 + C.z;
-		tvec4<T, P> x4 = x0 + C.w;
+		detail::tvec4<T, P> x1 = x0 - i1 + C.x;
+		detail::tvec4<T, P> x2 = x0 - i2 + C.y;
+		detail::tvec4<T, P> x3 = x0 - i3 + C.z;
+		detail::tvec4<T, P> x4 = x0 + C.w;
 		
 		// Permutations
 		i = mod(i, T(289));
 		T j0 = detail::permute(detail::permute(detail::permute(detail::permute(i.w) + i.z) + i.y) + i.x);
-		tvec4<T, P> j1 = detail::permute(detail::permute(detail::permute(detail::permute(
-			i.w + tvec4<T, P>(i1.w, i2.w, i3.w, T(1))) +
-			i.z + tvec4<T, P>(i1.z, i2.z, i3.z, T(1))) +
-			i.y + tvec4<T, P>(i1.y, i2.y, i3.y, T(1))) +
-			i.x + tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
+		detail::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.z + detail::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.x + detail::tvec4<T, P>(i1.x, i2.x, i3.x, T(1)));
 		
 		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
 		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		tvec4<T, P> ip = tvec4<T, P>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+		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> p0 = detail::grad4(j0,   ip);
-		tvec4<T, P> p1 = detail::grad4(j1.x, ip);
-		tvec4<T, P> p2 = detail::grad4(j1.y, ip);
-		tvec4<T, P> p3 = detail::grad4(j1.z, ip);
-		tvec4<T, P> p4 = detail::grad4(j1.w, ip);
+		detail::tvec4<T, P> p0 = detail::grad4(j0,   ip);
+		detail::tvec4<T, P> p1 = detail::grad4(j1.x, ip);
+		detail::tvec4<T, P> p2 = detail::grad4(j1.y, ip);
+		detail::tvec4<T, P> p3 = detail::grad4(j1.z, ip);
+		detail::tvec4<T, P> p4 = detail::grad4(j1.w, ip);
 		
 		// Normalise gradients
-		tvec4<T, P> norm = detail::taylorInvSqrt(tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		detail::tvec4<T, P> norm = detail::taylorInvSqrt(detail::tvec4<T, P>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
 		p0 *= norm.x;
 		p1 *= norm.y;
 		p2 *= norm.z;
@@ -293,96 +289,96 @@ namespace detail
 		p4 *= taylorInvSqrt(dot(p4, p4));
 		
 		// Mix contributions from the five corners
-		tvec3<T, P> m0 = max(T(0.6) - tvec3<T, P>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		tvec2<T, P> m1 = max(T(0.6) - tvec2<T, P>(dot(x3, x3), dot(x4, x4)             ), T(0));
+		detail::tvec3<T, P> m0 = max(T(0.6) - detail::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));
 		m0 = m0 * m0;
 		m1 = m1 * m1;
 		
 		return T(49) * (
-			dot(m0 * m0, tvec3<T, P>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) +
-			dot(m1 * m1, tvec2<T, P>(dot(p3, x3), dot(p4, x4))));
+			dot(m0 * m0, detail::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))));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec2<T, P> const & x)
 	{
-		return tvec2<T, P>(
-			noise1(x + tvec2<T, P>(0.0)),
-			noise1(tvec2<T, P>(0.0) - x));
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(detail::tvec2<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec3<T, P> const & x)
 	{
-		return tvec2<T, P>(
-			noise1(x + tvec3<T, P>(0.0)),
-			noise1(tvec3<T, P>(0.0) - x));
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(detail::tvec3<T, P>(0.0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec2<T, P> noise2(tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec2<T, P> noise2(detail::tvec4<T, P> const & x)
 	{
-		return tvec2<T, P>(
-			noise1(x + tvec4<T, P>(0)),
-			noise1(tvec4<T, P>(0) - x));
+		return detail::tvec2<T, P>(
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(detail::tvec4<T, P>(0) - x));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec2<T, P> const & x)
 	{
-		return tvec3<T, P>(
-			noise1(x - tvec2<T, P>(1.0)),
-			noise1(x + tvec2<T, P>(0.0)),
-			noise1(x + tvec2<T, P>(1.0)));
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec2<T, P>(1.0)),
+			noise1(x + detail::tvec2<T, P>(0.0)),
+			noise1(x + detail::tvec2<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec3<T, P> const & x)
 	{
-		return tvec3<T, P>(
-			noise1(x - tvec3<T, P>(1.0)),
-			noise1(x + tvec3<T, P>(0.0)),
-			noise1(x + tvec3<T, P>(1.0)));
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec3<T, P>(1.0)),
+			noise1(x + detail::tvec3<T, P>(0.0)),
+			noise1(x + detail::tvec3<T, P>(1.0)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> noise3(tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec3<T, P> noise3(detail::tvec4<T, P> const & x)
 	{
-		return tvec3<T, P>(
-			noise1(x - tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(0)),
-			noise1(x + tvec4<T, P>(1)));
+		return detail::tvec3<T, P>(
+			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + detail::tvec4<T, P>(1)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec2<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec2<T, P> const & x)
 	{
-		return tvec4<T, P>(
-			noise1(x - tvec2<T, P>(1)),
-			noise1(x + tvec2<T, P>(0)),
-			noise1(x + tvec2<T, P>(1)),
-			noise1(x + tvec2<T, P>(2)));
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec2<T, P>(1)),
+			noise1(x + detail::tvec2<T, P>(0)),
+			noise1(x + detail::tvec2<T, P>(1)),
+			noise1(x + detail::tvec2<T, P>(2)));
 	}
 
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec3<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec3<T, P> const & x)
 	{
-		return tvec4<T, P>(
-			noise1(x - tvec3<T, P>(1)),
-			noise1(x + tvec3<T, P>(0)),
-			noise1(x + tvec3<T, P>(1)),
-			noise1(x + tvec3<T, P>(2)));
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec3<T, P>(1)),
+			noise1(x + detail::tvec3<T, P>(0)),
+			noise1(x + detail::tvec3<T, P>(1)),
+			noise1(x + detail::tvec3<T, P>(2)));
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> noise4(tvec4<T, P> const & x)
+	GLM_FUNC_QUALIFIER detail::tvec4<T, P> noise4(detail::tvec4<T, P> const & x)
 	{
-		return tvec4<T, P>(
-			noise1(x - tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(0)),
-			noise1(x + tvec4<T, P>(1)),
-			noise1(x + tvec4<T, P>(2)));
+		return detail::tvec4<T, P>(
+			noise1(x - detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(0)),
+			noise1(x + detail::tvec4<T, P>(1)),
+			noise1(x + detail::tvec4<T, P>(2)));
 	}
 	
 }//namespace glm

common/glm/glm/detail/func_packing.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -25,12 +21,11 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_packing.hpp
+/// @file glm/core/func_packing.hpp
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///
 /// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-/// @see gtc_packing
 /// 
 /// @defgroup core_func_packing Floating-Point Pack and Unpack Functions
 /// @ingroup core
@@ -38,7 +33,8 @@
 /// These functions do not operate component-wise, rather as described in each case.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef GLM_CORE_func_packing
+#define GLM_CORE_func_packing
 
 #include "type_vec2.hpp"
 #include "type_vec4.hpp"
@@ -195,3 +191,5 @@ namespace glm
 }//namespace glm
 
 #include "func_packing.inl"
+
+#endif//GLM_CORE_func_packing

common/glm/glm/detail/func_packing.inl

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

common/glm/glm/detail/func_trigonometric.hpp

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

common/glm/glm/detail/func_trigonometric.inl

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

common/glm/glm/detail/func_vector_relational.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_vector_relational.hpp
+/// @file glm/core/func_vector_relational.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///
@@ -42,11 +38,14 @@
 /// call must match.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef GLM_CORE_func_vector_relational
+#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
@@ -58,8 +57,9 @@ 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>
-	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);
+	// TODO: Mismatched 
+	//template <typename T, precision P, template <typename, precision> class vecType>
+	//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 vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type 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 vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type 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 vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns the component-wise comparison of result x == y.
 	///
@@ -94,8 +94,9 @@ 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>
-	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);
+	//TODO: conflicts with definision
+	//template <typename T, precision P, template <typename, precision> class vecType>
+	//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.
 	/// 
@@ -104,7 +105,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 vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
+	GLM_FUNC_DECL typename vecType<T, P>::bool_type notEqual(vecType<T, P> const & x, vecType<T, P> const & y);
 
 	/// Returns true if any component of x is true.
 	///
@@ -137,4 +138,8 @@ 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,10 +12,6 @@
 /// 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
@@ -25,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/func_vector_relational.inl
+/// @file glm/core/func_vector_relational.inl
 /// @date 2008-08-03 / 2011-09-09
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -35,68 +31,100 @@
 namespace glm
 {
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type lessThan
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+			"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] < y[i];
 
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> lessThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type lessThanEqual
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+			"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] <= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThan(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type greaterThan
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+			"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] > y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> greaterThanEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type greaterThanEqual
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559 || std::numeric_limits<T>::is_integer,
+			"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] >= y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> equal(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type equal
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] == y[i];
 		return Result;
 	}
 
 	template <typename T, precision P, template <typename, precision> class vecType>
-	GLM_FUNC_QUALIFIER vecType<bool, P> notEqual(vecType<T, P> const & x, vecType<T, P> const & y)
+	GLM_FUNC_QUALIFIER typename vecType<T, P>::bool_type notEqual
+	(
+		vecType<T, P> const & x,
+		vecType<T, P> const & y
+	)
 	{
-		assert(detail::component_count(x) == detail::component_count(y));
+		assert(x.length() == y.length());
 
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(x); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < x.length(); ++i)
 			Result[i] = x[i] != y[i];
 		return Result;
 	}
@@ -105,7 +133,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool any(vecType<bool, P> const & v)
 	{
 		bool Result = false;
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		for(int i = 0; i < v.length(); ++i)
 			Result = Result || v[i];
 		return Result;
 	}
@@ -114,7 +142,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER bool all(vecType<bool, P> const & v)
 	{
 		bool Result = true;
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		for(int i = 0; i < v.length(); ++i)
 			Result = Result && v[i];
 		return Result;
 	}
@@ -122,8 +150,8 @@ namespace glm
 	template <precision P, template <typename, precision> class vecType>
 	GLM_FUNC_QUALIFIER vecType<bool, P> not_(vecType<bool, P> const & v)
 	{
-		vecType<bool, P> Result(uninitialize);
-		for(detail::component_count_t i = 0; i < detail::component_count(v); ++i)
+		typename vecType<bool, P>::bool_type Result(vecType<bool, P>::_null);
+		for(int i = 0; i < v.length(); ++i)
 			Result[i] = !v[i];
 		return Result;
 	}

common/glm/glm/detail/glm.cpp

@@ -12,10 +12,6 @@
 /// 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
@@ -34,9 +30,11 @@
 #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>;
@@ -45,6 +43,7 @@ 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>;
 
@@ -56,6 +55,7 @@ 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,9 +67,10 @@ 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>;
@@ -282,5 +283,6 @@ template struct tdualquat<float64, mediump>;
 template struct tdualquat<float32, highp>;
 template struct tdualquat<float64, highp>;
 
+}//namespace detail
 }//namespace glm
 

common/glm/glm/detail/hint.hpp

@@ -12,10 +12,6 @@
 /// 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
@@ -25,17 +21,20 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/type_tvec4_avx.inl
-/// @date 2014-12-01 / 2014-12-01
+/// @file glm/core/hint.hpp
+/// @date 2008-08-14 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace detail
+#ifndef glm_core_type
+#define glm_core_type
+
+namespace glm
 {
-
-}//namespace detail
-
-	
-
+	// Use dont_care, nicest and fastest to optimize implementations.
+	class dont_care {};
+	class nicest {};
+	class fastest {};
 }//namespace glm
+
+#endif//glm_core_type

common/glm/glm/detail/intrinsic_common.hpp

@@ -21,12 +21,13 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/intrinsic_common.hpp
+/// @file glm/core/intrinsic_common.hpp
 /// @date 2009-05-11 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_detail_intrinsic_common
+#define glm_detail_intrinsic_common
 
 #include "setup.hpp"
 
@@ -85,3 +86,4 @@ 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/detail/intrinsic_common.inl
+/// @file glm/core/intrinsic_common.inl
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_exponential.hpp

@@ -21,12 +21,13 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/intrinsic_exponential.hpp
+/// @file glm/core/intrinsic_exponential.hpp
 /// @date 2009-05-11 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_detail_intrinsic_exponential
+#define glm_detail_intrinsic_exponential
 
 #include "setup.hpp"
 
@@ -75,3 +76,4 @@ 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/detail/intrinsic_exponential.inl
+/// @file glm/core/intrinsic_exponential.inl
 /// @date 2011-06-15 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

common/glm/glm/detail/intrinsic_geometric.hpp

@@ -21,12 +21,13 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/detail/intrinsic_geometric.hpp
+/// @file glm/core/intrinsic_geometric.hpp
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#pragma once
+#ifndef glm_core_intrinsic_geometric
+#define glm_core_intrinsic_geometric
 
 #include "setup.hpp"
 
@@ -72,3 +73,4 @@ 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/detail/intrinsic_geometric.inl
+/// @file glm/core/intrinsic_geometric.inl
 /// @date 2009-05-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
@@ -32,33 +32,32 @@ 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);
-	return len0;
+    __m128 len0 = sse_len_ps(sub0);
+    return len0;
 }
 
 //dot
 GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
 {
-
-#	if(GLM_ARCH & GLM_ARCH_AVX)
-		return _mm_dp_ps(v1, v2, 0xff);
-#	else
-		__m128 mul0 = _mm_mul_ps(v1, v2);
-		__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
-		__m128 add0 = _mm_add_ps(mul0, swp0);
-		__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
-		__m128 add1 = _mm_add_ps(add0, swp1);
-		return add1;
-#	endif
+#   if((GLM_ARCH & GLM_ARCH_AVX) == GLM_ARCH_AVX)
+        return _mm_dp_ps(v1, v2, 0xff);
+#   else
+        __m128 mul0 = _mm_mul_ps(v1, v2);
+        __m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+        __m128 add0 = _mm_add_ps(mul0, swp0);
+        __m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+        __m128 add1 = _mm_add_ps(add0, swp1);
+        return add1;
+#   endif
 }
 
 // SSE1