Core: Merge InputStream and OutputStream to Stream

Remove serialization support from Stream


Former-commit-id: 7a761e4fcd07cab561f13e4709c4492ed18da88a

include/Nazara/Audio/Music.hpp

@@ -55,7 +55,7 @@ namespace Nz
 
 			bool OpenFromFile(const String& filePath, const MusicParams& params = MusicParams());
 			bool OpenFromMemory(const void* data, std::size_t size, const MusicParams& params = MusicParams());
-			bool OpenFromStream(InputStream& stream, const MusicParams& params = MusicParams());
+			bool OpenFromStream(Stream& stream, const MusicParams& params = MusicParams());
 
 			void Pause();
 			void Play();

include/Nazara/Audio/Sound.hpp

@@ -36,7 +36,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const SoundBufferParams& params = SoundBufferParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const SoundBufferParams& params = SoundBufferParams());
-			bool LoadFromStream(InputStream& stream, const SoundBufferParams& params = SoundBufferParams());
+			bool LoadFromStream(Stream& stream, const SoundBufferParams& params = SoundBufferParams());
 
 			void Pause();
 			void Play();

include/Nazara/Audio/SoundBuffer.hpp

@@ -10,7 +10,6 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Audio/Config.hpp>
 #include <Nazara/Audio/Enums.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/ObjectLibrary.hpp>
 #include <Nazara/Core/RefCounted.hpp>
@@ -18,6 +17,7 @@
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Core/ResourceManager.hpp>
 #include <Nazara/Core/Signal.hpp>
+#include <Nazara/Core/Stream.hpp>
 
 namespace Nz
 {
@@ -67,7 +67,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const SoundBufferParams& params = SoundBufferParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const SoundBufferParams& params = SoundBufferParams());
-			bool LoadFromStream(InputStream& stream, const SoundBufferParams& params = SoundBufferParams());
+			bool LoadFromStream(Stream& stream, const SoundBufferParams& params = SoundBufferParams());
 
 			static bool IsFormatSupported(AudioFormat format);
 			template<typename... Args> static SoundBufferRef New(Args&&... args);

include/Nazara/Audio/SoundEmitter.hpp

@@ -10,7 +10,6 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Audio/Config.hpp>
 #include <Nazara/Audio/Enums.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Math/Vector3.hpp>
 
 ///TODO: Faire hériter SoundEmitter de Node

include/Nazara/Core.hpp

@@ -50,7 +50,6 @@
 #include <Nazara/Core/GuillotineBinPack.hpp>
 #include <Nazara/Core/HardwareInfo.hpp>
 #include <Nazara/Core/Initializer.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/LockGuard.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Core/MemoryHelper.hpp>
@@ -62,7 +61,6 @@
 #include <Nazara/Core/ObjectLibrary.hpp>
 #include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/OffsetOf.hpp>
-#include <Nazara/Core/OutputStream.hpp>
 #include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Core/PluginManager.hpp>
 #include <Nazara/Core/Primitive.hpp>

include/Nazara/Core/Algorithm.inl

@@ -8,8 +8,7 @@
 
 #include <Nazara/Core/AbstractHash.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
-#include <Nazara/Core/OutputStream.hpp>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz

include/Nazara/Core/ByteArray.inl

@@ -59,6 +59,13 @@ namespace Nz
 		return m_array.back();
 	}
 
+	inline void ByteArray::Clear(bool keepBuffer)
+	{
+		m_array.clear();
+		if (!keepBuffer)
+			m_array.shrink_to_fit();
+	}
+
 	inline ByteArray::iterator ByteArray::Erase(const_iterator pos)
 	{
 		return m_array.erase(pos);

include/Nazara/Core/Enums.hpp

@@ -80,11 +80,12 @@ namespace Nz
 		OpenMode_Append    = 0x01, // Empêche l'écriture sur la partie déjà existante et met le curseur à la fin
 		OpenMode_Lock      = 0x02, // Empêche le fichier d'être modifié tant qu'il est ouvert
 		OpenMode_ReadOnly  = 0x04, // Ouvre uniquement en lecture
-		OpenMode_ReadWrite = 0x08, // Ouvre en lecture/écriture
 		OpenMode_Text      = 0x10, // Ouvre en mode texte
 		OpenMode_Truncate  = 0x20, // Créé le fichier s'il n'existe pas et le vide s'il existe
 		OpenMode_WriteOnly = 0x40, // Ouvre uniquement en écriture, créé le fichier s'il n'existe pas
 
+		OpenMode_ReadWrite = OpenMode_ReadOnly | OpenMode_WriteOnly, // Ouvre en lecture/écriture
+
 		OpenMode_Max = OpenMode_WriteOnly
 	};
 
@@ -173,7 +174,8 @@ namespace Nz
 	{
 		StreamOption_None = 0,
 
-		StreamOption_Text = 0x1,
+		StreamOption_Sequential = 0x1,
+		StreamOption_Text       = 0x2,
 
 		StreamOption_Max = StreamOption_Text*2-1
 	};

include/Nazara/Core/File.hpp

@@ -11,8 +11,7 @@
 #include <Nazara/Core/ByteArray.hpp>
 #include <Nazara/Core/Directory.hpp>
 #include <Nazara/Core/Endianness.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
-#include <Nazara/Core/OutputStream.hpp>
 #include <Nazara/Core/String.hpp>
 
 #if NAZARA_CORE_THREADSAFE && NAZARA_THREADSAFETY_FILE
@@ -27,7 +26,7 @@ namespace Nz
 {
 	class FileImpl;
 
-	class NAZARA_CORE_API File : public InputStream, public OutputStream
+	class NAZARA_CORE_API File : public Stream
 	{
 		public:
 			File();
@@ -47,8 +46,6 @@ namespace Nz
 
 			bool Exists() const;
 
-			void Flush() override;
-
 			time_t GetCreationTime() const;
 			UInt64 GetCursorPos() const override;
 			String GetDirectory() const override;
@@ -63,16 +60,12 @@ namespace Nz
 			bool Open(unsigned int openMode = OpenMode_Current);
 			bool Open(const String& filePath, unsigned int openMode = OpenMode_Current);
 
-			std::size_t Read(void* buffer, std::size_t size) override;
 			bool Rename(const String& newFilePath);
 
 			bool SetCursorPos(CursorPosition pos, Int64 offset = 0);
 			bool SetCursorPos(UInt64 offset) override;
 			bool SetFile(const String& filePath);
 
-			using OutputStream::Write;
-			std::size_t Write(const void* buffer, std::size_t size) override;
-
 			File& operator=(const String& filePath);
 			File& operator=(const File&) = delete;
 			File& operator=(File&& file) noexcept;
@@ -96,6 +89,10 @@ namespace Nz
 		private:
 			NazaraMutexAttrib(m_mutex, mutable)
 
+			void FlushStream() override;
+			std::size_t ReadBlock(void* buffer, std::size_t size) override;
+			std::size_t WriteBlock(const void* buffer, std::size_t size) override;
+
 			String m_filePath;
 			FileImpl* m_impl;
 	};

include/Nazara/Core/InputStream.hpp

@@ -1,45 +0,0 @@
-// Copyright (C) 2015 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
-
-#pragma once
-
-#ifndef NAZARA_INPUTSTREAM_HPP
-#define NAZARA_INPUTSTREAM_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Serialization.hpp>
-#include <Nazara/Core/Stream.hpp>
-
-namespace Nz
-{
-	class NAZARA_CORE_API InputStream : virtual public Stream
-	{
-		public:
-			inline InputStream(const InputStream& stream);
-			inline InputStream(InputStream&& stream) noexcept;
-			virtual ~InputStream();
-
-			virtual bool EndOfStream() const = 0;
-
-			virtual UInt64 GetSize() const = 0;
-
-			virtual std::size_t Read(void* buffer, std::size_t size) = 0;
-			virtual String ReadLine(unsigned int lineSize = 0);
-
-			template<typename T>
-			InputStream& operator>>(T& value);
-
-			inline InputStream& operator=(const InputStream& stream);
-			inline InputStream& operator=(InputStream&& stream) noexcept;
-
-		protected:
-			inline InputStream();
-
-			UnserializationContext m_unserializationContext;
-	};
-}
-
-#include <Nazara/Core/InputStream.inl>
-
-#endif // NAZARA_INPUTSTREAM_HPP

include/Nazara/Core/InputStream.inl

@@ -1,63 +0,0 @@
-// Copyright (C) 2015 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/Error.hpp>
-#include <utility>
-#include <Nazara/Core/Debug.hpp>
-
-namespace Nz
-{
-	inline InputStream::InputStream() :
-	Stream(OpenMode_Current)
-	{
-		m_unserializationContext.stream = this;
-	}
-
-	inline InputStream::InputStream(const InputStream& stream) :
-	Stream(stream),
-	m_unserializationContext(stream.m_unserializationContext)
-	{
-		m_unserializationContext.stream = this;
-	}
-
-	inline InputStream::InputStream(InputStream&& stream) noexcept :
-	Stream(std::move(stream)),
-	m_unserializationContext(std::move(stream.m_unserializationContext))
-	{
-		m_unserializationContext.stream = this;
-	}
-
-	template<typename T>
-	InputStream& InputStream::operator>>(T& value)
-	{
-		m_unserializationContext.endianness = m_dataEndianness; //< In case m_dataEndianness changed
-
-		if (!Unserialize(m_unserializationContext, &value))
-			NazaraError("Failed to unserialize value");
-
-		return *this;
-	}
-
-	inline InputStream& InputStream::operator=(const InputStream& stream)
-	{
-		Stream::operator=(stream);
-
-		m_unserializationContext = stream.m_unserializationContext;
-		m_unserializationContext.stream = this;
-
-		return *this;
-	}
-
-	inline InputStream& InputStream::operator=(InputStream&& stream) noexcept
-	{
-		Stream::operator=(std::move(stream));
-
-		m_unserializationContext = std::move(stream.m_unserializationContext);
-		m_unserializationContext.stream = this;
-
-		return *this;
-	}
-}
-
-#include <Nazara/Core/DebugOff.hpp>

include/Nazara/Core/MemoryStream.hpp

@@ -9,12 +9,11 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/ByteArray.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
-#include <Nazara/Core/OutputStream.hpp>
 
 namespace Nz
 {
-	class NAZARA_CORE_API MemoryStream : public InputStream, public OutputStream
+	class NAZARA_CORE_API MemoryStream : public Stream
 	{
 		public:
 			MemoryStream();
@@ -27,23 +26,22 @@ namespace Nz
 
 			bool EndOfStream() const override;
 
-			void Flush() override;
 
 			const ByteArray& GetBuffer() const;
 			const UInt8* GetData() const;
 			UInt64 GetCursorPos() const override;
 			UInt64 GetSize() const override;
 
-			std::size_t Read(void* buffer, std::size_t size) override;
-
 			bool SetCursorPos(UInt64 offset) override;
 
-			std::size_t Write(const void* buffer, std::size_t size) override;
-
 			MemoryStream& operator=(const MemoryStream&) = default;
 			MemoryStream& operator=(MemoryStream&&) = default;
 
 		private:
+			void FlushStream() override;
+			std::size_t ReadBlock(void* buffer, std::size_t size) override;
+			std::size_t WriteBlock(const void* buffer, std::size_t size) override;
+
 			ByteArray m_buffer;
 			UInt64 m_pos;
 	};
@@ -55,6 +53,6 @@ namespace Nz
 	NAZARA_CORE_API bool Unserialize(UnserializationContext& context, String* string);
 }
 
-#include <Nazara/Core/MemoryStream.hpp>
+#include <Nazara/Core/MemoryStream.inl>
 
 #endif // NAZARA_MEMORYSTREAM_HPP

include/Nazara/Core/MemoryView.hpp

@@ -8,11 +8,11 @@
 #define NAZARA_MEMORYVIEW_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 
 namespace Nz
 {
-	class NAZARA_CORE_API MemoryView : public InputStream
+	class NAZARA_CORE_API MemoryView : public Stream
 	{
 		public:
 			MemoryView(const void* ptr, UInt64 size);
@@ -25,14 +25,16 @@ namespace Nz
 			UInt64 GetCursorPos() const override;
 			UInt64 GetSize() const override;
 
-			std::size_t Read(void* buffer, std::size_t size) override;
-
 			bool SetCursorPos(UInt64 offset) override;
 
 			MemoryView& operator=(const MemoryView&) = delete;
 			MemoryView& operator=(MemoryView&&) = delete; ///TODO
 
 		private:
+		void FlushStream() override;
+			std::size_t ReadBlock(void* buffer, std::size_t size) override;
+			std::size_t WriteBlock(const void* buffer, std::size_t size) override;
+
 			const UInt8* m_ptr;
 			UInt64 m_pos;
 			UInt64 m_size;

include/Nazara/Core/OutputStream.hpp

@@ -1,47 +0,0 @@
-// Copyright (C) 2015 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
-
-#pragma once
-
-#ifndef NAZARA_OUTPUTSTREAM_HPP
-#define NAZARA_OUTPUTSTREAM_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Serialization.hpp>
-#include <Nazara/Core/Stream.hpp>
-
-namespace Nz
-{
-	class ByteArray;
-	class String;
-
-	class NAZARA_CORE_API OutputStream : virtual public Stream
-	{
-		public:
-			inline OutputStream(const OutputStream& stream);
-			inline OutputStream(OutputStream&& stream) noexcept;
-			virtual ~OutputStream();
-
-			virtual void Flush() = 0;
-
-			bool Write(const ByteArray& byteArray);
-			bool Write(const String& string);
-			virtual std::size_t Write(const void* buffer, std::size_t size) = 0;
-
-			template<typename T>
-			OutputStream& operator<<(const T& value);
-
-			inline OutputStream& operator=(const OutputStream& stream);
-			inline OutputStream& operator=(OutputStream&& stream) noexcept;
-
-		protected:
-			inline OutputStream();
-
-			SerializationContext m_serializationContext;
-	};
-}
-
-#include <Nazara/Core/OutputStream.inl>
-
-#endif // NAZARA_OUTPUTSTREAM_HPP

include/Nazara/Core/OutputStream.inl

@@ -1,63 +0,0 @@
-// Copyright (C) 2015 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/Error.hpp>
-#include <utility>
-#include <Nazara/Core/Debug.hpp>
-
-namespace Nz
-{
-	inline OutputStream::OutputStream() :
-	Stream(OpenMode_Current)
-	{
-		m_serializationContext.stream = this;
-	}
-
-	inline OutputStream::OutputStream(const OutputStream& stream) :
-	Stream(stream),
-	m_serializationContext(stream.m_serializationContext)
-	{
-		m_serializationContext.stream = this;
-	}
-
-	inline OutputStream::OutputStream(OutputStream&& stream) noexcept :
-	Stream(std::move(stream)),
-	m_serializationContext(std::move(stream.m_serializationContext))
-	{
-		m_serializationContext.stream = this;
-	}
-
-	template<typename T>
-	OutputStream& OutputStream::operator<<(const T& value)
-	{
-		m_serializationContext.endianness = m_dataEndianness; //< In case m_dataEndianness changed
-
-		if (!Serialize(m_serializationContext, value))
-			NazaraError("Failed to serialize value");
-
-		return *this;
-	}
-
-	inline OutputStream& OutputStream::operator=(const OutputStream& stream)
-	{
-		Stream::operator=(stream);
-
-		m_serializationContext = stream.m_serializationContext;
-		m_serializationContext.stream = this;
-
-		return *this;
-	}
-
-	inline OutputStream& OutputStream::operator=(OutputStream&& stream) noexcept
-	{
-		Stream::operator=(std::move(stream));
-
-		m_serializationContext = std::move(stream.m_serializationContext);
-		m_serializationContext.stream = this;
-
-		return *this;
-	}
-}
-
-#include <Nazara/Core/DebugOff.hpp>

include/Nazara/Core/ResourceLoader.hpp

@@ -16,7 +16,7 @@
 
 namespace Nz
 {
-	class InputStream;
+	class Stream;
 
 	template<typename Type, typename Parameters>
 	class ResourceLoader
@@ -27,8 +27,8 @@ namespace Nz
 			using ExtensionGetter = bool (*)(const String& extension);
 			using FileLoader = bool (*)(Type* resource, const String& filePath, const Parameters& parameters);
 			using MemoryLoader = bool (*)(Type* resource, const void* data, std::size_t size, const Parameters& parameters);
-			using StreamChecker = Ternary (*)(InputStream& stream, const Parameters& parameters);
+			using StreamChecker = Ternary (*)(Stream& stream, const Parameters& parameters);
-			using StreamLoader = bool (*)(Type* resource, InputStream& stream, const Parameters& parameters);
+			using StreamLoader = bool (*)(Type* resource, Stream& stream, const Parameters& parameters);
 
 			ResourceLoader() = delete;
 			~ResourceLoader() = delete;
@@ -37,7 +37,7 @@ namespace Nz
 
 			static bool LoadFromFile(Type* resource, const String& filePath, const Parameters& parameters = Parameters());
 			static bool LoadFromMemory(Type* resource, const void* data, unsigned int size, const Parameters& parameters = Parameters());
-			static bool LoadFromStream(Type* resource, InputStream& stream, const Parameters& parameters = Parameters());
+			static bool LoadFromStream(Type* resource, Stream& stream, const Parameters& parameters = Parameters());
 
 			static void RegisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader = nullptr, MemoryLoader memoryLoader = nullptr);
 			static void UnregisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader = nullptr, MemoryLoader memoryLoader = nullptr);

include/Nazara/Core/ResourceLoader.inl

@@ -5,8 +5,8 @@
 #include <Nazara/Core/Config.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/File.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/MemoryView.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/Debug.hpp>
 
 namespace Nz
@@ -199,7 +199,7 @@ namespace Nz
 	}
 
 	template<typename Type, typename Parameters>
-	bool ResourceLoader<Type, Parameters>::LoadFromStream(Type* resource, InputStream& stream, const Parameters& parameters)
+	bool ResourceLoader<Type, Parameters>::LoadFromStream(Type* resource, Stream& stream, const Parameters& parameters)
 	{
 		#if NAZARA_CORE_SAFE
 		if (!parameters.IsValid())

include/Nazara/Core/Serialization.hpp

@@ -15,18 +15,17 @@
 
 namespace Nz
 {
-	class InputStream;
+	class Stream;
-	class OutputStream;
 
 	struct SerializationContext
 	{
-		OutputStream* stream;
+		Stream* stream;
 		Endianness endianness;
 	};
 
 	struct UnserializationContext
 	{
-		InputStream* stream;
+		Stream* stream;
 		Endianness endianness;
 	};
 }

include/Nazara/Core/Stream.hpp

@@ -13,6 +13,7 @@
 
 namespace Nz
 {
+	class ByteArray;
 	class String; //< Do not include String.hpp in this file
 
 	class NAZARA_CORE_API Stream
@@ -22,19 +23,33 @@ namespace Nz
 			Stream(Stream&&) = default;
 			virtual ~Stream();
 
+			virtual bool EndOfStream() const = 0;
+
+			inline void EnableTextMode(bool textMode);
+
+			inline void Flush();
+
 			virtual UInt64 GetCursorPos() const = 0;
 			virtual String GetDirectory() const;
 			virtual String GetPath() const;
-			inline Endianness GetDataEndianness() const;
 			inline UInt32 GetOpenMode() const;
 			inline UInt32 GetStreamOptions() const;
 
+			virtual UInt64 GetSize() const = 0;
+
+			inline std::size_t Read(void* buffer, std::size_t size);
+			virtual String ReadLine(unsigned int lineSize = 0);
+
 			inline bool IsReadable() const;
+			inline bool IsSequential() const;
+			inline bool IsTextModeEnabled() const;
 			inline bool IsWritable() const;
 
 			virtual bool SetCursorPos(UInt64 offset) = 0;
-			inline void SetDataEndianness(Endianness endiannes);
+
-			inline void SetStreamOptions(UInt32 options);
+			bool Write(const ByteArray& byteArray);
+			bool Write(const String& string);
+			inline std::size_t Write(const void* buffer, std::size_t size);
 
 			Stream& operator=(const Stream&) = default;
 			Stream& operator=(Stream&&) = default;
@@ -42,7 +57,10 @@ namespace Nz
 		protected:
 			inline Stream(UInt32 openMode);
 
-			Endianness m_dataEndianness;
+			virtual void FlushStream() = 0;
+			virtual std::size_t ReadBlock(void* buffer, std::size_t size) = 0;
+			virtual std::size_t WriteBlock(const void* buffer, std::size_t size) = 0;
+
 			UInt32 m_openMode;
 			UInt32 m_streamOptions;
 	};

include/Nazara/Core/Stream.inl

@@ -2,18 +2,29 @@
 // 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/Error.hpp>
+
 namespace Nz
 {
 	inline Stream::Stream(UInt32 openMode) :
-	m_dataEndianness(Endianness_Unknown),
 	m_openMode(openMode),
 	m_streamOptions(0)
 	{
 	}
 
-	inline Endianness Stream::GetDataEndianness() const
+	inline void Stream::EnableTextMode(bool textMode)
 	{
-		return m_dataEndianness;
+		if (textMode)
+			m_streamOptions |= StreamOption_Text;
+		else
+			m_streamOptions &= ~StreamOption_Text;
+	}
+
+	inline void Stream::Flush()
+	{
+		NazaraAssert(IsWritable(), "Stream is not writable");
+
+		FlushStream();
 	}
 
 	inline UInt32 Stream::GetOpenMode() const
@@ -28,21 +39,36 @@ namespace Nz
 
 	inline bool Stream::IsReadable() const
 	{
-		return m_openMode & OpenMode_ReadOnly || m_openMode & OpenMode_ReadWrite;
+		return (m_openMode & OpenMode_ReadOnly) != 0;
+	}
+
+	inline bool Stream::IsSequential() const
+	{
+		return (m_streamOptions & StreamOption_Sequential) != 0;
+	}
+
+	inline bool Stream::IsTextModeEnabled() const
+	{
+		return (m_streamOptions & StreamOption_Text) != 0;
 	}
 
 	inline bool Stream::IsWritable() const
 	{
-		return m_openMode & OpenMode_ReadWrite || m_openMode & OpenMode_WriteOnly;
+		return (m_openMode & OpenMode_WriteOnly) != 0;
 	}
 
-	inline void Stream::SetDataEndianness(Endianness endiannes)
+	inline std::size_t Stream::Read(void* buffer, std::size_t size)
 	{
-		m_dataEndianness = endiannes;
+		NazaraAssert(IsReadable(), "Stream is not readable");
+
+		return ReadBlock(buffer, size);
 	}
 
-	inline void Stream::SetStreamOptions(UInt32 options)
+	inline std::size_t Stream::Write(const void* buffer, std::size_t size)
 	{
-		m_streamOptions = options;
+		NazaraAssert(IsWritable(), "Stream is not writable");
+
+		return WriteBlock(buffer, size);
 	}
+
 }

include/Nazara/Graphics/Material.hpp

@@ -106,7 +106,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const MaterialParams& params = MaterialParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params = MaterialParams());
-			bool LoadFromStream(InputStream& stream, const MaterialParams& params = MaterialParams());
+			bool LoadFromStream(Stream& stream, const MaterialParams& params = MaterialParams());
 
 			void Reset();
 

include/Nazara/Graphics/Model.hpp

@@ -58,7 +58,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const ModelParameters& params = ModelParameters());
 			bool LoadFromMemory(const void* data, std::size_t size, const ModelParameters& params = ModelParameters());
-			bool LoadFromStream(InputStream& stream, const ModelParameters& params = ModelParameters());
+			bool LoadFromStream(Stream& stream, const ModelParameters& params = ModelParameters());
 
 			void Reset();
 

include/Nazara/Graphics/SkeletalModel.hpp

@@ -59,7 +59,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const SkeletalModelParameters& params = SkeletalModelParameters());
 			bool LoadFromMemory(const void* data, std::size_t size, const SkeletalModelParameters& params = SkeletalModelParameters());
-			bool LoadFromStream(InputStream& stream, const SkeletalModelParameters& params = SkeletalModelParameters());
+			bool LoadFromStream(Stream& stream, const SkeletalModelParameters& params = SkeletalModelParameters());
 
 			void Reset();
 

include/Nazara/Lua/LuaInstance.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Clock.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Lua/Config.hpp>
 #include <Nazara/Lua/Enums.hpp>
@@ -73,7 +73,7 @@ namespace Nz
 			bool Execute(const String& code);
 			bool ExecuteFromFile(const String& filePath);
 			bool ExecuteFromMemory(const void* data, unsigned int size);
-			bool ExecuteFromStream(InputStream& stream);
+			bool ExecuteFromStream(Stream& stream);
 
 			int GetAbsIndex(int index) const;
 			LuaType GetField(const char* fieldName, int index = -1) const;

include/Nazara/Renderer/Texture.hpp

@@ -75,24 +75,24 @@ namespace Nz
 			bool LoadFromFile(const String& filePath, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
 			bool LoadFromImage(const Image& image, bool generateMipmaps = true);
 			bool LoadFromMemory(const void* data, std::size_t size, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
-			bool LoadFromStream(InputStream& stream, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
+			bool LoadFromStream(Stream& stream, const ImageParams& params = ImageParams(), bool generateMipmaps = true);
 
 			// LoadArray
 			bool LoadArrayFromFile(const String& filePath, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
 			bool LoadArrayFromImage(const Image& image, bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
 			bool LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
-			bool LoadArrayFromStream(InputStream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
+			bool LoadArrayFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const Vector2ui& atlasSize = Vector2ui(2, 2));
 
 			// LoadCubemap
 			bool LoadCubemapFromFile(const String& filePath, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
 			bool LoadCubemapFromImage(const Image& image, bool generateMipmaps = true, const CubemapParams& params = CubemapParams());
 			bool LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
-			bool LoadCubemapFromStream(InputStream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
+			bool LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), bool generateMipmaps = true, const CubemapParams& cubemapParams = CubemapParams());
 
 			// LoadFace
 			bool LoadFaceFromFile(CubemapFace face, const String& filePath, const ImageParams& params = ImageParams());
 			bool LoadFaceFromMemory(CubemapFace face, const void* data, std::size_t size, const ImageParams& params = ImageParams());
-			bool LoadFaceFromStream(CubemapFace face, InputStream& stream, const ImageParams& params = ImageParams());
+			bool LoadFaceFromStream(CubemapFace face, Stream& stream, const ImageParams& params = ImageParams());
 
 			bool SetMipmapRange(UInt8 minLevel, UInt8 maxLevel);
 

include/Nazara/Utility/Animation.hpp

@@ -83,7 +83,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const AnimationParams& params = AnimationParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const AnimationParams& params = AnimationParams());
-			bool LoadFromStream(InputStream& stream, const AnimationParams& params = AnimationParams());
+			bool LoadFromStream(Stream& stream, const AnimationParams& params = AnimationParams());
 
 			void RemoveSequence(const String& sequenceName);
 			void RemoveSequence(unsigned int index);

include/Nazara/Utility/Font.hpp

@@ -78,7 +78,7 @@ namespace Nz
 			// Open
 			bool OpenFromFile(const String& filePath, const FontParams& params = FontParams());
 			bool OpenFromMemory(const void* data, std::size_t size, const FontParams& params = FontParams());
-			bool OpenFromStream(InputStream& stream, const FontParams& params = FontParams());
+			bool OpenFromStream(Stream& stream, const FontParams& params = FontParams());
 
 			void SetAtlas(const std::shared_ptr<AbstractAtlas>& atlas);
 			void SetGlyphBorder(unsigned int borderSize);

include/Nazara/Utility/Formats/MD5AnimParser.hpp

@@ -8,7 +8,7 @@
 #define NAZARA_FORMATS_MD5ANIMPARSER_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
@@ -42,7 +42,7 @@ namespace Nz
 				unsigned int index;
 			};
 
-			MD5AnimParser(InputStream& stream);
+			MD5AnimParser(Stream& stream);
 			~MD5AnimParser();
 
 			Ternary Check();
@@ -69,7 +69,7 @@ namespace Nz
 			std::vector<float> m_animatedComponents;
 			std::vector<Frame> m_frames;
 			std::vector<Joint> m_joints;
-			InputStream& m_stream;
+			Stream& m_stream;
 			String m_currentLine;
 			bool m_keepLastLine;
 			unsigned int m_frameIndex;

include/Nazara/Utility/Formats/MD5MeshParser.hpp

@@ -8,7 +8,7 @@
 #define NAZARA_FORMATS_MD5MESHPARSER_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Math/Vector3.hpp>
@@ -52,7 +52,7 @@ namespace Nz
 				String shader;
 			};
 
-			MD5MeshParser(InputStream& stream);
+			MD5MeshParser(Stream& stream);
 			~MD5MeshParser();
 
 			Ternary Check();
@@ -74,7 +74,7 @@ namespace Nz
 
 			std::vector<Joint> m_joints;
 			std::vector<Mesh> m_meshes;
-			InputStream& m_stream;
+			Stream& m_stream;
 			String m_currentLine;
 			bool m_keepLastLine;
 			unsigned int m_lineCount;

include/Nazara/Utility/Formats/MTLParser.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Utility/Config.hpp>
 #include <unordered_map>
@@ -39,7 +39,7 @@ namespace Nz
 				unsigned int illumModel = 0;
 			};
 
-			MTLParser(InputStream& stream$);
+			MTLParser(Stream& stream$);
 			~MTLParser();
 
 			const Material* GetMaterial(const String& materialName) const;
@@ -54,7 +54,7 @@ namespace Nz
 			void UnrecognizedLine(bool error = false);
 
 			std::unordered_map<String, Material> m_materials;
-			InputStream& m_stream;
+			Stream& m_stream;
 			String m_currentLine;
 			bool m_keepLastLine;
 			unsigned int m_lineCount;

include/Nazara/Utility/Formats/OBJParser.hpp

@@ -8,7 +8,7 @@
 #define NAZARA_FORMATS_OBJPARSER_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Vector3.hpp>
 #include <Nazara/Math/Vector4.hpp>
@@ -39,7 +39,7 @@ namespace Nz
 				unsigned int material;
 			};
 
-			OBJParser(InputStream& stream$);
+			OBJParser(Stream& stream$);
 			~OBJParser();
 
 			const String* GetMaterials() const;
@@ -67,7 +67,7 @@ namespace Nz
 			std::vector<Vector3f> m_normals;
 			std::vector<Vector4f> m_positions;
 			std::vector<Vector3f> m_texCoords;
-			InputStream& m_stream;
+			Stream& m_stream;
 			String m_currentLine;
 			String m_mtlLib;
 			bool m_keepLastLine;

include/Nazara/Utility/Image.hpp

@@ -9,7 +9,6 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/ObjectLibrary.hpp>
 #include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/RefCounted.hpp>
@@ -17,6 +16,7 @@
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Core/ResourceManager.hpp>
 #include <Nazara/Core/Signal.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Utility/AbstractImage.hpp>
 #include <Nazara/Utility/CubemapParams.hpp>
 #include <atomic>
@@ -93,19 +93,19 @@ namespace Nz
 			// Load
 			bool LoadFromFile(const String& filePath, const ImageParams& params = ImageParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const ImageParams& params = ImageParams());
-			bool LoadFromStream(InputStream& stream, const ImageParams& params = ImageParams());
+			bool LoadFromStream(Stream& stream, const ImageParams& params = ImageParams());
 
 			// LoadArray
 			bool LoadArrayFromFile(const String& filePath, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2));
 			bool LoadArrayFromImage(const Image& image, const Vector2ui& atlasSize = Vector2ui(2, 2));
 			bool LoadArrayFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2));
-			bool LoadArrayFromStream(InputStream& stream, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2));
+			bool LoadArrayFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const Vector2ui& atlasSize = Vector2ui(2, 2));
 
 			// LoadCubemap
 			bool LoadCubemapFromFile(const String& filePath, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams());
 			bool LoadCubemapFromImage(const Image& image, const CubemapParams& params = CubemapParams());
 			bool LoadCubemapFromMemory(const void* data, std::size_t size, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams());
-			bool LoadCubemapFromStream(InputStream& stream, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams());
+			bool LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams = ImageParams(), const CubemapParams& cubemapParams = CubemapParams());
 
 			void SetLevelCount(UInt8 levelCount);
 			bool SetPixelColor(const Color& color, unsigned int x, unsigned int y = 0, unsigned int z = 0);

include/Nazara/Utility/Mesh.hpp

@@ -8,7 +8,6 @@
 #define NAZARA_MESH_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/ObjectLibrary.hpp>
 #include <Nazara/Core/ObjectRef.hpp>
 #include <Nazara/Core/Primitive.hpp>
@@ -16,6 +15,7 @@
 #include <Nazara/Core/Resource.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Core/ResourceManager.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Math/Box.hpp>
 #include <Nazara/Utility/Skeleton.hpp>
@@ -115,7 +115,7 @@ namespace Nz
 
 			bool LoadFromFile(const String& filePath, const MeshParams& params = MeshParams());
 			bool LoadFromMemory(const void* data, std::size_t size, const MeshParams& params = MeshParams());
-			bool LoadFromStream(InputStream& stream, const MeshParams& params = MeshParams());
+			bool LoadFromStream(Stream& stream, const MeshParams& params = MeshParams());
 
 			void Recenter();
 

src/Nazara/Audio/Formats/sndfileLoader.cpp

@@ -13,8 +13,8 @@
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/File.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/MemoryView.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <memory>
 #include <set>
 #include <vector>
@@ -27,19 +27,19 @@ namespace Nz
 	{
 		sf_count_t GetSize(void* user_data)
 		{
-			InputStream* stream = static_cast<InputStream*>(user_data);
+			Stream* stream = static_cast<Stream*>(user_data);
 			return stream->GetSize();
 		}
 
 		sf_count_t Read(void* ptr, sf_count_t count, void* user_data)
 		{
-			InputStream* stream = static_cast<InputStream*>(user_data);
+			Stream* stream = static_cast<Stream*>(user_data);
 			return static_cast<sf_count_t>(stream->Read(ptr, static_cast<std::size_t>(count)));
 		}
 
 		sf_count_t Seek(sf_count_t offset, int whence, void* user_data)
 		{
-			InputStream* stream = static_cast<InputStream*>(user_data);
+			Stream* stream = static_cast<Stream*>(user_data);
 			switch (whence)
 			{
 				case SEEK_CUR:
@@ -63,7 +63,7 @@ namespace Nz
 
 		sf_count_t Tell(void* user_data)
 		{
-			InputStream* stream = static_cast<InputStream*>(user_data);
+			Stream* stream = static_cast<Stream*>(user_data);
 			return stream->GetCursorPos();
 		}
 
@@ -128,7 +128,7 @@ namespace Nz
 					return Open(*m_ownedStream, forceMono);
 				}
 
-				bool Open(InputStream& stream, bool forceMono)
+				bool Open(Stream& stream, bool forceMono)
 				{
 					SF_INFO infos;
 					infos.format = 0; // Format inconnu
@@ -203,7 +203,7 @@ namespace Nz
 
 			private:
 				std::vector<Int16> m_mixBuffer;
-				std::unique_ptr<InputStream> m_ownedStream;
+				std::unique_ptr<Stream> m_ownedStream;
 				AudioFormat m_format;
 				SNDFILE* m_handle;
 				bool m_mixToMono;
@@ -222,7 +222,7 @@ namespace Nz
 			return supportedExtensions.find(extension) != supportedExtensions.end();
 		}
 
-		Ternary CheckMusic(InputStream& stream, const MusicParams& parameters)
+		Ternary CheckMusic(Stream& stream, const MusicParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -282,7 +282,7 @@ namespace Nz
 			return true;
 		}
 
-		bool LoadMusicStream(Music* music, InputStream& stream, const MusicParams& parameters)
+		bool LoadMusicStream(Music* music, Stream& stream, const MusicParams& parameters)
 		{
 			std::unique_ptr<sndfileStream> musicStream(new sndfileStream);
 			if (!musicStream->Open(stream, parameters.forceMono))
@@ -303,7 +303,7 @@ namespace Nz
 			return true;
 		}
 
-		Ternary CheckSoundBuffer(InputStream& stream, const SoundBufferParams& parameters)
+		Ternary CheckSoundBuffer(Stream& stream, const SoundBufferParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -320,7 +320,7 @@ namespace Nz
 				return Ternary_False;
 		}
 
-		bool LoadSoundBuffer(SoundBuffer* soundBuffer, InputStream& stream, const SoundBufferParams& parameters)
+		bool LoadSoundBuffer(SoundBuffer* soundBuffer, Stream& stream, const SoundBufferParams& parameters)
 		{
 			SF_INFO info;
 			info.format = 0;

src/Nazara/Audio/Music.cpp

@@ -189,7 +189,7 @@ namespace Nz
 		return MusicLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Music::OpenFromStream(InputStream& stream, const MusicParams& params)
+	bool Music::OpenFromStream(Stream& stream, const MusicParams& params)
 	{
 		return MusicLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Audio/Sound.cpp

@@ -110,7 +110,7 @@ namespace Nz
 		return true;
 	}
 
-	bool Sound::LoadFromStream(InputStream& stream, const SoundBufferParams& params)
+	bool Sound::LoadFromStream(Stream& stream, const SoundBufferParams& params)
 	{
 		SoundBufferRef buffer = SoundBuffer::New();
 		if (!buffer->LoadFromStream(stream, params))

src/Nazara/Audio/SoundBuffer.cpp

@@ -206,7 +206,7 @@ namespace Nz
 		return SoundBufferLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool SoundBuffer::LoadFromStream(InputStream& stream, const SoundBufferParams& params)
+	bool SoundBuffer::LoadFromStream(Stream& stream, const SoundBufferParams& params)
 	{
 		return SoundBufferLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Core/File.cpp

@@ -50,8 +50,6 @@ namespace Nz
 
 	File::File(File&& file) noexcept :
 	Stream(std::move(file)),
-	InputStream(std::move(file)),
-	OutputStream(std::move(file)),
 	m_filePath(std::move(file.m_filePath)),
 	m_impl(file.m_impl)
 	{
@@ -119,16 +117,6 @@ namespace Nz
 			return Exists(m_filePath);
 	}
 
-	void File::Flush()
-	{
-		NazaraLock(m_mutex)
-
-		NazaraAssert(IsOpen(), "File is not open");
-		NazaraAssert(IsWritable(), "File not opened with write access");
-
-		m_impl->Flush();
-	}
-
 	time_t File::GetCreationTime() const
 	{
 		NazaraLock(m_mutex)
@@ -194,29 +182,6 @@ namespace Nz
 		return m_impl != nullptr;
 	}
 
-	std::size_t File::Read(void* buffer, std::size_t size)
-	{
-		NazaraLock(m_mutex)
-
-		NazaraAssert(IsOpen(), "File is not opened");
-		NazaraAssert(IsReadable(), "File not opened with read access");
-
-		if (size == 0)
-			return 0;
-
-		if (buffer)
-			return m_impl->Read(buffer, size);
-		else
-		{
-			// Si nous ne devons rien lire, nous avançons simplement
-			UInt64 currentPos = m_impl->GetCursorPos();
-
-			m_impl->SetCursorPos(CursorPosition_AtCurrent, size);
-
-			return static_cast<std::size_t>(m_impl->GetCursorPos() - currentPos);
-		}
-	}
-
 	bool File::Rename(const String& newFilePath)
 	{
 		NazaraLock(m_mutex)
@@ -321,21 +286,6 @@ namespace Nz
 		return true;
 	}
 
-	std::size_t File::Write(const void* buffer, std::size_t size)
-	{
-		NazaraLock(m_mutex)
-
-		NazaraAssert(IsOpen(), "File is not opened");
-		NazaraAssert(IsWritable(), "File not opened with write access");
-
-		if (size == 0)
-			return 0;
-
-		NazaraAssert(buffer, "Invalid buffer");
-
-		return m_impl->Write(buffer, size);
-	}
-
 	File& File::operator=(const String& filePath)
 	{
 		SetFile(filePath);
@@ -549,6 +499,52 @@ namespace Nz
 		return FileImpl::Rename(NormalizePath(sourcePath), NormalizePath(targetPath));
 	}
 
+	void File::FlushStream()
+	{
+		NazaraLock(m_mutex)
+
+		NazaraAssert(IsOpen(), "File is not open");
+
+		m_impl->Flush();
+	}
+
+	std::size_t File::ReadBlock(void* buffer, std::size_t size)
+	{
+		NazaraLock(m_mutex)
+
+		NazaraAssert(IsOpen(), "File is not opened");
+
+		if (size == 0)
+			return 0;
+
+		if (buffer)
+			return m_impl->Read(buffer, size);
+		else
+		{
+			// Si nous ne devons rien lire, nous avançons simplement
+			UInt64 currentPos = m_impl->GetCursorPos();
+
+			m_impl->SetCursorPos(CursorPosition_AtCurrent, size);
+
+			return static_cast<std::size_t>(m_impl->GetCursorPos() - currentPos);
+		}
+	}
+
+	std::size_t File::WriteBlock(const void* buffer, std::size_t size)
+	{
+		NazaraLock(m_mutex)
+
+		NazaraAssert(IsOpen(), "File is not opened");
+
+		if (size == 0)
+			return 0;
+
+		NazaraAssert(buffer, "Invalid buffer");
+
+		return m_impl->Write(buffer, size);
+	}
+
+
 	NAZARA_CORE_API bool HashAppend(AbstractHash* hash, const File& originalFile)
 	{
 		File file(originalFile.GetPath());

src/Nazara/Core/InputStream.cpp

@@ -1,71 +0,0 @@
-// Copyright (C) 2015 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/InputStream.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/String.hpp>
-#include <cstring>
-#include <Nazara/Core/Debug.hpp>
-
-namespace Nz
-{
-	InputStream::~InputStream() = default;
-
-	String InputStream::ReadLine(unsigned int lineSize)
-	{
-		String line;
-		if (lineSize == 0) // Taille maximale indéterminée
-		{
-			const unsigned int bufferSize = 64;
-
-			char buffer[bufferSize+1];
-			buffer[bufferSize] = '\0';
-
-			unsigned int readSize;
-			do
-			{
-				readSize = Read(buffer, bufferSize);
-
-				const char* ptr = std::strchr(buffer, '\n');
-				if (ptr)
-				{
-					unsigned int pos = ptr-buffer;
-
-					if (m_streamOptions & StreamOption_Text && pos > 0 && buffer[pos-1] == '\r')
-						line.Append(buffer, pos-1);
-					else
-						line.Append(buffer, pos);
-
-					if (!SetCursorPos(GetCursorPos() - readSize + pos + 1))
-						NazaraWarning("Failed to reset cursos pos");
-
-					break;
-				}
-				else
-					line.Append(buffer, readSize);
-			}
-			while (readSize == bufferSize);
-		}
-		else
-		{
-			line.Set(lineSize, '\0');
-			unsigned int readSize = Read(&line[0], lineSize);
-			unsigned int pos = line.Find('\n');
-			if (pos <= readSize) // Faux uniquement si le caractère n'est pas présent (npos étant le plus grand entier)
-			{
-				if (m_streamOptions & StreamOption_Text && pos > 0 && line[pos-1] == '\r')
-					line.Resize(pos);
-				else
-					line.Resize(pos+1);
-
-				if (!SetCursorPos(GetCursorPos() - readSize + pos + 1))
-					NazaraWarning("Failed to reset cursos pos");
-			}
-			else
-				line.Resize(readSize);
-		}
-
-		return line;
-	}
-}

src/Nazara/Core/MemoryStream.cpp

@@ -33,11 +33,6 @@ namespace Nz
 		return m_pos >= m_buffer.size();
 	}
 
-	void MemoryStream::Flush()
-	{
-		// Nothing to flush
-	}
-
 	const ByteArray& MemoryStream::GetBuffer() const
 	{
 		return m_buffer;
@@ -58,7 +53,19 @@ namespace Nz
 		return m_buffer.size();
 	}
 
-	std::size_t MemoryStream::Read(void* buffer, std::size_t size)
+	bool MemoryStream::SetCursorPos(UInt64 offset)
+	{
+		m_pos = std::min<UInt64>(offset, m_buffer.size());
+
+		return true;
+	}
+
+	void MemoryStream::FlushStream()
+	{
+		// Nothing to flush
+	}
+
+	std::size_t MemoryStream::ReadBlock(void* buffer, std::size_t size)
 	{
 		std::size_t readSize = std::min<std::size_t>(size, static_cast<std::size_t>(m_buffer.size() - m_pos));
 
@@ -69,14 +76,7 @@ namespace Nz
 		return readSize;
 	}
 
-	bool MemoryStream::SetCursorPos(UInt64 offset)
+	std::size_t MemoryStream::WriteBlock(const void* buffer, std::size_t size)
-	{
-		m_pos = std::min<UInt64>(offset, m_buffer.size());
-
-		return true;
-	}
-
-	std::size_t MemoryStream::Write(const void* buffer, std::size_t size)
 	{
 		std::size_t endPos = static_cast<std::size_t>(m_pos + size);
 		if (endPos > m_buffer.size())

src/Nazara/Core/MemoryView.cpp

@@ -32,7 +32,19 @@ namespace Nz
 		return m_size;
 	}
 
-	std::size_t MemoryView::Read(void* buffer, std::size_t size)
+	bool MemoryView::SetCursorPos(UInt64 offset)
+	{
+		m_pos = std::min(offset, m_size);
+
+		return true;
+	}
+
+	void MemoryView::FlushStream()
+	{
+		NazaraInternalError("FlushStream has been called on a MemoryView");
+	}
+
+	std::size_t MemoryView::ReadBlock(void* buffer, std::size_t size)
 	{
 		std::size_t readSize = std::min<std::size_t>(size, static_cast<std::size_t>(m_size - m_pos));
 
@@ -43,10 +55,9 @@ namespace Nz
 		return readSize;
 	}
 
-	bool MemoryView::SetCursorPos(UInt64 offset)
+	std::size_t MemoryView::WriteBlock(const void* buffer, std::size_t size)
 	{
-		m_pos = std::min(offset, m_size);
+		NazaraInternalError("WriteBlock has been called on a MemoryView");
-
+		return 0;
-		return true;
 	}
 }

src/Nazara/Core/OutputStream.cpp

@@ -1,40 +0,0 @@
-// Copyright (C) 2015 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/OutputStream.hpp>
-#include <Nazara/Core/ByteArray.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/String.hpp>
-#include <cstring>
-#include <Nazara/Core/Debug.hpp>
-
-namespace Nz
-{
-	OutputStream::~OutputStream() = default;
-
-	bool OutputStream::Write(const ByteArray& byteArray)
-	{
-		ByteArray::size_type size = byteArray.GetSize();
-		return Write(byteArray.GetConstBuffer(), size) == size;
-	}
-
-	bool OutputStream::Write(const String& string)
-	{
-		String temp(string);
-
-		if (m_streamOptions & StreamOption_Text)
-		{
-			#if defined(NAZARA_PLATFORM_WINDOWS)
-			temp.Replace("\n", "\r\n");
-			#elif defined(NAZARA_PLATFORM_LINUX)
-			// Nothing to do
-			#elif defined(NAZARA_PLATFORM_MACOS)
-			temp.Replace('\n', '\r');
-			#endif
-		}
-
-		std::size_t size = temp.GetSize();
-		return Write(temp.GetConstBuffer(), size) == size;
-	}
-}

src/Nazara/Core/Stream.cpp

@@ -3,6 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Core/Stream.hpp>
+#include <Nazara/Core/ByteArray.hpp>
+#include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Core/Debug.hpp>
 
@@ -19,4 +21,86 @@ namespace Nz
 	{
 		return String();
 	}
+
+	String Stream::ReadLine(unsigned int lineSize)
+	{
+		String line;
+		if (lineSize == 0) // Taille maximale indéterminée
+		{
+			const unsigned int bufferSize = 64;
+
+			char buffer[bufferSize + 1];
+			buffer[bufferSize] = '\0';
+
+			unsigned int readSize;
+			do
+			{
+				readSize = Read(buffer, bufferSize);
+
+				const char* ptr = std::strchr(buffer, '\n');
+				if (ptr)
+				{
+					unsigned int pos = ptr - buffer;
+
+					if (m_streamOptions & StreamOption_Text && pos > 0 && buffer[pos - 1] == '\r')
+						line.Append(buffer, pos - 1);
+					else
+						line.Append(buffer, pos);
+
+					if (!SetCursorPos(GetCursorPos() - readSize + pos + 1))
+						NazaraWarning("Failed to reset cursos pos");
+
+					break;
+				}
+				else
+					line.Append(buffer, readSize);
+			}
+			while (readSize == bufferSize);
+		}
+		else
+		{
+			line.Set(lineSize, '\0');
+			unsigned int readSize = Read(&line[0], lineSize);
+			unsigned int pos = line.Find('\n');
+			if (pos <= readSize) // Faux uniquement si le caractère n'est pas présent (npos étant le plus grand entier)
+			{
+				if (m_streamOptions & StreamOption_Text && pos > 0 && line[pos - 1] == '\r')
+					line.Resize(pos);
+				else
+					line.Resize(pos + 1);
+
+				if (!SetCursorPos(GetCursorPos() - readSize + pos + 1))
+					NazaraWarning("Failed to reset cursos pos");
+			}
+			else
+				line.Resize(readSize);
+		}
+
+		return line;
+	}
+
+	bool Stream::Write(const ByteArray& byteArray)
+	{
+		ByteArray::size_type size = byteArray.GetSize();
+		return Write(byteArray.GetConstBuffer(), size) == size;
+	}
+
+	bool Stream::Write(const String& string)
+	{
+		String temp(string);
+
+		if (m_streamOptions & StreamOption_Text)
+		{
+			#if defined(NAZARA_PLATFORM_WINDOWS)
+			temp.Replace("\n", "\r\n");
+			#elif defined(NAZARA_PLATFORM_LINUX)
+			// Nothing to do
+			#elif defined(NAZARA_PLATFORM_MACOS)
+			temp.Replace('\n', '\r');
+			#endif
+		}
+
+		std::size_t size = temp.GetSize();
+		return Write(temp.GetConstBuffer(), size) == size;
+	}
 }

src/Nazara/Graphics/Formats/MeshLoader.cpp

@@ -14,7 +14,7 @@ namespace Nz
 {
 	namespace
 	{
-		Ternary CheckStatic(InputStream& stream, const ModelParameters& parameters)
+		Ternary CheckStatic(Stream& stream, const ModelParameters& parameters)
 		{
 			NazaraUnused(stream);
 			NazaraUnused(parameters);
@@ -22,7 +22,7 @@ namespace Nz
 			return Ternary_Unknown;
 		}
 
-		bool LoadStatic(Model* model, InputStream& stream, const ModelParameters& parameters)
+		bool LoadStatic(Model* model, Stream& stream, const ModelParameters& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -63,7 +63,7 @@ namespace Nz
 			return true;
 		}
 
-		Ternary CheckAnimated(InputStream& stream, const SkeletalModelParameters& parameters)
+		Ternary CheckAnimated(Stream& stream, const SkeletalModelParameters& parameters)
 		{
 			NazaraUnused(stream);
 			NazaraUnused(parameters);
@@ -71,7 +71,7 @@ namespace Nz
 			return Ternary_Unknown;
 		}
 
-		bool LoadAnimated(SkeletalModel* model, InputStream& stream, const SkeletalModelParameters& parameters)
+		bool LoadAnimated(SkeletalModel* model, Stream& stream, const SkeletalModelParameters& parameters)
 		{
 			NazaraUnused(parameters);
 

src/Nazara/Graphics/Formats/OBJLoader.cpp

@@ -29,7 +29,7 @@ namespace Nz
 			return (extension == "obj");
 		}
 
-		Ternary Check(InputStream& stream, const ModelParameters& parameters)
+		Ternary Check(Stream& stream, const ModelParameters& parameters)
 		{
 			NazaraUnused(stream);
 			NazaraUnused(parameters);
@@ -127,7 +127,7 @@ namespace Nz
 			return true;
 		}
 
-		bool Load(Model* model, InputStream& stream, const ModelParameters& parameters)
+		bool Load(Model* model, Stream& stream, const ModelParameters& parameters)
 		{
 			OBJParser parser(stream);
 			if (!parser.Parse())

src/Nazara/Graphics/Formats/TextureLoader.cpp

@@ -12,7 +12,7 @@ namespace Nz
 {
 	namespace
 	{
-		Ternary Check(InputStream& stream, const MaterialParams& parameters)
+		Ternary Check(Stream& stream, const MaterialParams& parameters)
 		{
 			NazaraUnused(stream);
 			NazaraUnused(parameters);
@@ -20,7 +20,7 @@ namespace Nz
 			return Ternary_Unknown;
 		}
 
-		bool Load(Material* material, InputStream& stream, const MaterialParams& parameters)
+		bool Load(Material* material, Stream& stream, const MaterialParams& parameters)
 		{
 			NazaraUnused(parameters);
 

src/Nazara/Graphics/Material.cpp

@@ -370,7 +370,7 @@ namespace Nz
 		return MaterialLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Material::LoadFromStream(InputStream& stream, const MaterialParams& params)
+	bool Material::LoadFromStream(Stream& stream, const MaterialParams& params)
 	{
 		return MaterialLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Graphics/Model.cpp

@@ -175,7 +175,7 @@ namespace Nz
 		return ModelLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Model::LoadFromStream(InputStream& stream, const ModelParameters& params)
+	bool Model::LoadFromStream(Stream& stream, const ModelParameters& params)
 	{
 		return ModelLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Graphics/SkeletalModel.cpp

@@ -149,7 +149,7 @@ namespace Nz
 		return SkeletalModelLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool SkeletalModel::LoadFromStream(InputStream& stream, const SkeletalModelParameters& params)
+	bool SkeletalModel::LoadFromStream(Stream& stream, const SkeletalModelParameters& params)
 	{
 		return SkeletalModelLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Lua/LuaInstance.cpp

@@ -62,7 +62,7 @@ namespace Nz
 
 		struct StreamData
 		{
-			InputStream* stream;
+			Stream* stream;
 			char buffer[NAZARA_CORE_FILE_BUFFERSIZE];
 		};
 
@@ -422,7 +422,7 @@ namespace Nz
 		return ExecuteFromStream(stream);
 	}
 
-	bool LuaInstance::ExecuteFromStream(InputStream& stream)
+	bool LuaInstance::ExecuteFromStream(Stream& stream)
 	{
 		StreamData data;
 		data.stream = &stream;

src/Nazara/Renderer/Texture.cpp

@@ -599,7 +599,7 @@ namespace Nz
 		return LoadFromImage(image, generateMipmaps);
 	}
 
-	bool Texture::LoadFromStream(InputStream& stream, const ImageParams& params, bool generateMipmaps)
+	bool Texture::LoadFromStream(Stream& stream, const ImageParams& params, bool generateMipmaps)
 	{
 		Image image;
 		if (!image.LoadFromStream(stream, params))
@@ -647,7 +647,7 @@ namespace Nz
 		return LoadFromImage(cubemap, generateMipmaps);
 	}
 
-	bool Texture::LoadArrayFromStream(InputStream& stream, const ImageParams& imageParams, bool generateMipmaps, const Vector2ui& atlasSize)
+	bool Texture::LoadArrayFromStream(Stream& stream, const ImageParams& imageParams, bool generateMipmaps, const Vector2ui& atlasSize)
 	{
 		Image cubemap;
 		if (!cubemap.LoadArrayFromStream(stream, imageParams, atlasSize))
@@ -695,7 +695,7 @@ namespace Nz
 		return LoadFromImage(cubemap, generateMipmaps);
 	}
 
-	bool Texture::LoadCubemapFromStream(InputStream& stream, const ImageParams& imageParams, bool generateMipmaps, const CubemapParams& cubemapParams)
+	bool Texture::LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams, bool generateMipmaps, const CubemapParams& cubemapParams)
 	{
 		Image cubemap;
 		if (!cubemap.LoadCubemapFromStream(stream, imageParams, cubemapParams))
@@ -785,7 +785,7 @@ namespace Nz
 		return Update(image, Rectui(0, 0, faceSize, faceSize), face);
 	}
 
-	bool Texture::LoadFaceFromStream(CubemapFace face, InputStream& stream, const ImageParams& params)
+	bool Texture::LoadFaceFromStream(CubemapFace face, Stream& stream, const ImageParams& params)
 	{
 		#if NAZARA_RENDERER_SAFE
 		if (!m_impl)

src/Nazara/Utility/Animation.cpp

@@ -458,7 +458,7 @@ namespace Nz
 		return AnimationLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Animation::LoadFromStream(InputStream& stream, const AnimationParams& params)
+	bool Animation::LoadFromStream(Stream& stream, const AnimationParams& params)
 	{
 		return AnimationLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Utility/Font.cpp

@@ -290,7 +290,7 @@ namespace Nz
 		return FontLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Font::OpenFromStream(InputStream& stream, const FontParams& params)
+	bool Font::OpenFromStream(Stream& stream, const FontParams& params)
 	{
 		return FontLoader::LoadFromStream(this, stream, params);
 	}

src/Nazara/Utility/Formats/DDSLoader.cpp

@@ -5,7 +5,7 @@
 #include <Nazara/Utility/Formats/DDSLoader.hpp>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Utility/Image.hpp>
 #include <Nazara/Utility/Formats/DDSConstants.hpp>
 #include <memory>
@@ -20,7 +20,7 @@ namespace Nz
 			return (extension == "dds");
 		}
 
-		Ternary Check(InputStream& stream, const ImageParams& parameters)
+		Ternary Check(Stream& stream, const ImageParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -38,7 +38,7 @@ namespace Nz
 			return Ternary_False;
 		}
 
-		bool Load(Image* image, InputStream& stream, const ImageParams& parameters)
+		bool Load(Image* image, Stream& stream, const ImageParams& parameters)
 		{
 			NazaraUnused(parameters);
 

src/Nazara/Utility/Formats/FreeTypeLoader.cpp

@@ -8,8 +8,8 @@
 #include FT_BITMAP_H
 #include FT_OUTLINE_H
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/MemoryView.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Utility/Font.hpp>
 #include <Nazara/Utility/FontData.hpp>
 #include <Nazara/Utility/FontGlyph.hpp>
@@ -31,7 +31,7 @@ namespace Nz
 		unsigned long FT_StreamRead(FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count)
 		{
 			// http://www.freetype.org/freetype2/docs/reference/ft2-system_interface.html#FT_Stream_IoFunc
-			InputStream& inputStream = *static_cast<InputStream*>(stream->descriptor.pointer);
+			Stream& inputStream = *static_cast<Stream*>(stream->descriptor.pointer);
 
 			// La valeur de count indique une opération de lecture ou de positionnement
 			if (count > 0)
@@ -298,7 +298,7 @@ namespace Nz
 					SetStream(*m_ownedStream);
 				}
 
-				void SetStream(InputStream& stream)
+				void SetStream(Stream& stream)
 				{
 					m_stream.base = nullptr;
 					m_stream.close = FT_StreamClose;
@@ -332,7 +332,7 @@ namespace Nz
 				FT_Face m_face;
 				FT_StreamRec m_stream;
 				std::shared_ptr<FreeTypeLibrary> m_library;
-				std::unique_ptr<InputStream> m_ownedStream;
+				std::unique_ptr<Stream> m_ownedStream;
 				mutable unsigned int m_characterSize;
 		};
 
@@ -346,7 +346,7 @@ namespace Nz
 			return supportedExtensions.find(extension) != supportedExtensions.end();
 		}
 
-		Ternary Check(InputStream& stream, const FontParams& parameters)
+		Ternary Check(Stream& stream, const FontParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -408,7 +408,7 @@ namespace Nz
 				return false;
 		}
 
-		bool LoadStream(Font* font, InputStream& stream, const FontParams& parameters)
+		bool LoadStream(Font* font, Stream& stream, const FontParams& parameters)
 		{
 			NazaraUnused(parameters);
 

src/Nazara/Utility/Formats/MD2Loader.cpp

@@ -5,7 +5,7 @@
 #include <Nazara/Utility/Formats/MD2Loader.hpp>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
@@ -26,7 +26,7 @@ namespace Nz
 			return (extension == "md2");
 		}
 
-		Ternary Check(InputStream& stream, const MeshParams& parameters)
+		Ternary Check(Stream& stream, const MeshParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -45,7 +45,7 @@ namespace Nz
 			return Ternary_False;
 		}
 
-		bool Load(Mesh* mesh, InputStream& stream, const MeshParams& parameters)
+		bool Load(Mesh* mesh, Stream& stream, const MeshParams& parameters)
 		{
 			MD2_Header header;
 			if (stream.Read(&header, sizeof(MD2_Header)) != sizeof(MD2_Header))

src/Nazara/Utility/Formats/MD5AnimLoader.cpp

@@ -15,7 +15,7 @@ namespace Nz
 			return (extension == "md5anim");
 		}
 
-		Ternary Check(InputStream& stream, const AnimationParams& parameters)
+		Ternary Check(Stream& stream, const AnimationParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -23,7 +23,7 @@ namespace Nz
 			return parser.Check();
 		}
 
-		bool Load(Animation* animation, InputStream& stream, const AnimationParams& parameters)
+		bool Load(Animation* animation, Stream& stream, const AnimationParams& parameters)
 		{
 			///TODO: Utiliser les paramètres
 			MD5AnimParser parser(stream);

src/Nazara/Utility/Formats/MD5AnimParser.cpp

@@ -15,22 +15,22 @@
 
 namespace Nz
 {
-	MD5AnimParser::MD5AnimParser(InputStream& stream) :
+	MD5AnimParser::MD5AnimParser(Stream& stream) :
 	m_stream(stream),
 	m_keepLastLine(false),
 	m_frameIndex(0),
 	m_frameRate(0),
 	m_lineCount(0),
-	m_streamFlags(stream.GetStreamOptions())
+	m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
 	{
-		if ((m_streamFlags & StreamOption_Text) == 0)
+		m_stream.EnableTextMode(true);
-			m_stream.SetStreamOptions(m_streamFlags | StreamOption_Text);
 	}
 
 	MD5AnimParser::~MD5AnimParser()
 	{
+		// Reset stream flags
 		if ((m_streamFlags & StreamOption_Text) == 0)
-			m_stream.SetStreamOptions(m_streamFlags);
+			m_stream.EnableTextMode(false);
 	}
 
 	Ternary MD5AnimParser::Check()

src/Nazara/Utility/Formats/MD5MeshLoader.cpp

@@ -20,7 +20,7 @@ namespace Nz
 			return (extension == "md5mesh");
 		}
 
-		Ternary Check(InputStream& stream, const MeshParams& parameters)
+		Ternary Check(Stream& stream, const MeshParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -28,7 +28,7 @@ namespace Nz
 			return parser.Check();
 		}
 
-		bool Load(Mesh* mesh, InputStream& stream, const MeshParams& parameters)
+		bool Load(Mesh* mesh, Stream& stream, const MeshParams& parameters)
 		{
 			MD5MeshParser parser(stream);
 			if (!parser.Parse())

src/Nazara/Utility/Formats/MD5MeshParser.cpp

@@ -21,21 +21,21 @@
 
 namespace Nz
 {
-	MD5MeshParser::MD5MeshParser(InputStream& stream) :
+	MD5MeshParser::MD5MeshParser(Stream& stream) :
 	m_stream(stream),
 	m_keepLastLine(false),
 	m_lineCount(0),
 	m_meshIndex(0),
-	m_streamFlags(stream.GetStreamOptions())
+	m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
 	{
-		if ((m_streamFlags & StreamOption_Text) == 0)
+		m_stream.EnableTextMode(true);
-			m_stream.SetStreamOptions(m_streamFlags | StreamOption_Text);
 	}
 
 	MD5MeshParser::~MD5MeshParser()
 	{
+		// Reset stream flags
 		if ((m_streamFlags & StreamOption_Text) == 0)
-			m_stream.SetStreamOptions(m_streamFlags);
+			m_stream.EnableTextMode(false);
 	}
 
 	Ternary MD5MeshParser::Check()

src/Nazara/Utility/Formats/MTLParser.cpp

@@ -12,18 +12,18 @@
 
 namespace Nz
 {
-	MTLParser::MTLParser(InputStream& stream) :
+	MTLParser::MTLParser(Stream& stream) :
 	m_stream(stream),
-	m_streamFlags(stream.GetStreamOptions())
+	m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
 	{
-		if ((m_streamFlags & StreamOption_Text) == 0)
+		m_stream.EnableTextMode(true);
-			m_stream.SetStreamOptions(m_streamFlags | StreamOption_Text);
 	}
 
 	MTLParser::~MTLParser()
 	{
+		// Reset stream flags
 		if ((m_streamFlags & StreamOption_Text) == 0)
-			m_stream.SetStreamOptions(m_streamFlags);
+			m_stream.EnableTextMode(false);
 	}
 
 	const MTLParser::Material* MTLParser::GetMaterial(const String& materialName) const

src/Nazara/Utility/Formats/OBJParser.cpp

@@ -13,18 +13,18 @@
 
 namespace Nz
 {
-	OBJParser::OBJParser(InputStream& stream) :
+	OBJParser::OBJParser(Stream& stream) :
 	m_stream(stream),
-	m_streamFlags(stream.GetStreamOptions())
+	m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
 	{
-		if ((m_streamFlags & StreamOption_Text) == 0)
+		m_stream.EnableTextMode(true);
-			m_stream.SetStreamOptions(m_streamFlags | StreamOption_Text);
 	}
 
 	OBJParser::~OBJParser()
 	{
+		// Reset stream flags
 		if ((m_streamFlags & StreamOption_Text) == 0)
-			m_stream.SetStreamOptions(m_streamFlags);
+			m_stream.EnableTextMode(false);
 	}
 
 	const String* OBJParser::GetMaterials() const

src/Nazara/Utility/Formats/PCXLoader.cpp

@@ -5,7 +5,7 @@
 #include <Nazara/Utility/Formats/PCXLoader.hpp>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Utility/Image.hpp>
 #include <memory>
 #include <Nazara/Utility/Debug.hpp>
@@ -45,7 +45,7 @@ namespace Nz
 			return (extension == "pcx");
 		}
 
-		Ternary Check(InputStream& stream, const ImageParams& parameters)
+		Ternary Check(Stream& stream, const ImageParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -59,7 +59,7 @@ namespace Nz
 			return Ternary_False;
 		}
 
-		bool Load(Image* image, InputStream& stream, const ImageParams& parameters)
+		bool Load(Image* image, Stream& stream, const ImageParams& parameters)
 		{
 			NazaraUnused(parameters);
 

src/Nazara/Utility/Formats/STBLoader.cpp

@@ -7,8 +7,8 @@
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/File.hpp>
-#include <Nazara/Core/InputStream.hpp>
 #include <Nazara/Core/MemoryView.hpp>
+#include <Nazara/Core/Stream.hpp>
 #include <Nazara/Utility/Image.hpp>
 #include <set>
 #include <Nazara/Utility/Debug.hpp>
@@ -19,19 +19,19 @@ namespace Nz
 	{
 		int Read(void* userdata, char* data, int size)
 		{
-			InputStream* stream = static_cast<InputStream*>(userdata);
+			Stream* stream = static_cast<Stream*>(userdata);
 			return static_cast<int>(stream->Read(data, size));
 		}
 
 		void Skip(void* userdata, int size)
 		{
-			InputStream* stream = static_cast<InputStream*>(userdata);
+			Stream* stream = static_cast<Stream*>(userdata);
 			stream->SetCursorPos(static_cast<Int64>(stream->GetCursorPos()) + static_cast<Int64>(size));
 		}
 
 		int Eof(void* userdata)
 		{
-			InputStream* stream = static_cast<InputStream*>(userdata);
+			Stream* stream = static_cast<Stream*>(userdata);
 			return stream->GetCursorPos() >= stream->GetSize();
 		}
 
@@ -43,7 +43,7 @@ namespace Nz
 			return supportedExtensions.find(extension) != supportedExtensions.end();
 		}
 
-		Ternary Check(InputStream& stream, const ImageParams& parameters)
+		Ternary Check(Stream& stream, const ImageParams& parameters)
 		{
 			NazaraUnused(parameters);
 
@@ -54,7 +54,7 @@ namespace Nz
 				return Ternary_False;
 		}
 
-		bool Load(Image* image, InputStream& stream, const ImageParams& parameters)
+		bool Load(Image* image, Stream& stream, const ImageParams& parameters)
 		{
 			// Je charge tout en RGBA8 et je converti ensuite via la méthode Convert
 			// Ceci à cause d'un bug de STB lorsqu'il s'agit de charger certaines images (ex: JPG) en "default"

src/Nazara/Utility/Image.cpp

@@ -831,7 +831,7 @@ namespace Nz
 		return ImageLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Image::LoadFromStream(InputStream& stream, const ImageParams& params)
+	bool Image::LoadFromStream(Stream& stream, const ImageParams& params)
 	{
 		return ImageLoader::LoadFromStream(this, stream, params);
 	}
@@ -923,7 +923,7 @@ namespace Nz
 		return LoadArrayFromImage(image, atlasSize);
 	}
 
-	bool Image::LoadArrayFromStream(InputStream& stream, const ImageParams& imageParams, const Vector2ui& atlasSize)
+	bool Image::LoadArrayFromStream(Stream& stream, const ImageParams& imageParams, const Vector2ui& atlasSize)
 	{
 		Image image;
 		if (!image.LoadFromStream(stream, imageParams))
@@ -1054,7 +1054,7 @@ namespace Nz
 		return LoadCubemapFromImage(image, cubemapParams);
 	}
 
-	bool Image::LoadCubemapFromStream(InputStream& stream, const ImageParams& imageParams, const CubemapParams& cubemapParams)
+	bool Image::LoadCubemapFromStream(Stream& stream, const ImageParams& imageParams, const CubemapParams& cubemapParams)
 	{
 		Image image;
 		if (!image.LoadFromStream(stream, imageParams))

src/Nazara/Utility/Mesh.cpp

@@ -795,7 +795,7 @@ namespace Nz
 		return MeshLoader::LoadFromMemory(this, data, size, params);
 	}
 
-	bool Mesh::LoadFromStream(InputStream& stream, const MeshParams& params)
+	bool Mesh::LoadFromStream(Stream& stream, const MeshParams& params)
 	{
 		return MeshLoader::LoadFromStream(this, stream, params);
 	}