Merge branch 'master' into reflection-mapping

src/Nazara/Audio/Music.cpp

@@ -3,7 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Audio/Music.hpp>
-#include <Nazara/Audio/Audio.hpp>
 #include <Nazara/Audio/OpenAL.hpp>
 #include <Nazara/Audio/SoundStream.hpp>
 #include <Nazara/Core/Mutex.hpp>

src/Nazara/Audio/Sound.cpp

@@ -3,13 +3,9 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Audio/Sound.hpp>
-#include <Nazara/Audio/Audio.hpp>
 #include <Nazara/Audio/Config.hpp>
 #include <Nazara/Audio/OpenAL.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <cstring>
-#include <memory>
-#include <stdexcept>
 #include <Nazara/Audio/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/AbstractHash.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Core/AbstractHash.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Hash/CRC32.hpp>
+#include <Nazara/Core/Hash/CRC64.hpp>
 #include <Nazara/Core/Hash/Fletcher16.hpp>
 #include <Nazara/Core/Hash/MD5.hpp>
 #include <Nazara/Core/Hash/SHA1.hpp>
@@ -48,6 +49,9 @@ namespace Nz
 			case HashType_CRC32:
 				return std::make_unique<HashCRC32>();
 
+			case HashType_CRC64:
+				return std::make_unique<HashCRC64>();
+
 			case HashType_MD5:
 				return std::make_unique<HashMD5>();
 

src/Nazara/Core/ByteArray.cpp

@@ -3,8 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/ByteArray.hpp>
-#include <Nazara/Core/AbstractHash.hpp>
-#include <ostream>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/ByteStream.cpp

@@ -6,7 +6,6 @@
 #include <Nazara/Core/MemoryStream.hpp>
 #include <Nazara/Core/MemoryView.hpp>
 #include <algorithm>
-#include <cstring>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Clock.cpp

@@ -3,7 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Clock.hpp>
-#include <Nazara/Core/Error.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Core/Win32/ClockImpl.hpp>

src/Nazara/Core/ConditionVariable.cpp

@@ -102,18 +102,4 @@ namespace Nz
 		NazaraAssert(mutex != nullptr, "Mutex must be valid");
 		return m_impl->Wait(mutex->m_impl, timeout);
 	}
-
-	/*!
-	* \brief Moves a condition to another ConditionVariable object
-	* \return A reference to the object
-	*/
-	ConditionVariable& ConditionVariable::operator=(ConditionVariable&& condition) noexcept
-	{
-		delete m_impl;
-
-		m_impl = condition.m_impl;
-		condition.m_impl = nullptr;
-
-		return *this;
-	}
 }

src/Nazara/Core/Core.cpp

@@ -4,7 +4,6 @@
 
 #include <Nazara/Core/Core.hpp>
 #include <Nazara/Core/Config.hpp>
-#include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/HardwareInfo.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Core/PluginManager.hpp>

src/Nazara/Core/DynLib.cpp

@@ -40,19 +40,6 @@ namespace Nz
 	{
 	}
 
-	/*!
-	* \brief Constructs a DynLib object by move semantic
-	*
-	* \param lib DynLib to move into this
-	*/
-
-	DynLib::DynLib(DynLib&& lib) :
-	m_lastError(std::move(lib.m_lastError)),
-	m_impl(lib.m_impl)
-	{
-		lib.m_impl = nullptr;
-	}
-
 	/*!
 	* \brief Destructs the object and calls Unload
 	*
@@ -150,23 +137,4 @@ namespace Nz
 			m_impl = nullptr;
 		}
 	}
-
-	/*!
-	* \brief Moves the other lib into this
-	* \return A reference to this
-	*
-	* \param lib DynLib to move in this
-	*/
-
-	DynLib& DynLib::operator=(DynLib&& lib)
-	{
-		Unload();
-
-		m_impl = lib.m_impl;
-		m_lastError = std::move(lib.m_lastError);
-
-		lib.m_impl = nullptr;
-
-		return *this;
-	}
 }

src/Nazara/Core/File.cpp

@@ -5,12 +5,11 @@
 #include <Nazara/Core/File.hpp>
 #include <Nazara/Core/AbstractHash.hpp>
 #include <Nazara/Core/Config.hpp>
+#include <Nazara/Core/Directory.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/StringStream.hpp>
-#include <cstring>
 #include <memory>
-#include <utility>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Core/Win32/FileImpl.hpp>
@@ -70,20 +69,6 @@ namespace Nz
 		Open(filePath, openMode);
 	}
 
-	/*!
-	* \brief Constructs a File object by move semantic
-	*
-	* \param file File to move into this
-	*/
-
-	File::File(File&& file) noexcept :
-	Stream(std::move(file)),
-	m_filePath(std::move(file.m_filePath)),
-	m_impl(file.m_impl)
-	{
-		file.m_impl = nullptr;
-	}
-
 	/*!
 	* \brief Destructs the object and calls Close
 	*
@@ -487,23 +472,6 @@ namespace Nz
 		return *this;
 	}
 
-	/*!
-	* \brief Moves the other file into this
-	* \return A reference to this
-	*
-	* \param file File to move in this
-	*/
-
-	File& File::operator=(File&& file) noexcept
-	{
-		NazaraLock(m_mutex)
-
-		std::swap(m_filePath, file.m_filePath);
-		std::swap(m_impl, file.m_impl);
-
-		return *this;
-	}
-
 	/*!
 	* \brief Gets the absolute path of the file
 	* \return Absolute path of the file

src/Nazara/Core/GuillotineBinPack.cpp

@@ -9,8 +9,6 @@
 #include <Nazara/Core/GuillotineBinPack.hpp>
 #include <Nazara/Core/Config.hpp>
 #include <algorithm>
-#include <cstdlib>
-#include <cmath>
 #include <limits>
 #include <Nazara/Core/Debug.hpp>
 

src/Nazara/Core/HardwareInfo.cpp

@@ -5,7 +5,6 @@
 #include <Nazara/Core/HardwareInfo.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <algorithm>
-#include <cstdlib>
 #include <cstring>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)

src/Nazara/Core/Hash/CRC64.cpp

@@ -0,0 +1,115 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/Hash/CRC64.hpp>
+#include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/Debug.hpp>
+
+namespace Nz
+{
+	struct HashCRC64_state
+	{
+		UInt64 crc;
+	};
+
+	namespace
+	{
+		static const UInt64 crc64_table[256] = {
+			0x0000000000000000ULL, 0x7ad870c830358979ULL, 0xf5b0e190606b12f2ULL, 0x8f689158505e9b8bULL,
+			0xc038e5739841b68fULL, 0xbae095bba8743ff6ULL, 0x358804e3f82aa47dULL, 0x4f50742bc81f2d04ULL,
+			0xab28ecb46814fe75ULL, 0xd1f09c7c5821770cULL, 0x5e980d24087fec87ULL, 0x24407dec384a65feULL,
+			0x6b1009c7f05548faULL, 0x11c8790fc060c183ULL, 0x9ea0e857903e5a08ULL, 0xe478989fa00bd371ULL,
+			0x7d08ff3b88be6f81ULL, 0x07d08ff3b88be6f8ULL, 0x88b81eabe8d57d73ULL, 0xf2606e63d8e0f40aULL,
+			0xbd301a4810ffd90eULL, 0xc7e86a8020ca5077ULL, 0x4880fbd87094cbfcULL, 0x32588b1040a14285ULL,
+			0xd620138fe0aa91f4ULL, 0xacf86347d09f188dULL, 0x2390f21f80c18306ULL, 0x594882d7b0f40a7fULL,
+			0x1618f6fc78eb277bULL, 0x6cc0863448deae02ULL, 0xe3a8176c18803589ULL, 0x997067a428b5bcf0ULL,
+			0xfa11fe77117cdf02ULL, 0x80c98ebf2149567bULL, 0x0fa11fe77117cdf0ULL, 0x75796f2f41224489ULL,
+			0x3a291b04893d698dULL, 0x40f16bccb908e0f4ULL, 0xcf99fa94e9567b7fULL, 0xb5418a5cd963f206ULL,
+			0x513912c379682177ULL, 0x2be1620b495da80eULL, 0xa489f35319033385ULL, 0xde51839b2936bafcULL,
+			0x9101f7b0e12997f8ULL, 0xebd98778d11c1e81ULL, 0x64b116208142850aULL, 0x1e6966e8b1770c73ULL,
+			0x8719014c99c2b083ULL, 0xfdc17184a9f739faULL, 0x72a9e0dcf9a9a271ULL, 0x08719014c99c2b08ULL,
+			0x4721e43f0183060cULL, 0x3df994f731b68f75ULL, 0xb29105af61e814feULL, 0xc849756751dd9d87ULL,
+			0x2c31edf8f1d64ef6ULL, 0x56e99d30c1e3c78fULL, 0xd9810c6891bd5c04ULL, 0xa3597ca0a188d57dULL,
+			0xec09088b6997f879ULL, 0x96d1784359a27100ULL, 0x19b9e91b09fcea8bULL, 0x636199d339c963f2ULL,
+			0xdf7adabd7a6e2d6fULL, 0xa5a2aa754a5ba416ULL, 0x2aca3b2d1a053f9dULL, 0x50124be52a30b6e4ULL,
+			0x1f423fcee22f9be0ULL, 0x659a4f06d21a1299ULL, 0xeaf2de5e82448912ULL, 0x902aae96b271006bULL,
+			0x74523609127ad31aULL, 0x0e8a46c1224f5a63ULL, 0x81e2d7997211c1e8ULL, 0xfb3aa75142244891ULL,
+			0xb46ad37a8a3b6595ULL, 0xceb2a3b2ba0eececULL, 0x41da32eaea507767ULL, 0x3b024222da65fe1eULL,
+			0xa2722586f2d042eeULL, 0xd8aa554ec2e5cb97ULL, 0x57c2c41692bb501cULL, 0x2d1ab4dea28ed965ULL,
+			0x624ac0f56a91f461ULL, 0x1892b03d5aa47d18ULL, 0x97fa21650afae693ULL, 0xed2251ad3acf6feaULL,
+			0x095ac9329ac4bc9bULL, 0x7382b9faaaf135e2ULL, 0xfcea28a2faafae69ULL, 0x8632586aca9a2710ULL,
+			0xc9622c4102850a14ULL, 0xb3ba5c8932b0836dULL, 0x3cd2cdd162ee18e6ULL, 0x460abd1952db919fULL,
+			0x256b24ca6b12f26dULL, 0x5fb354025b277b14ULL, 0xd0dbc55a0b79e09fULL, 0xaa03b5923b4c69e6ULL,
+			0xe553c1b9f35344e2ULL, 0x9f8bb171c366cd9bULL, 0x10e3202993385610ULL, 0x6a3b50e1a30ddf69ULL,
+			0x8e43c87e03060c18ULL, 0xf49bb8b633338561ULL, 0x7bf329ee636d1eeaULL, 0x012b592653589793ULL,
+			0x4e7b2d0d9b47ba97ULL, 0x34a35dc5ab7233eeULL, 0xbbcbcc9dfb2ca865ULL, 0xc113bc55cb19211cULL,
+			0x5863dbf1e3ac9decULL, 0x22bbab39d3991495ULL, 0xadd33a6183c78f1eULL, 0xd70b4aa9b3f20667ULL,
+			0x985b3e827bed2b63ULL, 0xe2834e4a4bd8a21aULL, 0x6debdf121b863991ULL, 0x1733afda2bb3b0e8ULL,
+			0xf34b37458bb86399ULL, 0x8993478dbb8deae0ULL, 0x06fbd6d5ebd3716bULL, 0x7c23a61ddbe6f812ULL,
+			0x3373d23613f9d516ULL, 0x49aba2fe23cc5c6fULL, 0xc6c333a67392c7e4ULL, 0xbc1b436e43a74e9dULL,
+			0x95ac9329ac4bc9b5ULL, 0xef74e3e19c7e40ccULL, 0x601c72b9cc20db47ULL, 0x1ac40271fc15523eULL,
+			0x5594765a340a7f3aULL, 0x2f4c0692043ff643ULL, 0xa02497ca54616dc8ULL, 0xdafce7026454e4b1ULL,
+			0x3e847f9dc45f37c0ULL, 0x445c0f55f46abeb9ULL, 0xcb349e0da4342532ULL, 0xb1eceec59401ac4bULL,
+			0xfebc9aee5c1e814fULL, 0x8464ea266c2b0836ULL, 0x0b0c7b7e3c7593bdULL, 0x71d40bb60c401ac4ULL,
+			0xe8a46c1224f5a634ULL, 0x927c1cda14c02f4dULL, 0x1d148d82449eb4c6ULL, 0x67ccfd4a74ab3dbfULL,
+			0x289c8961bcb410bbULL, 0x5244f9a98c8199c2ULL, 0xdd2c68f1dcdf0249ULL, 0xa7f41839ecea8b30ULL,
+			0x438c80a64ce15841ULL, 0x3954f06e7cd4d138ULL, 0xb63c61362c8a4ab3ULL, 0xcce411fe1cbfc3caULL,
+			0x83b465d5d4a0eeceULL, 0xf96c151de49567b7ULL, 0x76048445b4cbfc3cULL, 0x0cdcf48d84fe7545ULL,
+			0x6fbd6d5ebd3716b7ULL, 0x15651d968d029fceULL, 0x9a0d8ccedd5c0445ULL, 0xe0d5fc06ed698d3cULL,
+			0xaf85882d2576a038ULL, 0xd55df8e515432941ULL, 0x5a3569bd451db2caULL, 0x20ed197575283bb3ULL,
+			0xc49581ead523e8c2ULL, 0xbe4df122e51661bbULL, 0x3125607ab548fa30ULL, 0x4bfd10b2857d7349ULL,
+			0x04ad64994d625e4dULL, 0x7e7514517d57d734ULL, 0xf11d85092d094cbfULL, 0x8bc5f5c11d3cc5c6ULL,
+			0x12b5926535897936ULL, 0x686de2ad05bcf04fULL, 0xe70573f555e26bc4ULL, 0x9ddd033d65d7e2bdULL,
+			0xd28d7716adc8cfb9ULL, 0xa85507de9dfd46c0ULL, 0x273d9686cda3dd4bULL, 0x5de5e64efd965432ULL,
+			0xb99d7ed15d9d8743ULL, 0xc3450e196da80e3aULL, 0x4c2d9f413df695b1ULL, 0x36f5ef890dc31cc8ULL,
+			0x79a59ba2c5dc31ccULL, 0x037deb6af5e9b8b5ULL, 0x8c157a32a5b7233eULL, 0xf6cd0afa9582aa47ULL,
+			0x4ad64994d625e4daULL, 0x300e395ce6106da3ULL, 0xbf66a804b64ef628ULL, 0xc5bed8cc867b7f51ULL,
+			0x8aeeace74e645255ULL, 0xf036dc2f7e51db2cULL, 0x7f5e4d772e0f40a7ULL, 0x05863dbf1e3ac9deULL,
+			0xe1fea520be311aafULL, 0x9b26d5e88e0493d6ULL, 0x144e44b0de5a085dULL, 0x6e963478ee6f8124ULL,
+			0x21c640532670ac20ULL, 0x5b1e309b16452559ULL, 0xd476a1c3461bbed2ULL, 0xaeaed10b762e37abULL,
+			0x37deb6af5e9b8b5bULL, 0x4d06c6676eae0222ULL, 0xc26e573f3ef099a9ULL, 0xb8b627f70ec510d0ULL,
+			0xf7e653dcc6da3dd4ULL, 0x8d3e2314f6efb4adULL, 0x0256b24ca6b12f26ULL, 0x788ec2849684a65fULL,
+			0x9cf65a1b368f752eULL, 0xe62e2ad306bafc57ULL, 0x6946bb8b56e467dcULL, 0x139ecb4366d1eea5ULL,
+			0x5ccebf68aecec3a1ULL, 0x2616cfa09efb4ad8ULL, 0xa97e5ef8cea5d153ULL, 0xd3a62e30fe90582aULL,
+			0xb0c7b7e3c7593bd8ULL, 0xca1fc72bf76cb2a1ULL, 0x45775673a732292aULL, 0x3faf26bb9707a053ULL,
+			0x70ff52905f188d57ULL, 0x0a2722586f2d042eULL, 0x854fb3003f739fa5ULL, 0xff97c3c80f4616dcULL,
+			0x1bef5b57af4dc5adULL, 0x61372b9f9f784cd4ULL, 0xee5fbac7cf26d75fULL, 0x9487ca0fff135e26ULL,
+			0xdbd7be24370c7322ULL, 0xa10fceec0739fa5bULL, 0x2e675fb4576761d0ULL, 0x54bf2f7c6752e8a9ULL,
+			0xcdcf48d84fe75459ULL, 0xb71738107fd2dd20ULL, 0x387fa9482f8c46abULL, 0x42a7d9801fb9cfd2ULL,
+			0x0df7adabd7a6e2d6ULL, 0x772fdd63e7936bafULL, 0xf8474c3bb7cdf024ULL, 0x829f3cf387f8795dULL,
+			0x66e7a46c27f3aa2cULL, 0x1c3fd4a417c62355ULL, 0x935745fc4798b8deULL, 0xe98f353477ad31a7ULL,
+			0xa6df411fbfb21ca3ULL, 0xdc0731d78f8795daULL, 0x536fa08fdfd90e51ULL, 0x29b7d047efec8728ULL
+		};
+	}
+
+	void HashCRC64::Append(const UInt8* data, std::size_t len)
+	{
+		while (len--)
+			m_crc = crc64_table[(m_crc ^ *data++) & 0xFF] ^ (m_crc >> 8);
+	}
+
+	void HashCRC64::Begin()
+	{
+		m_crc = 0;
+	}
+
+	ByteArray HashCRC64::End()
+	{
+		#ifdef NAZARA_LITTLE_ENDIAN
+		SwapBytes(&m_crc, sizeof(UInt64));
+		#endif
+
+		return ByteArray(reinterpret_cast<UInt8*>(&m_crc), 8);
+	}
+
+	std::size_t HashCRC64::GetDigestLength() const
+	{
+		return 8;
+	}
+
+	const char* HashCRC64::GetHashName() const
+	{
+		return "CRC64";
+	}
+}

src/Nazara/Core/MemoryManager.cpp

@@ -5,9 +5,9 @@
 #include <Nazara/Core/MemoryManager.hpp>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <ctime>
 #include <new>
-#include <stdexcept>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <windows.h>

src/Nazara/Core/Mutex.cpp

@@ -77,18 +77,4 @@ namespace Nz
 		NazaraAssert(m_impl, "Cannot unlock a moved mutex");
 		m_impl->Unlock();
 	}
-
-	/*!
-	* \brief Moves a mutex to another mutex object
-	* \return A reference to the object
-	*/
-	Mutex& Mutex::operator=(Mutex&& mutex) noexcept
-	{
-		delete m_impl;
-
-		m_impl = mutex.m_impl;
-		mutex.m_impl = nullptr;
-
-		return *this;
-	}
 }

src/Nazara/Core/ParameterList.cpp

@@ -7,8 +7,6 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/MemoryHelper.hpp>
 #include <cstring>
-#include <limits>
-#include <new>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Posix/ClockImpl.cpp

@@ -3,8 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Posix/ClockImpl.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <ctime>
 #include <sys/time.h>
 #include <Nazara/Core/Debug.hpp>
 

src/Nazara/Core/Posix/ConditionVariableImpl.cpp

@@ -4,6 +4,8 @@
 
 #include <Nazara/Core/Posix/ConditionVariableImpl.hpp>
 #include <Nazara/Core/Posix/MutexImpl.hpp>
+#include <sys/time.h>
+#include <time.h>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Posix/ConditionVariableImpl.hpp

@@ -11,8 +11,6 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <pthread.h>
-#include <unistd.h>
-#include <sys/time.h>
 
 namespace Nz
 {

src/Nazara/Core/Posix/DirectoryImpl.cpp

@@ -4,10 +4,12 @@
 
 #include <Nazara/Core/Posix/DirectoryImpl.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/Debug.hpp>
-
+#include <Nazara/Core/String.hpp>
 #include <errno.h>
 #include <sys/param.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <Nazara/Core/Debug.hpp>
 
 namespace Nz
 {

src/Nazara/Core/Posix/DirectoryImpl.hpp

@@ -9,9 +9,6 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <dirent.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 
 namespace Nz
 {

src/Nazara/Core/Posix/DynLibImpl.cpp

@@ -4,8 +4,8 @@
 
 #include <Nazara/Core/Posix/DynLibImpl.hpp>
 #include <Nazara/Core/DynLib.hpp>
-#include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/String.hpp>
+#include <dlfcn.h>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Posix/DynLibImpl.hpp

@@ -8,7 +8,6 @@
 #define NAZARA_DYNLIBIMPL_HPP
 
 #include <Nazara/Core/DynLib.hpp>
-#include <dlfcn.h>
 
 namespace Nz
 {

src/Nazara/Core/Posix/FileImpl.cpp

@@ -4,6 +4,9 @@
 
 #include <Nazara/Core/Posix/FileImpl.hpp>
 #include <Nazara/Core/Error.hpp>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
 #include <cstdio>
 #include <Nazara/Core/Debug.hpp>
 
@@ -72,11 +75,47 @@ namespace Nz
 		if (mode & OpenMode_Truncate)
 			flags |= O_TRUNC;
 
-		///TODO: lock
-		//if ((mode & OpenMode_Lock) == 0)
-		//	shareMode |= FILE_SHARE_WRITE;
-
 		m_fileDescriptor = open64(filePath.GetConstBuffer(), flags, permissions);
+
+		static struct flock lock;
+
+		auto initialize_flock = [](struct flock& fileLock)
+		{
+			fileLock.l_type = F_WRLCK;
+			fileLock.l_start = 0;
+			fileLock.l_whence = SEEK_SET;
+			fileLock.l_len = 0;
+			fileLock.l_pid = getpid();
+		};
+
+		initialize_flock(lock);
+
+		if (fcntl(m_fileDescriptor, F_GETLK, &lock) == -1)
+		{
+			Close();
+			NazaraError("Unable to detect presence of lock on the file");
+			return false;
+		}
+
+		if (lock.l_type != F_UNLCK)
+		{
+			Close();
+			NazaraError("A lock is present on the file");
+			return false;
+		}
+
+		if (mode & OpenMode_Lock)
+		{
+			initialize_flock(lock);
+
+			if (fcntl(m_fileDescriptor, F_SETLK, &lock) == -1)  
+			{
+				Close();
+				NazaraError("Unable to place a lock on the file");
+				return false;
+			}
+		}
+
 		return m_fileDescriptor != -1;
 	}
 
@@ -128,10 +167,7 @@ namespace Nz
 
 	std::size_t FileImpl::Write(const void* buffer, std::size_t size)
 	{
-		lockf64(m_fileDescriptor, F_LOCK, size);
 		ssize_t written = write(m_fileDescriptor, buffer, size);
-		lockf64(m_fileDescriptor, F_ULOCK, size);
-
 		m_endOfFileUpdated = false;
 
 		return written;

src/Nazara/Core/Posix/FileImpl.hpp

@@ -12,12 +12,8 @@
 #endif
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/File.hpp>
+#include <Nazara/Core/Enums.hpp>
 #include <ctime>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
 
 namespace Nz
 {

src/Nazara/Core/Posix/HardwareInfoImpl.cpp

@@ -3,7 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Posix/HardwareInfoImpl.hpp>
-#include <Nazara/Core/Error.hpp>
+#include <unistd.h>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Posix/HardwareInfoImpl.hpp

@@ -8,7 +8,6 @@
 #define NAZARA_HARDWAREINFOIMPL_POSIX_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <unistd.h>
 
 namespace Nz
 {

src/Nazara/Core/Posix/SemaphoreImpl.cpp

@@ -3,9 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Posix/SemaphoreImpl.hpp>
-#include <Nazara/Core/Config.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <limits>
+#include <time.h>
 #include <sys/time.h>
 #include <Nazara/Core/Debug.hpp>
 

src/Nazara/Core/Posix/TaskSchedulerImpl.cpp

@@ -3,8 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Posix/TaskSchedulerImpl.hpp>
-#include <Nazara/Core/Config.hpp>
-#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Functor.hpp>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/Posix/TaskSchedulerImpl.hpp

@@ -8,7 +8,6 @@
 #define NAZARA_TASKSCHEDULERIMPL_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Functor.hpp>
 #include <atomic>
 #include <memory>
 #include <pthread.h>
@@ -16,6 +15,8 @@
 
 namespace Nz
 {
+	struct Functor;
+
 	class TaskSchedulerImpl
 	{
 		public:

src/Nazara/Core/Posix/ThreadImpl.cpp

@@ -5,8 +5,10 @@
 #include <Nazara/Core/Posix/ThreadImpl.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Functor.hpp>
-#include <unistd.h>
-#include <sys/time.h>
+#include <Nazara/Core/String.hpp>
+#include <errno.h>
+#include <sched.h>
+#include <time.h>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz
@@ -28,6 +30,43 @@ namespace Nz
 		pthread_join(m_handle, nullptr);
 	}
 
+	void ThreadImpl::SetName(const Nz::String& name)
+	{
+#ifdef __GNUC__
+		pthread_setname_np(m_handle, name.GetConstBuffer());
+#else
+		NazaraWarning("Setting thread name is not supported on this platform");
+#endif
+	}
+
+	void ThreadImpl::SetCurrentName(const Nz::String& name)
+	{
+#ifdef __GNUC__
+		pthread_setname_np(pthread_self(), name.GetConstBuffer());
+#else
+		NazaraWarning("Setting current thread name is not supported on this platform");
+#endif
+	}
+
+	void ThreadImpl::Sleep(UInt32 time)
+	{
+		if (time == 0)
+			sched_yield();
+		else
+		{
+			struct timespec ts;
+			ts.tv_sec = time / 1000;
+			ts.tv_nsec = (time - ts.tv_sec * 1000) * 1'000'000;
+
+			int r;
+			do
+			{
+				r = nanosleep(&ts, &ts);
+			}
+			while (r == -1 && errno == EINTR);
+		}
+	}
+
 	void* ThreadImpl::ThreadProc(void* userdata)
 	{
 		Functor* func = static_cast<Functor*>(userdata);
@@ -36,40 +75,4 @@ namespace Nz
 
 		return nullptr;
 	}
-
-	void ThreadImpl::Sleep(UInt32 time)
-	{
-		// code from SFML2 Unix SleepImpl.cpp source https://github.com/LaurentGomila/SFML/blob/master/src/SFML/System/Unix/SleepImpl.cpp
-
-		// usleep is not reliable enough (it might block the
-		// whole process instead of just the current thread)
-		// so we must use pthread_cond_timedwait instead
-
-		// this implementation is inspired from Qt
-
-		// get the current time
-		timeval tv;
-		gettimeofday(&tv, nullptr);
-
-		// construct the time limit (current time + time to wait)
-		timespec ti;
-		ti.tv_nsec = (tv.tv_usec + (time % 1000)) * 1000;
-		ti.tv_sec = tv.tv_sec + (time / 1000) + (ti.tv_nsec / 1000000000);
-		ti.tv_nsec %= 1000000000;
-
-		// create a mutex and thread condition
-		pthread_mutex_t mutex;
-		pthread_mutex_init(&mutex, nullptr);
-		pthread_cond_t condition;
-		pthread_cond_init(&condition, nullptr);
-
-		// wait...
-		pthread_mutex_lock(&mutex);
-		pthread_cond_timedwait(&condition, &mutex, &ti);
-		pthread_mutex_unlock(&mutex);
-
-		// destroy the mutex and condition
-		pthread_cond_destroy(&condition);
-		pthread_mutex_destroy(&mutex);
-	}
 }

src/Nazara/Core/Posix/ThreadImpl.hpp

@@ -8,11 +8,17 @@
 #define NAZARA_THREADIMPL_HPP
 
 #include <Nazara/Prerequesites.hpp>
+
+#if defined(__GNUC__) && !defined(_GNU_SOURCE)
+#define _GNU_SOURCE
+#endif
+
 #include <pthread.h>
 
 namespace Nz
 {
 	struct Functor;
+	class String;
 
 	class ThreadImpl
 	{
@@ -21,7 +27,9 @@ namespace Nz
 
 			void Detach();
 			void Join();
+			void SetName(const Nz::String& name);
 
+			static void SetCurrentName(const Nz::String& name);
 			static void Sleep(UInt32 time);
 
 		private:

src/Nazara/Core/RefCounted.cpp

@@ -5,13 +5,6 @@
 #include <Nazara/Core/RefCounted.hpp>
 #include <Nazara/Core/Config.hpp>
 #include <Nazara/Core/Error.hpp>
-
-#if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_REFCOUNTED
-	#include <Nazara/Core/ThreadSafety.hpp>
-#else
-	#include <Nazara/Core/ThreadSafetyOff.hpp>
-#endif
-
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

src/Nazara/Core/String.cpp

@@ -5975,20 +5975,7 @@ namespace std
 
 	istream& getline(istream& is, Nz::String& str)
 	{
-		str.Clear();
-
-		char c;
-
-		for (;;)
-                {
-			is.get(c);
-			if (c != '\n' && c != '\0')
-				str += c;
-			else
-				break;
-		}
-
-		return is;
+		return getline(is, str, is.widen('\n'));
 	}
 
 	/*!
@@ -6012,7 +5999,11 @@ namespace std
 			if (c != delim && c != '\0')
 				str += c;
 			else
+			{
+				if (c == '\0')
+					is.setstate(std::ios_base::eofbit);
 				break;
+			}
 		}
 
 		return is;

src/Nazara/Core/Thread.cpp

@@ -6,8 +6,7 @@
 #include <Nazara/Core/Config.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/HardwareInfo.hpp>
-#include <ostream>
-#include <stdexcept>
+#include <Nazara/Core/MovablePtr.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 	#include <Nazara/Core/Win32/ThreadImpl.hpp>
@@ -36,18 +35,6 @@ namespace Nz
 	{
 	}
 
-	/*!
-	* \brief Constructs a Thread<T> object by move semantic
-	*
-	* \param other Thread to move into this
-	*/
-
-	Thread::Thread(Thread&& other) noexcept :
-	m_impl(other.m_impl)
-	{
-		other.m_impl = nullptr;
-	}
-
 	/*!
 	* \brief Waits that the thread ends and then destroys this
 	*/
@@ -118,45 +105,57 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Moves the other thread into this
-	* \return A reference to this
+	* \brief Changes the debugging name associated to a thread
 	*
-	* \param thread Thread to move in this
+	* Changes the debugging name associated with a particular thread, and may helps with debugging tools.
 	*
-	* \remark Produce a NazaraError if no functor was assigned and NAZARA_CORE_SAFE is defined
-	* \remark And call std::terminate if no functor was assigned and NAZARA_CORE_SAFE is defined
+	* \param name The new name of the thread
+	*
+	* \remark Due to system limitations, thread name cannot exceed 15 characters (excluding null-terminator)
+	*
+	* \see SetCurrentThreadName
 	*/
-
-	Thread& Thread::operator=(Thread&& thread)
+	void Thread::SetName(const String& name)
 	{
-		#if NAZARA_CORE_SAFE
-		if (m_impl)
-		{
-			NazaraError("This thread cannot be joined");
-			std::terminate();
-		}
-		#endif
+		NazaraAssert(m_impl, "Invalid thread");
+		NazaraAssert(name.GetSize() < 16, "Thread name is too long");
 
-		std::swap(m_impl, thread.m_impl);
-		return *this;
+		m_impl->SetName(name);
 	}
 
 	/*!
 	* \brief Gets the number of simulatenous threads that can run on the same cpu
 	* \return The number of simulatenous threads
 	*/
-
 	unsigned int Thread::HardwareConcurrency()
 	{
 		return HardwareInfo::GetProcessorCount();
 	}
 
+
+	/*!
+	* \brief Changes the debugging name associated to the calling thread
+	*
+	* Changes the debugging name associated with the calling thread, and may helps with debugging tools.
+	*
+	* \param name The new name associated with this thread
+	*
+	* \remark Due to system limitations, thread name cannot exceed 15 characters (excluding null-terminator)
+	*
+	* \see SetName
+	*/
+	void Thread::SetCurrentThreadName(const String& name)
+	{
+		NazaraAssert(name.GetSize() < 16, "Thread name is too long");
+
+		ThreadImpl::SetCurrentName(name);
+	}
+
 	/*!
 	* \brief Makes sleep this thread
 	*
 	* \param milliseconds The number of milliseconds to sleep
 	*/
-
 	void Thread::Sleep(UInt32 milliseconds)
 	{
 		ThreadImpl::Sleep(milliseconds);

src/Nazara/Core/Win32/FileImpl.cpp

@@ -191,9 +191,7 @@ namespace Nz
 		LARGE_INTEGER cursorPos;
 		cursorPos.QuadPart = GetCursorPos();
 
-		LockFile(m_handle, cursorPos.LowPart, cursorPos.HighPart, static_cast<DWORD>(size), 0);
 		WriteFile(m_handle, buffer, static_cast<DWORD>(size), &written, nullptr);
-		UnlockFile(m_handle, cursorPos.LowPart, cursorPos.HighPart, static_cast<DWORD>(size), 0);
 
 		m_endOfFileUpdated = false;
 

src/Nazara/Core/Win32/ThreadImpl.cpp

@@ -6,15 +6,32 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Functor.hpp>
 #include <process.h>
+#include <windows.h>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz
 {
+	namespace
+	{
+#pragma pack(push,8)
+		struct THREADNAME_INFO
+		{
+			DWORD dwType;
+			LPCSTR szName;
+			DWORD dwThreadID;
+			DWORD dwFlags;
+		};
+#pragma pack(pop)
+	}
+
 	ThreadImpl::ThreadImpl(Functor* functor)
 	{
-		m_handle = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, &ThreadImpl::ThreadProc, functor, 0, nullptr));
+		unsigned int threadId;
+		m_handle = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0, &ThreadImpl::ThreadProc, functor, 0, &threadId));
 		if (!m_handle)
 			NazaraInternalError("Failed to create thread: " + Error::GetLastSystemError());
+
+		m_threadId = threadId;
 	}
 
 	void ThreadImpl::Detach()
@@ -29,6 +46,44 @@ namespace Nz
 		CloseHandle(m_handle);
 	}
 
+	void ThreadImpl::SetName(const Nz::String& name)
+	{
+		SetThreadName(m_threadId, name.GetConstBuffer());
+	}
+
+	void ThreadImpl::SetCurrentName(const Nz::String& name)
+	{
+		SetThreadName(::GetCurrentThreadId(), name.GetConstBuffer());
+	}
+
+	void ThreadImpl::Sleep(UInt32 time)
+	{
+		::Sleep(time);
+	}
+
+	void ThreadImpl::SetThreadName(DWORD threadId, const char* threadName)
+	{
+		// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
+		constexpr DWORD MS_VC_EXCEPTION = 0x406D1388;
+
+		THREADNAME_INFO info;
+		info.dwType = 0x1000;
+		info.szName = threadName;
+		info.dwThreadID = threadId;
+		info.dwFlags = 0;
+
+#pragma warning(push)
+#pragma warning(disable: 6320 6322)
+		__try
+		{
+			RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), reinterpret_cast<ULONG_PTR*>(&info));
+		}
+		__except (EXCEPTION_EXECUTE_HANDLER)
+		{
+		}
+#pragma warning(pop)
+	}
+
 	unsigned int __stdcall ThreadImpl::ThreadProc(void* userdata)
 	{
 		Functor* func = static_cast<Functor*>(userdata);
@@ -42,9 +97,4 @@ namespace Nz
 
 		return 0;
 	}
-
-	void ThreadImpl::Sleep(UInt32 time)
-	{
-		::Sleep(time);
-	}
 }

src/Nazara/Core/Win32/ThreadImpl.hpp

@@ -10,6 +10,7 @@
 #define NAZARA_THREADIMPL_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/String.hpp>
 #include <windows.h>
 
 namespace Nz
@@ -23,12 +24,16 @@ namespace Nz
 
 			void Detach();
 			void Join();
+			void SetName(const Nz::String& name);
 
+			static void SetCurrentName(const Nz::String& name);
 			static void Sleep(UInt32 time);
 
 		private:
+			static void SetThreadName(DWORD threadId, const char* threadName);
 			static unsigned int __stdcall ThreadProc(void* userdata);
 
+			DWORD m_threadId;
 			HANDLE m_handle;
 	};
 }

src/Nazara/Graphics/AbstractRenderTechnique.cpp

@@ -3,9 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/AbstractRenderTechnique.hpp>
-#include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/RenderTechniques.hpp>
-#include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/Billboard.cpp

@@ -4,10 +4,6 @@
 
 #include <Nazara/Graphics/Billboard.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Math/Algorithm.hpp>
-#include <cstring>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/ColorBackground.cpp

@@ -3,8 +3,10 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/ColorBackground.hpp>
+#include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <memory>
+#include <Nazara/Renderer/RenderStates.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredBloomPass.cpp

@@ -4,7 +4,6 @@
 
 #include <Nazara/Graphics/DeferredBloomPass.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredDOFPass.cpp

@@ -3,10 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/DeferredDOFPass.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredFXAAPass.cpp

@@ -5,7 +5,7 @@
 #include <Nazara/Graphics/DeferredFXAAPass.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <memory>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredFinalPass.cpp

@@ -3,9 +3,12 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/DeferredFinalPass.hpp>
+#include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <memory>
+#include <Nazara/Renderer/Shader.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredFogPass.cpp

@@ -4,9 +4,9 @@
 
 #include <Nazara/Graphics/DeferredFogPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredForwardPass.cpp

@@ -6,6 +6,7 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderTechnique.hpp>
 #include <Nazara/Renderer/Renderer.hpp>

src/Nazara/Graphics/DeferredGeometryPass.cpp

@@ -8,12 +8,9 @@
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <Nazara/Utility/BufferMapper.hpp>
-#include <Nazara/Utility/StaticMesh.hpp>
-#include <Nazara/Utility/VertexStruct.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredPhongLightingPass.cpp

@@ -3,12 +3,13 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/DeferredPhongLightingPass.hpp>
+#include <Nazara/Core/Primitive.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderQueue.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredRenderPass.cpp

@@ -3,8 +3,9 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
-#include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
+#include <Nazara/Graphics/DeferredRenderQueue.hpp>
+#include <Nazara/Math/Vector2.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DeferredRenderQueue.cpp

@@ -3,9 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/DeferredRenderQueue.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
-#include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 ///TODO: Render billboards using Deferred Shading if possible

src/Nazara/Graphics/DeferredRenderTechnique.cpp

@@ -8,7 +8,6 @@
 
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
-#include <Nazara/Graphics/AbstractBackground.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredBloomPass.hpp>
 #include <Nazara/Graphics/DeferredDOFPass.hpp>
@@ -18,18 +17,13 @@
 #include <Nazara/Graphics/DeferredFXAAPass.hpp>
 #include <Nazara/Graphics/DeferredGeometryPass.hpp>
 #include <Nazara/Graphics/DeferredPhongLightingPass.hpp>
-#include <Nazara/Graphics/Drawable.hpp>
-#include <Nazara/Graphics/Light.hpp>
-#include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/ShaderStage.hpp>
-#include <limits>
 #include <memory>
-#include <random>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DepthRenderQueue.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Graphics/DepthRenderQueue.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/DepthRenderTechnique.cpp

@@ -5,19 +5,14 @@
 #include <Nazara/Graphics/DepthRenderTechnique.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/OffsetOf.hpp>
-#include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/Drawable.hpp>
-#include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
-#include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/VertexStruct.hpp>
 #include <limits>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/Formats/MeshLoader.cpp

@@ -3,13 +3,11 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/Formats/MeshLoader.hpp>
-#include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/SkeletalModel.hpp>
 #include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Utility/Mesh.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/Formats/TextureLoader.cpp

@@ -5,7 +5,6 @@
 #include <Nazara/Graphics/Formats/TextureLoader.hpp>
 #include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Renderer/Texture.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/ForwardRenderQueue.cpp

@@ -4,7 +4,7 @@
 
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Utility/VertexStruct.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 ///TODO: Replace sinus/cosinus by a lookup table (which will lead to a speed up about 10x)
@@ -697,7 +697,7 @@ namespace Nz
 		auto it = layers.find(i);
 		if (it == layers.end())
 			it = layers.insert(std::make_pair(i, Layer())).first;
-		
+
 		Layer& layer = it->second;
 		layer.clearCount = 0;
 
@@ -729,7 +729,6 @@ namespace Nz
 	void ForwardRenderQueue::SortForOrthographic(const AbstractViewer * viewer)
 	{
 		Planef nearPlane = viewer->GetFrustum().GetPlane(FrustumPlane_Near);
-		Vector3f viewerPos = viewer->GetEyePosition();
 
 		for (auto& pair : layers)
 		{

src/Nazara/Graphics/ForwardRenderTechnique.cpp

@@ -10,14 +10,12 @@
 #include <Nazara/Graphics/Drawable.hpp>
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Sprite.hpp>
+#include <Nazara/Graphics/SceneData.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
-#include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/VertexStruct.hpp>
 #include <limits>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/Graphics.cpp

@@ -173,7 +173,7 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Uninitializes the Core module
+	* \brief Uninitializes the Graphics module
 	*
 	* \remark Produces a NazaraNotice
 	*/

src/Nazara/Graphics/GuillotineTextureAtlas.cpp

@@ -3,7 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
-#include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 

src/Nazara/Graphics/Light.cpp

@@ -8,9 +8,6 @@
 #include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Math/Sphere.hpp>
-#include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/Shader.hpp>
-#include <cstring>
 #include <Nazara/Graphics/Debug.hpp>
 
 ///TODO: Use of UBOs

src/Nazara/Graphics/Material.cpp

@@ -5,8 +5,7 @@
 #include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <cstring>
-#include <memory>
+#include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/ParticleDeclaration.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2017 Jérôme Leclercq
+// Copyright (C) 2017 Jérôme Leclercq
 // This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
@@ -10,7 +10,6 @@
 #include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Graphics/ParticleStruct.hpp>
 #include <Nazara/Utility/Utility.hpp>
-#include <cstring>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz
@@ -287,7 +286,7 @@ namespace Nz
 			// ParticleLayout_Billboard : ParticleStruct_Billboard
 			declaration = &s_declarations[ParticleLayout_Billboard];
 			declaration->EnableComponent(ParticleComponent_Color,    ComponentType_Color,  NazaraOffsetOf(ParticleStruct_Billboard, color));
-			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Int1,   NazaraOffsetOf(ParticleStruct_Billboard, life));
+			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Float1, NazaraOffsetOf(ParticleStruct_Billboard, life));
 			declaration->EnableComponent(ParticleComponent_Normal,   ComponentType_Float3, NazaraOffsetOf(ParticleStruct_Billboard, normal));
 			declaration->EnableComponent(ParticleComponent_Position, ComponentType_Float3, NazaraOffsetOf(ParticleStruct_Billboard, position));
 			declaration->EnableComponent(ParticleComponent_Rotation, ComponentType_Float1, NazaraOffsetOf(ParticleStruct_Billboard, rotation));
@@ -298,7 +297,7 @@ namespace Nz
 
 			// ParticleLayout_Model : ParticleStruct_Model
 			declaration = &s_declarations[ParticleLayout_Model];
-			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Int1,       NazaraOffsetOf(ParticleStruct_Model, life));
+			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Float1,     NazaraOffsetOf(ParticleStruct_Model, life));
 			declaration->EnableComponent(ParticleComponent_Position, ComponentType_Float3,     NazaraOffsetOf(ParticleStruct_Model, position));
 			declaration->EnableComponent(ParticleComponent_Rotation, ComponentType_Quaternion, NazaraOffsetOf(ParticleStruct_Model, rotation));
 			declaration->EnableComponent(ParticleComponent_Velocity, ComponentType_Float3,     NazaraOffsetOf(ParticleStruct_Model, velocity));
@@ -308,7 +307,7 @@ namespace Nz
 			// ParticleLayout_Sprite : ParticleStruct_Sprite
 			declaration = &s_declarations[ParticleLayout_Sprite];
 			declaration->EnableComponent(ParticleComponent_Color,    ComponentType_Color,  NazaraOffsetOf(ParticleStruct_Sprite, color));
-			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Int1,   NazaraOffsetOf(ParticleStruct_Sprite, life));
+			declaration->EnableComponent(ParticleComponent_Life,     ComponentType_Float1, NazaraOffsetOf(ParticleStruct_Sprite, life));
 			declaration->EnableComponent(ParticleComponent_Position, ComponentType_Float3, NazaraOffsetOf(ParticleStruct_Sprite, position));
 			declaration->EnableComponent(ParticleComponent_Rotation, ComponentType_Float1, NazaraOffsetOf(ParticleStruct_Sprite, rotation));
 			declaration->EnableComponent(ParticleComponent_Velocity, ComponentType_Float3, NazaraOffsetOf(ParticleStruct_Sprite, velocity));

src/Nazara/Graphics/ParticleEmitter.cpp

@@ -3,13 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/ParticleEmitter.hpp>
-#include <Nazara/Core/CallOnExit.hpp>
-#include <Nazara/Core/ErrorFlags.hpp>
-#include <Nazara/Core/StringStream.hpp>
 #include <Nazara/Graphics/ParticleMapper.hpp>
 #include <Nazara/Graphics/ParticleGroup.hpp>
-#include <cstdlib>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/ParticleGroup.cpp

@@ -7,8 +7,6 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/StringStream.hpp>
 #include <Nazara/Graphics/ParticleMapper.hpp>
-#include <cstdlib>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/ParticleMapper.cpp

@@ -3,7 +3,6 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/ParticleMapper.hpp>
-#include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/SkeletalModel.cpp

@@ -6,8 +6,8 @@
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Graphics/SkinningManager.hpp>
-#include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/MeshData.hpp>
+#include <Nazara/Utility/Sequence.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>

src/Nazara/Graphics/SkinningManager.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2017 Jérôme Leclercq
+// Copyright (C) 2017 Jérôme Leclercq
 // This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
@@ -6,10 +6,11 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/TaskScheduler.hpp>
 #include <Nazara/Utility/Algorithm.hpp>
+#include <Nazara/Utility/Joint.hpp>
+#include <Nazara/Utility/Skeleton.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
+#include <Nazara/Utility/Skeleton.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
-#include <Nazara/Utility/VertexMapper.hpp>
-#include <memory>
 #include <unordered_map>
 #include <Nazara/Graphics/Debug.hpp>
 

src/Nazara/Graphics/SkyboxBackground.cpp

@@ -6,10 +6,11 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
+#include <Nazara/Renderer/RenderStates.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
 #include <Nazara/Utility/VertexDeclaration.hpp>
-#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/Sprite.cpp

@@ -4,9 +4,7 @@
 
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
-#include <cstring>
-#include <memory>
+#include <Nazara/Utility/VertexStruct.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/TextSprite.cpp

@@ -6,9 +6,9 @@
 #include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/SparsePtr.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
-#include <memory>
+#include <Nazara/Utility/AbstractTextDrawer.hpp>
 #include <Nazara/Utility/Font.hpp>
+#include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/TextureBackground.cpp

@@ -4,7 +4,8 @@
 
 #include <Nazara/Graphics/TextureBackground.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <memory>
+#include <Nazara/Renderer/RenderStates.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Graphics/TileMap.cpp

@@ -4,10 +4,8 @@
 
 #include <Nazara/Graphics/TileMap.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Math/Rect.hpp>
-#include <cstring>
-#include <memory>
+#include <Nazara/Utility/VertexStruct.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace Nz

src/Nazara/Lua/LuaCoroutine.cpp

@@ -3,9 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Lua/LuaCoroutine.hpp>
-#include <Lua/lauxlib.h>
 #include <Lua/lua.h>
-#include <Lua/lualib.h>
 #include <Nazara/Lua/LuaInstance.hpp>
 #include <Nazara/Lua/Debug.hpp>
 

src/Nazara/Lua/LuaInstance.cpp

@@ -8,14 +8,9 @@
 #include <Lua/lualib.h>
 #include <Nazara/Core/Clock.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/File.hpp>
-#include <Nazara/Core/MemoryHelper.hpp>
-#include <Nazara/Core/MemoryView.hpp>
-#include <Nazara/Core/StringStream.hpp>
 #include <cassert>
 #include <cstdlib>
 #include <stdexcept>
-#include <unordered_map>
 #include <Nazara/Lua/Debug.hpp>
 
 namespace Nz

src/Nazara/Lua/LuaState.cpp

@@ -5,7 +5,6 @@
 #include <Nazara/Lua/LuaState.hpp>
 #include <Lua/lauxlib.h>
 #include <Lua/lua.h>
-#include <Lua/lualib.h>
 #include <Nazara/Core/Clock.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/File.hpp>
@@ -14,9 +13,6 @@
 #include <Nazara/Core/StringStream.hpp>
 #include <Nazara/Lua/LuaCoroutine.hpp>
 #include <Nazara/Lua/LuaInstance.hpp>
-#include <cstdlib>
-#include <stdexcept>
-#include <unordered_map>
 #include <Nazara/Lua/Debug.hpp>
 
 namespace Nz
@@ -126,12 +122,6 @@ namespace Nz
 		static_assert(sizeof(s_types)/sizeof(int) == LuaType_Max+1, "Lua type array is incomplete");
 	}
 
-	LuaState::LuaState(LuaState&& state) noexcept :
-	m_lastError(state.m_lastError),
-	m_state(state.m_state)
-	{
-	}
-
 	void LuaState::ArgCheck(bool condition, unsigned int argNum, const char* error) const
 	{
 		luaL_argcheck(m_state, condition, argNum, error);
@@ -373,7 +363,7 @@ namespace Nz
 			return false;
 		}
 
-		return Run(0, 0);
+		return Run(0, LUA_MULTRET);
 	}
 
 	bool LuaState::ExecuteFromFile(const String& filePath)
@@ -419,7 +409,7 @@ namespace Nz
 			return false;
 		}
 
-		return Run(0, 0);
+		return Run(0, LUA_MULTRET);
 	}
 
 	int LuaState::GetAbsIndex(int index) const
@@ -789,14 +779,6 @@ namespace Nz
 		return luaL_testudata(m_state, index, tname.GetConstBuffer());
 	}
 
-	LuaState& LuaState::operator=(LuaState&& state) noexcept
-	{
-		m_lastError = std::move(state.m_lastError);
-		m_state = state.m_state;
-
-		return *this;
-	}
-
 	bool LuaState::Run(int argCount, int resultCount)
 	{
 		LuaInstance& instance = GetInstance(m_state);

src/Nazara/Network/AbstractSocket.cpp

@@ -4,7 +4,6 @@
 
 #include <Nazara/Network/AbstractSocket.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <utility>
 #include <Nazara/Network/Debug.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)

src/Nazara/Network/ENetCompressor.cpp

@@ -0,0 +1,11 @@
+// Copyright (C) 2017 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Network module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Network/ENetCompressor.hpp>
+#include <Nazara/Network/Debug.hpp>
+
+namespace Nz
+{
+	ENetCompressor::~ENetCompressor() = default;
+}

src/Nazara/Network/ENetHost.cpp

@@ -86,7 +86,7 @@ namespace Nz
 			return nullptr;
 		}
 
-		m_channelLimit = Clamp<std::size_t>(channelCount, ENetConstants::ENetProtocol_MinimumChannelCount, ENetConstants::ENetProtocol_MaximumChannelCount);
+		channelCount = Clamp<std::size_t>(channelCount, ENetConstants::ENetProtocol_MinimumChannelCount, ENetConstants::ENetProtocol_MaximumChannelCount);
 
 		UInt32 windowSize;
 		if (m_outgoingBandwidth == 0)
@@ -128,24 +128,29 @@ namespace Nz
 			if (!result.address)
 				continue;
 
-			if (result.socketType != SocketType_UDP)
-				continue;
-
 			hostnameAddress = result.address;
 			break; //< Take first valid address
 		}
 
+		if (!hostnameAddress.IsValid())
+		{
+			if (error)
+				*error = ResolveError_NotFound;
+
+			return nullptr;
+		}
+
 		return Connect(hostnameAddress, channelCount, data);
 	}
 
-	bool ENetHost::Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount)
+	bool ENetHost::Create(const IpAddress& listenAddress, std::size_t peerCount, std::size_t channelCount)
 	{
-		return Create(address, peerCount, channelCount, 0, 0);
+		return Create(listenAddress, peerCount, channelCount, 0, 0);
 	}
 
-	bool ENetHost::Create(const IpAddress& address, std::size_t peerCount, std::size_t channelCount, UInt32 incomingBandwidth, UInt32 outgoingBandwidth)
+	bool ENetHost::Create(const IpAddress& listenAddress, std::size_t peerCount, std::size_t channelCount, UInt32 incomingBandwidth, UInt32 outgoingBandwidth)
 	{
-		NazaraAssert(address.IsValid(), "Invalid listening address");
+		NazaraAssert(listenAddress.IsValid(), "Invalid listening address");
 
 		if (peerCount > ENetConstants::ENetProtocol_MaximumPeerId)
 		{
@@ -153,10 +158,11 @@ namespace Nz
 			return false;
 		}
 
-		if (!InitSocket(address))
+		if (!InitSocket(listenAddress))
 			return false;
 
-		m_address = address;
+		m_address = listenAddress;
+		m_allowsIncomingConnections = (listenAddress.IsValid() && !listenAddress.IsLoopback());
 		m_randomSeed = *reinterpret_cast<UInt32*>(this);
 		m_randomSeed += s_randomGenerator();
 		m_randomSeed = (m_randomSeed << 16) | (m_randomSeed >> 16);
@@ -231,6 +237,10 @@ namespace Nz
 					break;
 			}
 
+			// Receiving on an unbound socket which has never sent data is an invalid operation
+			if (!m_allowsIncomingConnections && m_totalSentData == 0)
+				return 0;
+
 			switch (ReceiveIncomingCommands(event))
 			{
 				case 1:
@@ -318,7 +328,7 @@ namespace Nz
 		m_socket.SetReceiveBufferSize(ENetConstants::ENetHost_ReceiveBufferSize);
 		m_socket.SetSendBufferSize(ENetConstants::ENetHost_SendBufferSize);
 
-		if (!address.IsLoopback())
+		if (address.IsValid() && !address.IsLoopback())
 		{
 			if (m_socket.Bind(address) != SocketState_Bound)
 			{
@@ -402,6 +412,9 @@ namespace Nz
 
 	ENetPeer* ENetHost::HandleConnect(ENetProtocolHeader* /*header*/, ENetProtocol* command)
 	{
+		if (!m_allowsIncomingConnections)
+			return nullptr;
+
 		UInt32 channelCount = NetToHost(command->connect.channelCount);
 
 		if (channelCount < ENetProtocol_MinimumChannelCount || channelCount > ENetProtocol_MaximumChannelCount)
@@ -508,6 +521,19 @@ namespace Nz
 		}
 
 		// Compression handling
+		if (flags & ENetProtocolHeaderFlag_Compressed)
+		{
+			if (!m_compressor)
+				return false;
+
+			std::size_t newSize = m_compressor->Decompress(peer, m_receivedData, m_receivedDataLength, m_packetData[1].data() + headerSize, m_packetData[1].size() - headerSize);
+			if (newSize == 0 || newSize > m_packetData[1].size() - headerSize)
+				return false;
+
+			std::memcpy(m_packetData[1].data(), header, headerSize);
+			m_receivedData = m_packetData[1].data();
+			m_receivedDataLength = headerSize + newSize;
+		}
 
 		// Checksum
 
@@ -868,8 +894,6 @@ namespace Nz
 				break;
 			}
 
-			++currentCommand;
-
 			if (channel && outgoingCommand->sendAttempts < 1)
 			{
 				channel->usedReliableWindows |= 1 << reliableWindow;
@@ -888,7 +912,7 @@ namespace Nz
 				peer->m_nextTimeout = m_serviceTime + outgoingCommand->roundTripTimeout;
 
 			peer->m_sentReliableCommands.emplace_back(std::move(*outgoingCommand));
-			peer->m_outgoingReliableCommands.erase(outgoingCommand);
+			currentCommand = peer->m_outgoingReliableCommands.erase(outgoingCommand);
 
 			outgoingCommand = peer->m_sentReliableCommands.end();
 			--outgoingCommand;
@@ -911,7 +935,7 @@ namespace Nz
 				++m_bufferCount;
 
 				NetBuffer& packetBuffer = m_buffers[m_bufferCount];
-				packetBuffer.data = outgoingCommand->packet->data.GetData() + Nz::NetPacket::HeaderSize + outgoingCommand->fragmentOffset;
+				packetBuffer.data = outgoingCommand->packet->data.GetData() + NetPacket::HeaderSize + outgoingCommand->fragmentOffset;
 				packetBuffer.dataLength = outgoingCommand->fragmentLength;
 
 				m_packetSize += packetBuffer.dataLength;
@@ -1013,11 +1037,27 @@ namespace Nz
 				else
 					m_buffers[0].dataLength = NazaraOffsetOf(ENetProtocolHeader, sentTime);
 
+				// Compress packet buffers if possible
+				std::size_t compressedSize = 0;
+				if (m_compressor)
+				{
+					compressedSize = m_compressor->Compress(currentPeer, &m_buffers[1], m_bufferCount, m_packetSize - sizeof(ENetProtocolHeader), m_packetData[1].data(), m_packetData[1].size());
+					if (compressedSize > 0)
+						m_headerFlags |= ENetProtocolHeaderFlag_Compressed;
+				}
+
 				if (currentPeer->m_outgoingPeerID < ENetConstants::ENetProtocol_MaximumPeerId)
 					m_headerFlags |= currentPeer->m_outgoingSessionID << ENetProtocolHeaderSessionShift;
 
 				header->peerID = HostToNet(static_cast<UInt16>(currentPeer->m_outgoingPeerID | m_headerFlags));
 
+				if (compressedSize > 0)
+				{
+					m_buffers[1].data = m_packetData[1].data();
+					m_buffers[1].dataLength = compressedSize;
+					m_bufferCount = 2;
+				}
+
 				currentPeer->m_lastSendTime = m_serviceTime;
 
 				// Simulate network by adding delay to packet sending and losing some packets
@@ -1027,7 +1067,7 @@ namespace Nz
 					sendNow = false;
 					if (!currentPeer->m_packetLossProbability(s_randomGenerator))
 					{
-						Nz::UInt16 delay = currentPeer->m_packetDelayDistribution(s_randomGenerator);
+						UInt16 delay = currentPeer->m_packetDelayDistribution(s_randomGenerator);
 						if (delay == 0)
 							sendNow = true;
 						else
@@ -1148,7 +1188,7 @@ namespace Nz
 				++m_bufferCount;
 
 				NetBuffer& packetBuffer = m_buffers[m_bufferCount];
-				packetBuffer.data = outgoingCommand->packet->data.GetData() + Nz::NetPacket::HeaderSize + outgoingCommand->fragmentOffset;
+				packetBuffer.data = outgoingCommand->packet->data.GetData() + NetPacket::HeaderSize + outgoingCommand->fragmentOffset;
 				packetBuffer.dataLength = outgoingCommand->fragmentLength;
 
 				m_packetSize += packetBuffer.dataLength;

src/Nazara/Network/ENetPeer.cpp

@@ -139,7 +139,7 @@ namespace Nz
 		m_packetsLost = 0;
 		m_packetLoss = 0;
 		m_packetLossVariance = 0;
-		m_packetThrottle = ENetConstants::ENetProtocol_MaximumWindowSize;
+		m_packetThrottle = ENetConstants::ENetPeer_DefaultPacketThrottle;
 		m_packetThrottleLimit = ENetConstants::ENetPeer_PacketThrottleScale;
 		m_packetThrottleCounter = 0;
 		m_packetThrottleEpoch = 0;
@@ -1330,7 +1330,7 @@ namespace Nz
 		{
 			if (rtt < m_lastRoundTripTime)
 			{
-				m_packetThrottle = std::max(m_packetThrottle + m_packetThrottleAcceleration, m_packetThrottleLimit);
+				m_packetThrottle = std::min(m_packetThrottle + m_packetThrottleAcceleration, m_packetThrottleLimit);
 				return 1;
 			}
 			else if (rtt > m_lastRoundTripTime + 2 * m_lastRoundTripTimeVariance)

src/Nazara/Network/IpAddress.cpp

@@ -8,7 +8,6 @@
 #include <Nazara/Network/Algorithm.hpp>
 #include <algorithm>
 #include <limits>
-#include <Nazara/Network/SystemSocket.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 #include <Nazara/Network/Win32/IpAddressImpl.hpp>

src/Nazara/Network/Linux/SocketPollerImpl.cpp

@@ -80,7 +80,7 @@ namespace Nz
 			NazaraWarning("An error occured while removing socket from epoll structure (errno " + String::Number(errno) + ": " + Error::GetLastSystemError() + ')');
 	}
 
-	int SocketPollerImpl::Wait(UInt64 msTimeout, SocketError* error)
+	int SocketPollerImpl::Wait(int msTimeout, SocketError* error)
 	{
 		int activeSockets;
 

src/Nazara/Network/Linux/SocketPollerImpl.hpp

@@ -30,7 +30,7 @@ namespace Nz
 			bool RegisterSocket(SocketHandle socket, SocketPollEventFlags eventFlags);
 			void UnregisterSocket(SocketHandle socket);
 
-			int Wait(UInt64 msTimeout, SocketError* error);
+			int Wait(int msTimeout, SocketError* error);
 
 		private:
 			std::unordered_set<SocketHandle> m_readyToReadSockets;

src/Nazara/Network/Network.cpp

@@ -10,7 +10,6 @@
 #include <Nazara/Network/Config.hpp>
 #include <Nazara/Network/NetPacket.hpp>
 #include <Nazara/Network/RUdpConnection.hpp>
-#include <Nazara/Network/Debug.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)
 #include <Nazara/Network/Win32/SocketImpl.hpp>

src/Nazara/Network/Posix/SocketImpl.cpp

@@ -4,8 +4,8 @@
 
 #include <Nazara/Network/Posix/SocketImpl.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/Log.hpp>
 #include <Nazara/Core/MemoryHelper.hpp>
+#include <Nazara/Network/NetBuffer.hpp>
 #include <Nazara/Network/Posix/IpAddressImpl.hpp>
 #include <netinet/tcp.h>
 #include <sys/ioctl.h>
@@ -509,12 +509,12 @@ namespace Nz
 		NazaraAssert(buffer && length > 0, "Invalid buffer");
 
 		IpAddressImpl::SockAddrBuffer nameBuffer;
-		socklen_t bufferLength = sizeof(sockaddr_in);
+		socklen_t bufferLength = static_cast<socklen_t>(nameBuffer.size());
 
 		IpAddress senderIp;
 
 		int byteRead = recvfrom(handle, buffer, length, 0, reinterpret_cast<sockaddr*>(&nameBuffer), &bufferLength);
-		if (byteRead == SOCKET_ERROR)
+		if (byteRead == -1)
 		{
 			int errorCode = GetLastErrorCode();
 			if (errorCode == EAGAIN)
@@ -549,6 +549,92 @@ namespace Nz
 		else // else we received something
 			senderIp = IpAddressImpl::FromSockAddr(reinterpret_cast<const sockaddr*>(&nameBuffer));
 
+		if (from)
+			*from = IpAddressImpl::FromSockAddr(reinterpret_cast<const sockaddr*>(&nameBuffer));
+
+		if (read)
+			*read = byteRead;
+
+		if (error)
+			*error = SocketError_NoError;
+
+		return true;
+	}
+
+	bool SocketImpl::ReceiveMultiple(SocketHandle handle, NetBuffer* buffers, std::size_t bufferCount, IpAddress* from, int* read, SocketError* error)
+	{
+		NazaraAssert(handle != InvalidHandle, "Invalid handle");
+		NazaraAssert(buffers && bufferCount > 0, "Invalid buffers");
+
+		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(iovec));
+		struct iovec* sysBuffers = static_cast<struct iovec*>(memory.GetPtr());
+		for (std::size_t i = 0; i < bufferCount; ++i)
+		{
+			sysBuffers[i].iov_base = buffers[i].data;
+			sysBuffers[i].iov_len = buffers[i].dataLength;
+		}
+
+		struct msghdr msgHdr;
+		std::memset(&msgHdr, 0, sizeof(msgHdr));
+
+		msgHdr.msg_iov = sysBuffers;
+		msgHdr.msg_iovlen = static_cast<int>(bufferCount);
+
+		IpAddressImpl::SockAddrBuffer nameBuffer;
+		if (from)
+		{
+			msgHdr.msg_name = nameBuffer.data();
+			msgHdr.msg_namelen = static_cast<socklen_t>(nameBuffer.size());
+		}
+
+		IpAddress senderIp;
+
+		int byteRead = recvmsg(handle, &msgHdr, MSG_NOSIGNAL);
+		if (byteRead == -1)
+		{
+			int errorCode = GetLastErrorCode();
+			if (errorCode == EAGAIN)
+				errorCode = EWOULDBLOCK;
+
+			switch (errorCode)
+			{
+				case EWOULDBLOCK:
+				{
+					// If we have no data and are not blocking, return true with 0 byte read
+					byteRead = 0;
+					senderIp = IpAddress::Invalid;
+					break;
+				}
+
+				default:
+				{
+					if (error)
+						*error = TranslateErrnoToResolveError(errorCode);
+
+					return false; //< Error
+				}
+			}
+		}
+		else if (byteRead == 0)
+		{
+			if (error)
+				*error = SocketError_ConnectionClosed;
+
+			return false; //< Connection closed
+		}
+		else // else we received something
+			senderIp = IpAddressImpl::FromSockAddr(reinterpret_cast<const sockaddr*>(nameBuffer.data()));
+
+#ifdef HAS_MSGHDR_FLAGS
+		if (msgHdr.msg_flags & MSG_TRUNC)
+		{
+			if (error)
+				*error = SocketError_DatagramSize;
+
+			return false;
+		}
+#endif
+
 		if (from)
 			*from = senderIp;
 

src/Nazara/Network/Posix/SocketImpl.hpp

@@ -10,12 +10,13 @@
 #include <Nazara/Network/SocketHandle.hpp>
 #include <Nazara/Network/Enums.hpp>
 #include <Nazara/Network/IpAddress.hpp>
-#include <Nazara/Network/NetBuffer.hpp>
 
 #define NAZARA_NETWORK_POLL_SUPPORT 1
 
 namespace Nz
 {
+	struct NetBuffer;
+
 	struct PollSocket
 	{
 		SocketHandle fd;
@@ -63,6 +64,7 @@ namespace Nz
 
 			static bool Receive(SocketHandle handle, void* buffer, int length, int* read, SocketError* error);
 			static bool ReceiveFrom(SocketHandle handle, void* buffer, int length, IpAddress* from, int* read, SocketError* error);
+			static bool ReceiveMultiple(SocketHandle handle, NetBuffer* buffers, std::size_t bufferCount, IpAddress* from, int* read, SocketError* error);
 
 			static bool Send(SocketHandle handle, const void* buffer, int length, int* sent, SocketError* error);
 			static bool SendMultiple(SocketHandle handle, const NetBuffer* buffers, std::size_t bufferCount, const IpAddress& to, int* sent, SocketError* error);

src/Nazara/Network/Posix/SocketPollerImpl.cpp

@@ -76,7 +76,7 @@ namespace Nz
 		m_readyToWriteSockets.erase(socket);
 	}
 
-	int SocketPollerImpl::Wait(UInt64 msTimeout, SocketError* error)
+	int SocketPollerImpl::Wait(int msTimeout, SocketError* error)
 	{
 		int activeSockets;
 

src/Nazara/Network/Posix/SocketPollerImpl.hpp

@@ -7,7 +7,6 @@
 #ifndef NAZARA_SOCKETPOLLERIMPL_HPP
 #define NAZARA_SOCKETPOLLERIMPL_HPP
 
-#include <Nazara/Network/IpAddress.hpp>
 #include <Nazara/Network/SocketHandle.hpp>
 #include <Nazara/Network/Posix/SocketImpl.hpp>
 #include <unordered_map>
@@ -30,7 +29,7 @@ namespace Nz
 			bool RegisterSocket(SocketHandle socket, SocketPollEventFlags eventFlags);
 			void UnregisterSocket(SocketHandle socket);
 
-			int Wait(UInt64 msTimeout, SocketError* error);
+			int Wait(int msTimeout, SocketError* error);
 
 		private:
 			std::unordered_set<SocketHandle> m_readyToReadSockets;

src/Nazara/Network/RUdpConnection.cpp

@@ -527,7 +527,7 @@ namespace Nz
 					}
 					else
 					{
-						NazaraNotice("Received wrong token (" + String::Number(token) + " instead of " + String::Number(~peer.stateData1) + ") from client " + peer.address);
+						NazaraNotice("Received wrong token (" + String::Number(token) + " instead of " + String::Number(~peer.stateData1) + ") from client " + peer.address.ToString());
 						return; //< Ignore
 					}
 

src/Nazara/Network/SocketPoller.cpp

@@ -170,7 +170,7 @@ namespace Nz
 	* Waits a specific/undetermined amount of time until at least one socket part of the SocketPoller becomes ready.
 	* To query the ready state of the registered socket, use the IsReadyToRead or IsReadyToWrite functions.
 	*
-	* \param msTimeout Maximum time to wait in milliseconds, 0 for infinity
+	* \param msTimeout Maximum time to wait in milliseconds, 0 will returns immediately and -1 will block indefinitely
 	*
 	* \return True if at least one socket registered to the poller is ready.
 	*
@@ -179,7 +179,7 @@ namespace Nz
 	* \see IsReady
 	* \see RegisterSocket
 	*/
-	bool SocketPoller::Wait(UInt64 msTimeout)
+	bool SocketPoller::Wait(int msTimeout)
 	{
 		SocketError error;
 

src/Nazara/Network/TcpClient.cpp

@@ -326,7 +326,7 @@ namespace Nz
 			});
 		}
 
-		while (totalByteSent < size)
+		while (totalByteSent < size || !IsBlockingEnabled())
 		{
 			int sendSize = static_cast<int>(std::min<std::size_t>(size - totalByteSent, std::numeric_limits<int>::max())); //< Handle very large send
 			int sentSize;

src/Nazara/Network/TcpServer.cpp

@@ -3,10 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Network/TcpServer.hpp>
-#include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Network/TcpClient.hpp>
-#include <limits>
 #include <Nazara/Network/Debug.hpp>
 
 #if defined(NAZARA_PLATFORM_WINDOWS)

src/Nazara/Network/UdpSocket.cpp

@@ -118,6 +118,42 @@ namespace Nz
 		return true;
 	}
 
+	/*!
+	* \brief Receive multiple datagram from one peer
+	* \return true If data were sent
+	*
+	* \param to Destination IpAddress (must match socket protocol)
+	* \param buffers A pointer to an array of NetBuffer containing buffers and size data
+	* \param bufferCount Number of buffers available
+	* \param from IpAddress of the peer
+	* \param received Optional argument to get the number of bytes received
+	*/
+	bool UdpSocket::ReceiveMultiple(NetBuffer* buffers, std::size_t bufferCount, IpAddress* from, std::size_t* received)
+	{
+		NazaraAssert(m_handle != SocketImpl::InvalidHandle, "Socket hasn't been created");
+		NazaraAssert(buffers && bufferCount > 0, "Invalid buffer");
+
+		int read;
+		if (!SocketImpl::ReceiveMultiple(m_handle, buffers, bufferCount, from, &read, &m_lastError))
+		{
+			switch (m_lastError)
+			{
+				case SocketError_ConnectionClosed:
+					m_lastError = SocketError_NoError;
+					read = 0;
+					break;
+
+				default:
+					return false;
+			}
+		}
+
+		if (received)
+			*received = read;
+
+		return true;
+	}
+
 	/*!
 	* \brief Receives the packet available
 	* \return true If packet received

src/Nazara/Network/Win32/SocketImpl.cpp

@@ -586,6 +586,72 @@ namespace Nz
 		return true;
 	}
 
+	bool SocketImpl::ReceiveMultiple(SocketHandle handle, NetBuffer* buffers, std::size_t bufferCount, IpAddress* from, int* read, SocketError* error)
+	{
+		NazaraAssert(handle != InvalidHandle, "Invalid handle");
+		NazaraAssert(buffers && bufferCount > 0, "Invalid buffers");
+
+		IpAddressImpl::SockAddrBuffer nameBuffer;
+		int bufferLength = static_cast<int>(nameBuffer.size());
+
+		IpAddress senderIp;
+
+		StackAllocation memory = NazaraStackAllocation(bufferCount * sizeof(WSABUF));
+		WSABUF* winBuffers = static_cast<WSABUF*>(memory.GetPtr());
+		for (std::size_t i = 0; i < bufferCount; ++i)
+		{
+			winBuffers[i].buf = static_cast<CHAR*>(buffers[i].data);
+			winBuffers[i].len = static_cast<ULONG>(buffers[i].dataLength);
+		}
+
+		DWORD flags = 0;
+		DWORD byteRead;
+		if (WSARecvFrom(handle, winBuffers, static_cast<DWORD>(bufferCount), &byteRead, &flags, reinterpret_cast<sockaddr*>(nameBuffer.data()), &bufferLength, nullptr, nullptr) == SOCKET_ERROR)
+		{
+			int errorCode = WSAGetLastError();
+			switch (errorCode)
+			{
+				case WSAECONNRESET:
+				case WSAEWOULDBLOCK:
+				{
+					// If we have no data and are not blocking, return true with 0 byte read
+					byteRead = 0;
+					senderIp = IpAddress::Invalid;
+					break;
+				}
+
+				default:
+				{
+					if (error)
+						*error = TranslateWSAErrorToSocketError(errorCode);
+
+					return false; //< Error
+				}
+			}
+		}
+		else
+			senderIp = IpAddressImpl::FromSockAddr(reinterpret_cast<const sockaddr*>(&nameBuffer));
+
+		if (flags & MSG_PARTIAL)
+		{
+			if (error)
+				*error = SocketError_DatagramSize;
+
+			return false;
+		}
+
+		if (from)
+			*from = senderIp;
+
+		if (read)
+			*read = byteRead;
+
+		if (error)
+			*error = SocketError_NoError;
+
+		return true;
+	}
+
 	bool SocketImpl::Send(SocketHandle handle, const void* buffer, int length, int* sent, SocketError* error)
 	{
 		NazaraAssert(handle != InvalidHandle, "Invalid handle");

src/Nazara/Network/Win32/SocketImpl.hpp

@@ -64,6 +64,7 @@ namespace Nz
 
 			static bool Receive(SocketHandle handle, void* buffer, int length, int* read, SocketError* error);
 			static bool ReceiveFrom(SocketHandle handle, void* buffer, int length, IpAddress* from, int* read, SocketError* error);
+			static bool ReceiveMultiple(SocketHandle handle, NetBuffer* buffers, std::size_t bufferCount, IpAddress* from, int* read, SocketError* error);
 
 			static bool Send(SocketHandle handle, const void* buffer, int length, int* sent, SocketError* error);
 			static bool SendMultiple(SocketHandle handle, const NetBuffer* buffers, std::size_t bufferCount, const IpAddress& to, int* sent, SocketError* error);

src/Nazara/Network/Win32/SocketPollerImpl.cpp

@@ -129,12 +129,36 @@ namespace Nz
 		#endif
 	}
 
-	int SocketPollerImpl::Wait(UInt64 msTimeout, SocketError* error)
+	int SocketPollerImpl::Wait(int msTimeout, SocketError* error)
 	{
 		int activeSockets;
 
 		#if NAZARA_NETWORK_POLL_SUPPORT
 		activeSockets = SocketImpl::Poll(m_sockets.data(), m_sockets.size(), static_cast<int>(msTimeout), error);
+
+		m_readyToReadSockets.clear();
+		m_readyToWriteSockets.clear();
+		if (activeSockets > 0U)
+		{
+			int socketRemaining = activeSockets;
+			for (PollSocket& entry : m_sockets)
+			{
+				if (entry.revents != 0)
+				{
+					if (entry.revents & POLLRDNORM)
+						m_readyToReadSockets.insert(entry.fd);
+
+					if (entry.revents & POLLWRNORM)
+						m_readyToWriteSockets.insert(entry.fd);
+
+					entry.revents = 0;
+
+					if (--socketRemaining == 0)
+						break;
+				}
+			}
+		}
+
 		#else
 		fd_set* readSet = nullptr;
 		fd_set* writeSet = nullptr;
@@ -155,7 +179,7 @@ namespace Nz
 		tv.tv_sec = static_cast<long>(msTimeout / 1000ULL);
 		tv.tv_usec = static_cast<long>((msTimeout % 1000ULL) * 1000ULL);
 
-		activeSockets = ::select(0xDEADBEEF, readSet, writeSet, nullptr, (msTimeout > 0) ? &tv : nullptr); //< The first argument is ignored on Windows
+		activeSockets = ::select(0xDEADBEEF, readSet, writeSet, nullptr, (msTimeout >= 0) ? &tv : nullptr); //< The first argument is ignored on Windows
 		if (activeSockets == SOCKET_ERROR)
 		{
 			if (error)

src/Nazara/Network/Win32/SocketPollerImpl.hpp

@@ -32,7 +32,7 @@ namespace Nz
 			bool RegisterSocket(SocketHandle socket, SocketPollEventFlags eventFlags);
 			void UnregisterSocket(SocketHandle socket);
 
-			int Wait(UInt64 msTimeout, SocketError* error);
+			int Wait(int msTimeout, SocketError* error);
 
 		private:
 			#if NAZARA_NETWORK_POLL_SUPPORT

src/Nazara/Noise/Perlin.cpp

@@ -4,8 +4,6 @@
 
 #include <Nazara/Noise/Perlin.hpp>
 #include <Nazara/Noise/NoiseTools.hpp>
-#include <exception>
-#include <stdexcept>
 #include <Nazara/Noise/Debug.hpp>
 
 namespace Nz

src/Nazara/Noise/Simplex.cpp

@@ -4,8 +4,6 @@
 
 #include <Nazara/Noise/Simplex.hpp>
 #include <Nazara/Noise/NoiseTools.hpp>
-#include <exception>
-#include <stdexcept>
 #include <Nazara/Noise/Debug.hpp>
 
 namespace Nz

src/Nazara/Noise/Worley.cpp

@@ -4,7 +4,6 @@
 
 #include <Nazara/Noise/Worley.hpp>
 #include <Nazara/Noise/NoiseTools.hpp>
-#include <exception>
 #include <stdexcept>
 #include <Nazara/Noise/Debug.hpp>