sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Core: Merge InputStream and OutputStream to Stream 

Remove serialization support from Stream


Former-commit-id: 7a761e4fcd07cab561f13e4709c4492ed18da88a
This commit is contained in:
Lynix 2015-11-20 13:52:49 +01:00
parent a47e5633d4
commit ed961f5ba8
66 changed files with 372 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/Nazara/Audio/Music.hpp
View File

@ -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();

2
include/Nazara/Audio/Sound.hpp
View File

@ -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();

4
include/Nazara/Audio/SoundBuffer.hpp
View File

@ -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);

1
include/Nazara/Audio/SoundEmitter.hpp
View File

@ -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

2
include/Nazara/Core.hpp
View File

@ -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>

3
include/Nazara/Core/Algorithm.inl
View File

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

7
include/Nazara/Core/ByteArray.inl
View File

@ -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);

6
include/Nazara/Core/Enums.hpp
View File

@ -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
};

15
include/Nazara/Core/File.hpp
View File

@ -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/OutputStream.hpp>
#include <Nazara/Core/Stream.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;
};

45
include/Nazara/Core/InputStream.hpp
View File

@ -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

63
include/Nazara/Core/InputStream.inl
View File

@ -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>

16
include/Nazara/Core/MemoryStream.hpp
View File

@ -9,12 +9,11 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/ByteArray.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Core/OutputStream.hpp>
#include <Nazara/Core/Stream.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

10
include/Nazara/Core/MemoryView.hpp
View File

@ -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;

47
include/Nazara/Core/OutputStream.hpp
View File

@ -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

63
include/Nazara/Core/OutputStream.inl
View File

@ -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>

8
include/Nazara/Core/ResourceLoader.hpp
View File

@ -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 StreamLoader = bool (*)(Type* resource, InputStream& stream, const Parameters& parameters);
using StreamChecker = Ternary (*)(Stream& 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);

4
include/Nazara/Core/ResourceLoader.inl
View File

@ -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())

7
include/Nazara/Core/Serialization.hpp
View File

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

26
include/Nazara/Core/Stream.hpp
View File

@ -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;
};

44
include/Nazara/Core/Stream.inl
View File

@ -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);
}
}

2
include/Nazara/Graphics/Material.hpp
View File

@ -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();

2
include/Nazara/Graphics/Model.hpp
View File

@ -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();

2
include/Nazara/Graphics/SkeletalModel.hpp
View File

@ -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();

4
include/Nazara/Lua/LuaInstance.hpp
View File

@ -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;

8
include/Nazara/Renderer/Texture.hpp
View File

@ -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);

2
include/Nazara/Utility/Animation.hpp
View File

@ -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);

2
include/Nazara/Utility/Font.hpp
View File

@ -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);

6
include/Nazara/Utility/Formats/MD5AnimParser.hpp
View File

@ -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;

6
include/Nazara/Utility/Formats/MD5MeshParser.hpp
View File

@ -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;

6
include/Nazara/Utility/Formats/MTLParser.hpp
View File

@ -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;

6
include/Nazara/Utility/Formats/OBJParser.hpp
View File

@ -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;

8
include/Nazara/Utility/Image.hpp
View File

@ -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);

4
include/Nazara/Utility/Mesh.hpp
View File

@ -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();

22
src/Nazara/Audio/Formats/sndfileLoader.cpp
View File

@ -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;

2
src/Nazara/Audio/Music.cpp
View File

@ -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);
}

2
src/Nazara/Audio/Sound.cpp
View File

@ -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))

2
src/Nazara/Audio/SoundBuffer.cpp
View File

@ -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);
}

96
src/Nazara/Core/File.cpp
View File

@ -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());

71
src/Nazara/Core/InputStream.cpp
View File

@ -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;
}
}

28
src/Nazara/Core/MemoryStream.cpp
View File

@ -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)
{
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 MemoryStream::WriteBlock(const void* buffer, std::size_t size)
{
std::size_t endPos = static_cast<std::size_t>(m_pos + size);
if (endPos > m_buffer.size())

21
src/Nazara/Core/MemoryView.cpp
View File

@ -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);
return true;
NazaraInternalError("WriteBlock has been called on a MemoryView");
return 0;
}
}

40
src/Nazara/Core/OutputStream.cpp
View File

@ -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;
}
}

84
src/Nazara/Core/Stream.cpp
View File

@ -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;
}
}

8
src/Nazara/Graphics/Formats/MeshLoader.cpp
View File

@ -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);

4
src/Nazara/Graphics/Formats/OBJLoader.cpp
View File

@ -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())

4
src/Nazara/Graphics/Formats/TextureLoader.cpp
View File

@ -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);

2
src/Nazara/Graphics/Material.cpp
View File

@ -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);
}

2
src/Nazara/Graphics/Model.cpp
View File

@ -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);
}

2
src/Nazara/Graphics/SkeletalModel.cpp
View File

@ -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);
}

4
src/Nazara/Lua/LuaInstance.cpp
View File

@ -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;

8
src/Nazara/Renderer/Texture.cpp
View File

@ -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)

2
src/Nazara/Utility/Animation.cpp
View File

@ -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);
}

2
src/Nazara/Utility/Font.cpp
View File

@ -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);
}

6
src/Nazara/Utility/Formats/DDSLoader.cpp
View File

@ -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);

12
src/Nazara/Utility/Formats/FreeTypeLoader.cpp
View File

@ -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);

6
src/Nazara/Utility/Formats/MD2Loader.cpp
View File

@ -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))

4
src/Nazara/Utility/Formats/MD5AnimLoader.cpp
View File

@ -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);

10
src/Nazara/Utility/Formats/MD5AnimParser.cpp
View File

@ -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.SetStreamOptions(m_streamFlags | StreamOption_Text);
m_stream.EnableTextMode(true);
}
MD5AnimParser::~MD5AnimParser()
{
// Reset stream flags
if ((m_streamFlags & StreamOption_Text) == 0)
m_stream.SetStreamOptions(m_streamFlags);
m_stream.EnableTextMode(false);
}
Ternary MD5AnimParser::Check()

4
src/Nazara/Utility/Formats/MD5MeshLoader.cpp
View File

@ -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())

10
src/Nazara/Utility/Formats/MD5MeshParser.cpp
View File

@ -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.SetStreamOptions(m_streamFlags | StreamOption_Text);
m_stream.EnableTextMode(true);
}
MD5MeshParser::~MD5MeshParser()
{
// Reset stream flags
if ((m_streamFlags & StreamOption_Text) == 0)
m_stream.SetStreamOptions(m_streamFlags);
m_stream.EnableTextMode(false);
}
Ternary MD5MeshParser::Check()

10
src/Nazara/Utility/Formats/MTLParser.cpp
View File

@ -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.SetStreamOptions(m_streamFlags | StreamOption_Text);
m_stream.EnableTextMode(true);
}
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

10
src/Nazara/Utility/Formats/OBJParser.cpp
View File

@ -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.SetStreamOptions(m_streamFlags | StreamOption_Text);
m_stream.EnableTextMode(true);
}
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

6
src/Nazara/Utility/Formats/PCXLoader.cpp
View File

@ -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);

12
src/Nazara/Utility/Formats/STBLoader.cpp
View File

@ -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"

6
src/Nazara/Utility/Image.cpp
View File

@ -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))

2
src/Nazara/Utility/Mesh.cpp
View File

@ -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);
}