Merge remote-tracking branch 'refs/remotes/origin/master' into vulkan

include/Nazara/Core/Enums.hpp

@@ -91,9 +91,10 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<OpenMode>
+	struct EnumAsFlags<OpenMode>
 	{
 		static constexpr bool value = true;
+		static constexpr int  max   = OpenMode_Max;
 	};
 
 	using OpenModeFlags = Flags<OpenMode>;
@@ -194,9 +195,10 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<StreamOption>
+	struct EnumAsFlags<StreamOption>
 	{
 		static constexpr bool value = true;
+		static constexpr int  max = StreamOption_Max;
 	};
 
 	using StreamOptionFlags = Flags<StreamOption>;

include/Nazara/Core/Flags.hpp

@@ -12,47 +12,53 @@
 
 namespace Nz
 {
+	// From: https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html
+	template<typename E>
+	struct EnumAsFlags
+	{
+		static constexpr bool value = false;
+		static constexpr int  max   = 0;
+	};
+
 	template<typename E>
 	class Flags
 	{
 		static_assert(std::is_enum<E>::value, "Type must be an enumeration");
+		static_assert(EnumAsFlags<E>::value, "Enum has not been enabled as flags by an EnumAsFlags specialization");
 
 		public:
-			constexpr Flags(UInt32 value);
+			using BitField = typename std::conditional<(EnumAsFlags<E>::max > 32), UInt64, UInt32>::type;
+
+			constexpr Flags(BitField value);
 			constexpr Flags(E enumVal);
 
 			explicit constexpr operator bool() const;
-			explicit constexpr operator UInt32() const;
+			explicit constexpr operator BitField() const;
 
 			constexpr Flags operator~() const;
-			constexpr Flags operator&(Flags rhs) const;
+			constexpr Flags operator&(const Flags& rhs) const;
-			constexpr Flags operator|(Flags rhs) const;
+			constexpr Flags operator|(const Flags& rhs) const;
-			constexpr Flags operator^(Flags rhs) const;
+			constexpr Flags operator^(const Flags& rhs) const;
 
-			constexpr bool operator==(Flags rhs) const;
+			constexpr bool operator==(const Flags& rhs) const;
-			constexpr bool operator!=(Flags rhs) const;
+			constexpr bool operator!=(const Flags& rhs) const;
 
-			/*constexpr*/ Flags& operator|=(Flags rhs);
+			/*constexpr*/ Flags& operator|=(const Flags& rhs);
-			/*constexpr*/ Flags& operator&=(Flags rhs);
+			/*constexpr*/ Flags& operator&=(const Flags& rhs);
-			/*constexpr*/ Flags& operator^=(Flags rhs);
+			/*constexpr*/ Flags& operator^=(const Flags& rhs);
 
-			static constexpr UInt32 GetFlagValue(E enumValue);
+			static constexpr BitField GetFlagValue(E enumValue);
+
+			static constexpr BitField ValueMask = ((BitField(1) << (EnumAsFlags<E>::max + 1)) - 1);
 
 		private:
-			UInt32 m_value;
+			BitField m_value;
 	};
 
-	// From: https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs);
-	template<typename E>
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs);
-	struct EnableFlagsOperators
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator&(E lhs, E rhs);
-	{
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs);
-		static constexpr bool value = false;
-	};
-
-	template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator~(E lhs);
-	template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator|(E lhs, E rhs);
-	template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator&(E lhs, E rhs);
-	template<typename E> constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator^(E lhs, E rhs);
 }
 
 #include <Nazara/Core/Flags.inl>

include/Nazara/Core/Flags.inl

@@ -10,122 +10,264 @@ namespace Nz
 	/*!
 	* \ingroup core
 	* \class Nz::Flags
-	* \brief Core class that represents a set of bits
+	* \brief Core class used to combine enumeration values into flags bitfield
-	*
-	* This class meets the requirements of Container, AllocatorAwareContainer, SequenceContainer
 	*/
 
+    /*!
+    * \brief Constructs a Flags object using a bitfield
+    *
+    * \param value Bitfield to be used
+	*
+	* Uses a bitfield to builds the flag value. (e.g. if bit 0 is active, then Enum value 0 will be set as active).
+    */
 	template<typename E>
-	constexpr Flags<E>::Flags(UInt32 value) :
+	constexpr Flags<E>::Flags(BitField value) :
 	m_value(value)
 	{
 	}
 
+	/*!
+	* \brief Constructs a Flags object using an Enum value
+	*
+	* \param value enumVal
+	*
+	* Setup a Flags object with only one flag active (corresponding to the enum value passed as argument).
+	*/
 	template<typename E>
 	constexpr Flags<E>::Flags(E enumVal) :
 	Flags(GetFlagValue(enumVal))
 	{
 	}
 
+	/*!
+	* \brief Tests a Flags
+	* \return True if any flag is enabled.
+	*
+	* This will convert to a boolean value allowing to check if any flag is set.
+	*/
 	template<typename E>
 	constexpr Flags<E>::operator bool() const
 	{
 		return m_value != 0;
 	}
 
+	/*!
+	* \brief Converts to a bitfield
+	* \return Enabled flags as a bitfield.
+	*
+	* This will convert to a bitfield value.
+	*/
 	template<typename E>
-	constexpr Flags<E>::operator UInt32() const
+	constexpr Flags<E>::operator BitField() const
 	{
 		return m_value;
 	}
 
+	/*!
+	* \brief Reverse flag states
+	* \return Opposite enabled flags
+	*
+	* This will returns a copy of the Flags object with reversed flags states.
+	*/
 	template<typename E>
 	constexpr Flags<E> Flags<E>::operator~() const
 	{
-		return Flags(~m_value);
+		return Flags((~m_value) & ValueMask);
 	}
 
+	/*!
+	* \brief Compare flag states
+	* \return Shared flags
+	*
+	* \param rhs Flags to compare with.
+	*
+	* This will returns a copy of the Flags object with only enabled flags in common with the parameter
+	*/
 	template<typename E>
-	constexpr Flags<E> Flags<E>::operator&(Flags rhs) const
+	constexpr Flags<E> Flags<E>::operator&(const Flags& rhs) const
 	{
 		return Flags(m_value & rhs.m_value);
 	}
 
+	/*!
+	* \brief Combine flag states
+	* \return Combined flags
+	*
+	* This will returns a copy of the Flags object with combined flags from the parameter.
+	*
+	* \param rhs Flags to combine with.
+	*/
 	template<typename E>
-	constexpr Flags<E> Flags<E>::operator|(Flags rhs) const
+	constexpr Flags<E> Flags<E>::operator|(const Flags& rhs) const
 	{
 		return Flags(m_value | rhs.m_value);
 	}
 
+	/*!
+	* \brief XOR flag states
+	* \return XORed flags.
+	*
+	* \param rhs Flags to XOR with.
+	*
+	* This performs a XOR (Exclusive OR) on a copy of the flag object.
+	* This will returns a copy of the object with disabled common flags and enabled unique ones.
+	*/
 	template<typename E>
-	constexpr Flags<E> Flags<E>::operator^(Flags rhs) const
+	constexpr Flags<E> Flags<E>::operator^(const Flags& rhs) const
 	{
-		return Flags(m_value ^ rhs.m_value);
+		return Flags((m_value ^ rhs.m_value) & ValueMask);
 	}
 
+	/*!
+	* \brief Check equality with flag object
+	* \return True if both flags objects have the same states.
+	*
+	* \param rhs Flags to compare with.
+	*
+	* Compare two Flags object and returns true if the flag states are identical.
+	*/
 	template<typename E>
-	constexpr bool Flags<E>::operator==(Flags rhs) const
+	constexpr bool Flags<E>::operator==(const Flags& rhs) const
 	{
 		return m_value == rhs.m_value;
 	}
 
+	/*!
+	* \brief Check inequality with flag object
+	* \return True if both flags objects have different states.
+	*
+	* \param rhs Flags to compare with.
+	*
+	* Compare two Flags object and returns true if the flag states are identical.
+	*/
 	template<typename E>
-	constexpr bool Flags<E>::operator!=(Flags rhs) const
+	constexpr bool Flags<E>::operator!=(const Flags& rhs) const
 	{
 		return !operator==(rhs);
 	}
 
+	/*!
+	* \brief Combine flag states
+	* \return A reference to the object.
+	*
+	* \param rhs Flags to combine with.
+	*
+	* This will enable flags which are enabled in parameter object and not in Flag object.
+	*/
 	template<typename E>
-	/*constexpr*/ Flags<E>& Flags<E>::operator|=(Flags rhs)
+	/*constexpr*/ Flags<E>& Flags<E>::operator|=(const Flags& rhs)
 	{
 		m_value |= rhs.m_value;
 
 		return *this;
 	}
 
+	/*!
+	* \brief Compare flag states
+	* \return A reference to the object.
+	*
+	* \param rhs Flags to compare with.
+	*
+	* This will disable flags which are disabled in parameter object and enabled in Flag object (and vice-versa).
+	*/
 	template<typename E>
-	/*constexpr*/ Flags<E>& Flags<E>::operator&=(Flags rhs)
+	/*constexpr*/ Flags<E>& Flags<E>::operator&=(const Flags& rhs)
 	{
 		m_value &= rhs.m_value;
 
 		return *this;
 	}
 
+	/*!
+	* \brief XOR flag states
+	* \return A reference to the object.
+	*
+	* \param rhs Flags to XOR with.
+	*
+	* This performs a XOR (Exclusive OR) on the flag object.
+	* This will disable flags enabled in both Flags objects and enable those enabled in only one of the Flags objects.
+	*/
 	template<typename E>
-	/*constexpr*/ Flags<E>& Flags<E>::operator^=(Flags rhs)
+	/*constexpr*/ Flags<E>& Flags<E>::operator^=(const Flags& rhs)
 	{
 		m_value ^= rhs.m_value;
+		m_value &= ValueMask;
 
 		return *this;
 	}
 
+	/*!
+	* \brief Returns a bitfield corresponding to an enum value.
+	* \return Bitfield representation of the enum value
+	*
+	* \param enumValue Enumeration value to get as a bitfield.
+	*
+	* Internally, every enum option is turned into a bit, this function allows to get a bitfield with only the bit of the enumeration value enabled.
+	*/
 	template<typename E>
-	constexpr UInt32 Flags<E>::GetFlagValue(E enumValue)
+	constexpr typename Flags<E>::BitField Flags<E>::GetFlagValue(E enumValue)
 	{
-		return 1U << static_cast<UInt32>(enumValue);
+		return 1U << static_cast<BitField>(enumValue);
 	}
 
 
+	/*!
+	* \brief Override binary NOT operator on enum to turns into a Flags object.
+	* \return A Flags object with reversed bits.
+	*
+	* \param lhs Enumeration value to reverse.
+	*
+	* Returns a Flags object with all state enabled except for the enum one.
+	*/
 	template<typename E>
-	constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator~(E lhs)
+	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs)
 	{
 		return ~Flags<E>(lhs);
 	}
 
+	/*!
+	* \brief Override binary OR operator on enum to turns into a Flags object.
+	* \return A Flags object with combined enum states.
+	*
+	* \param lhs First enumeration value to combine.
+	* \param rhs Second enumeration value to combine.
+	*
+	* Returns a Flags object with combined states from the two enumeration values.
+	*/
 	template<typename E>
-	constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator|(E lhs, E rhs)
+	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator|(E lhs, E rhs)
 	{
 		return Flags<E>(lhs) | rhs;
 	}
 
+	/*!
+	* \brief Override binary AND operator on enum to turns into a Flags object.
+	* \return A Flags object with compare enum states.
+	*
+	* \param lhs First enumeration value to compare.
+	* \param rhs Second enumeration value to compare.
+	*
+	* Returns a Flags object with compared states from the two enumeration values.
+	* In this case, only one flag will be enabled if both enumeration values are the same.
+	*/
 	template<typename E>
-	constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator&(E lhs, E rhs)
+	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator&(E lhs, E rhs)
 	{
 		return Flags<E>(lhs) & rhs;
 	}
 
+	/*!
+	* \brief Override binary XOR operator on enum to turns into a Flags object.
+	* \return A Flags object with XORed enum states.
+	*
+	* \param lhs First enumeration value to compare.
+	* \param rhs Second enumeration value to compare.
+	*
+	* Returns a Flags object with XORed states from the two enumeration values.
+	* In this case, two flags will be enabled if both the enumeration values are different.
+	*/
 	template<typename E>
-	constexpr std::enable_if_t<EnableFlagsOperators<E>::value, Flags<E>> operator^(E lhs, E rhs)
+	constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs)
 	{
 		return Flags<E>(lhs) ^ rhs;
 	}

include/Nazara/Lua/LuaInstance.inl

@@ -100,21 +100,21 @@ namespace Nz
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 		return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), TypeTag<UnderlyingT>());
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 		return LuaImplQueryArg(instance, index, reinterpret_cast<UnderlyingT*>(arg), static_cast<UnderlyingT>(defValue), TypeTag<UnderlyingT>());
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 
@@ -126,7 +126,7 @@ namespace Nz
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, unsigned int> LuaImplQueryArg(const LuaInstance& instance, int index, T* arg, T defValue, TypeTag<T>)
 	{
 		using UnderlyingT = std::underlying_type_t<T>;
 
@@ -216,14 +216,14 @@ namespace Nz
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && !EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && !EnumAsFlags<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
 	{
 		using EnumT = typename std::underlying_type<T>::type;
 		return LuaImplReplyVal(instance, static_cast<EnumT>(val), TypeTag<EnumT>());
 	}
 
 	template<typename T>
-	std::enable_if_t<std::is_enum<T>::value && EnableFlagsOperators<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
+	std::enable_if_t<std::is_enum<T>::value && EnumAsFlags<T>::value, int> LuaImplReplyVal(const LuaInstance& instance, T val, TypeTag<T>)
 	{
 		Flags<T> flags(val);
 		return LuaImplReplyVal(instance, flags, TypeTag<decltype(flags)>());

include/Nazara/Utility/Enums.hpp

@@ -62,9 +62,10 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<BufferUsage>
+	struct EnumAsFlags<BufferUsage>
 	{
 		static constexpr bool value = true;
+		static constexpr int  max   = BufferUsage_Max;
 	};
 
 	using BufferUsageFlags = Flags<BufferUsage>;
@@ -453,9 +454,10 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<WindowStyle>
+	struct EnumAsFlags<WindowStyle>
 	{
 		static constexpr bool value = true;
+		static constexpr int  max   = WindowStyle_Max;
 	};
 
 	using WindowStyleFlags = Flags<WindowStyle>;

include/Nazara/Utility/SoftwareBuffer.hpp

@@ -15,7 +15,7 @@ namespace Nz
 {
 	class Buffer;
 
-	class SoftwareBuffer : public AbstractBuffer
+	class NAZARA_UTILITY_API SoftwareBuffer : public AbstractBuffer
 	{
 		public:
 			SoftwareBuffer(Buffer* parent, BufferType type);

plugins/Assimp/Plugin.cpp

@@ -184,7 +184,7 @@ bool Load(Mesh* mesh, Stream& stream, const MeshParams& parameters)
 				// Index buffer
 				bool largeIndices = (vertexCount > std::numeric_limits<UInt16>::max());
 
-				IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, indexCount, parameters.storage);
+				IndexBufferRef indexBuffer = IndexBuffer::New(largeIndices, indexCount, parameters.storage, 0);
 
 				IndexMapper indexMapper(indexBuffer, BufferAccess_DiscardAndWrite);
 				IndexIterator index = indexMapper.begin();
@@ -202,7 +202,7 @@ bool Load(Mesh* mesh, Stream& stream, const MeshParams& parameters)
 				indexMapper.Unmap();
 
 				// Vertex buffer
-				VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent), vertexCount, parameters.storage);
+				VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent), vertexCount, parameters.storage, 0);
 				BufferMapper<VertexBuffer> vertexMapper(vertexBuffer, BufferAccess_WriteOnly);
 
 				MeshVertex* vertex = static_cast<MeshVertex*>(vertexMapper.GetPointer());

readme.md

@@ -1,7 +1,7 @@
-Platform | Build Status
+Platform | Build Status | Nightlies
------------- | -------------
+------------ | ------------- | -------------
-Windows | [![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/dj5qx7axym4uakmy/branch/master?svg=true)](https://ci.appveyor.com/project/DPSLynix/nazaraengine/branch/master)
+Windows | [![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/dj5qx7axym4uakmy/branch/master?svg=true)](https://ci.appveyor.com/project/DPSLynix/nazaraengine/branch/master) | MSVC14:  [x86](https://ci.appveyor.com/api/projects/DPSLynix/NazaraEngine/artifacts/package%2FNazaraEngine.7z?branch=master&job=Environment%3A%20TOOLSET%3Dvs2015%3B%20Configuration%3A%20ReleaseDynamic%3B%20Platform%3A%20Win32)   [x86_64](https://ci.appveyor.com/api/projects/DPSLynix/NazaraEngine/artifacts/package%2FNazaraEngine.7z?branch=master&job=Environment%3A%20TOOLSET%3Dvs2015%3B%20Configuration%3A%20ReleaseDynamic%3B%20Platform%3A%20x64)
-Linux | [![Travis CI Build Status](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine.svg?branch=master)](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine)
+Linux | [![Travis CI Build Status](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine.svg?branch=master)](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine) | No
 
 # Nazara Engine  
 

readme_fr.md

@@ -1,7 +1,7 @@
-Platforme | Build Status
+Platforme | Build Status | Nightlies
------------- | -------------
+------------ | ------------- | -------------
-Windows | [![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/dj5qx7axym4uakmy/branch/master?svg=true)](https://ci.appveyor.com/project/DPSLynix/nazaraengine/branch/master)
+Windows | [![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/dj5qx7axym4uakmy/branch/master?svg=true)](https://ci.appveyor.com/project/DPSLynix/nazaraengine/branch/master) | MSVC14:  [x86](https://ci.appveyor.com/api/projects/DPSLynix/NazaraEngine/artifacts/package%2FNazaraEngine.7z?branch=master&job=Environment%3A%20TOOLSET%3Dvs2015%3B%20Configuration%3A%20ReleaseDynamic%3B%20Platform%3A%20Win32)   [x86_64](https://ci.appveyor.com/api/projects/DPSLynix/NazaraEngine/artifacts/package%2FNazaraEngine.7z?branch=master&job=Environment%3A%20TOOLSET%3Dvs2015%3B%20Configuration%3A%20ReleaseDynamic%3B%20Platform%3A%20x64)
-Linux | [![Travis CI Build Status](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine.svg?branch=master)](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine)
+Linux | [![Travis CI Build Status](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine.svg?branch=master)](https://travis-ci.org/DigitalPulseSoftware/NazaraEngine) | Non
 
 # Nazara Engine