diff --git a/include/Nazara/Core/Enums.hpp b/include/Nazara/Core/Enums.hpp
index 765505575..1020cd2b6 100644
--- a/include/Nazara/Core/Enums.hpp
+++ b/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>;
diff --git a/include/Nazara/Core/Flags.hpp b/include/Nazara/Core/Flags.hpp
index e56d723e5..90e7ed2be 100644
--- a/include/Nazara/Core/Flags.hpp
+++ b/include/Nazara/Core/Flags.hpp
@@ -12,6 +12,13 @@
 
 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;
+	};
+
 	template<typename E>
 	class Flags
 	{
@@ -40,19 +47,13 @@ namespace Nz
 
 		private:
 			UInt32 m_value;
+
 	};
 
-	// From: https://www.justsoftwaresolutions.co.uk/cplusplus/using-enum-classes-as-bitfields.html
-	template<typename E>
-	struct EnableFlagsOperators
-	{
-		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);
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator~(E lhs);
+	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);
+	template<typename E> constexpr std::enable_if_t<EnumAsFlags<E>::value, Flags<E>> operator^(E lhs, E rhs);
 }
 
 #include <Nazara/Core/Flags.inl>
diff --git a/include/Nazara/Core/Flags.inl b/include/Nazara/Core/Flags.inl
index d9558fb99..8bf122b69 100644
--- a/include/Nazara/Core/Flags.inl
+++ b/include/Nazara/Core/Flags.inl
@@ -219,7 +219,7 @@ namespace Nz
 	* 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);
 	}
@@ -234,7 +234,7 @@ namespace Nz
 	* 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;
 	}
@@ -250,7 +250,7 @@ namespace Nz
 	* 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;
 	}
@@ -266,7 +266,7 @@ namespace Nz
 	* 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;
 	}
diff --git a/include/Nazara/Lua/LuaInstance.inl b/include/Nazara/Lua/LuaInstance.inl
index 99ef94ea4..6c3a4ff7e 100644
--- a/include/Nazara/Lua/LuaInstance.inl
+++ b/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)>());
diff --git a/include/Nazara/Utility/Enums.hpp b/include/Nazara/Utility/Enums.hpp
index 4edce5fef..69df340bd 100644
--- a/include/Nazara/Utility/Enums.hpp
+++ b/include/Nazara/Utility/Enums.hpp
@@ -62,7 +62,7 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<BufferUsage>
+	struct EnumAsFlags<BufferUsage>
 	{
 		static constexpr bool value = true;
 	};
@@ -453,7 +453,7 @@ namespace Nz
 	};
 
 	template<>
-	struct EnableFlagsOperators<WindowStyle>
+	struct EnumAsFlags<WindowStyle>
 	{
 		static constexpr bool value = true;
 	};