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

Reworked ResourceLoader 

Former-commit-id: 9809e7fcd3657dfe90a0795986d0918f4ae1823c
This commit is contained in:
Lynix 2013-03-23 22:49:06 +01:00
parent 0603590549
commit 8f21a75c43
8 changed files with 121 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,7 +9,6 @@
#include <Nazara/Core/String.hpp>
#include <list>
#include <set>
#include <tuple>
class NzInputStream;
@ -18,17 +17,21 @@ template<typename Type, typename Parameters>
class NzResourceLoader
{
public:
using CheckFunction = bool (*)(NzInputStream& stream, const Parameters& parameters);
using LoadFunction = bool (*)(Type* resource, NzInputStream& stream, const Parameters& parameters);
using ExtensionGetter = bool (*)(const NzString& extension);
using FileLoader = bool (*)(Type* resource, const NzString& filePath, const Parameters& parameters);
using StreamChecker = bool (*)(NzInputStream& stream, const Parameters& parameters);
using StreamLoader = bool (*)(Type* resource, NzInputStream& stream, const Parameters& parameters);
static bool IsExtensionSupported(const NzString& extension);
static bool LoadFromFile(Type* resource, const NzString& 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, NzInputStream& stream, const Parameters& parameters = Parameters());
static void RegisterLoader(const NzString& fileExtensions, CheckFunction checkFunc, LoadFunction loadfunc);
static void UnregisterLoader(const NzString& fileExtensions, CheckFunction checkFunc, LoadFunction loadfunc);
static void RegisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader = nullptr);
static void UnregisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader = nullptr);
using Loader = std::tuple<std::set<NzString>, CheckFunction, LoadFunction>;
using Loader = std::tuple<ExtensionGetter, StreamChecker, StreamLoader, FileLoader>;
using LoaderList = std::list<Loader>;
};

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

@ -9,6 +9,20 @@
#include <Nazara/Core/MemoryStream.hpp>
#include <Nazara/Core/Debug.hpp>
template<typename Type, typename Parameters>
bool NzResourceLoader<Type, Parameters>::IsExtensionSupported(const NzString& extension)
{
for (auto loader = Type::s_loaders.begin(); loader != Type::s_loaders.end(); ++loader)
{
ExtensionGetter isExtensionSupported = std::get<0>(*loader);
if (isExtensionSupported && isExtensionSupported(extension))
return true;
}
return false;
}
template<typename Type, typename Parameters>
bool NzResourceLoader<Type, Parameters>::LoadFromFile(Type* resource, const NzString& filePath, const Parameters& parameters)
{
@ -28,38 +42,54 @@ bool NzResourceLoader<Type, Parameters>::LoadFromFile(Type* resource, const NzSt
return false;
}
NzFile file(path, NzFile::ReadOnly);
if (!file.IsOpen())
{
NazaraError("Failed to open \"" + path + '"');
return false;
}
NzFile file(path); // Ouvert seulement en cas de besoin
for (auto loader = Type::s_loaders.begin(); loader != Type::s_loaders.end(); ++loader)
{
for (const NzString& loaderExt : std::get<0>(*loader))
ExtensionGetter isExtensionSupported = std::get<0>(*loader);
if (!isExtensionSupported || !isExtensionSupported(ext))
continue;
StreamChecker checkFunc = std::get<1>(*loader);
StreamLoader streamLoader = std::get<2>(*loader);
FileLoader fileLoader = std::get<3>(*loader);
if (checkFunc && !file.IsOpen())
{
int cmp = NzString::Compare(loaderExt, ext);
if (cmp == 0)
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to load file: unable to open file");
return false;
}
}
if (fileLoader)
{
if (checkFunc)
{
file.SetCursorPos(0);
if (!std::get<1>(*loader)(file, parameters))
if (!checkFunc(file, parameters))
continue;
file.SetCursorPos(0);
// Chargement de la ressource
if (std::get<2>(*loader)(resource, file, parameters))
return true;
NazaraWarning("Loader failed");
}
else if (cmp < 0) // S'il est encore possible que l'extension se situe après
if (fileLoader(resource, filePath, parameters))
return true;
}
else
{
file.SetCursorPos(0);
if (!checkFunc(file, parameters))
continue;
break;
file.SetCursorPos(0);
if (streamLoader(resource, file, parameters))
return true;
}
NazaraWarning("Loader failed");
}
NazaraError("Failed to load file: no loader");
@ -95,17 +125,20 @@ bool NzResourceLoader<Type, Parameters>::LoadFromStream(Type* resource, NzInputS
nzUInt64 streamPos = stream.GetCursorPos();
for (auto loader = Type::s_loaders.begin(); loader != Type::s_loaders.end(); ++loader)
{
StreamChecker checkFunc = std::get<1>(*loader);
StreamLoader streamLoader = std::get<2>(*loader);
stream.SetCursorPos(streamPos);
// Le loader supporte-t-il les données ?
if (!std::get<1>(*loader)(stream, parameters))
if (!checkFunc(stream, parameters))
continue;
// On repositionne le stream à son ancienne position
stream.SetCursorPos(streamPos);
// Chargement de la ressource
if (std::get<2>(*loader)(resource, stream, parameters))
if (streamLoader(resource, stream, parameters))
return true;
NazaraWarning("Loader failed");
@ -116,28 +149,31 @@ bool NzResourceLoader<Type, Parameters>::LoadFromStream(Type* resource, NzInputS
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::RegisterLoader(const NzString& fileExtensions, CheckFunction checkFunc, LoadFunction loadFunc)
void NzResourceLoader<Type, Parameters>::RegisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader)
{
///FIXME: Trouver une alternative à ce code monstrueux
std::vector<NzString> exts;
fileExtensions.SplitAny(exts, " /\\.,;|-_");
#if NAZARA_CORE_SAFE
if (streamLoader)
{
if (!checkFunc)
{
NazaraError("StreamLoader present without StreamChecker");
return;
}
}
else if (!fileLoader)
{
NazaraError("Neither FileLoader nor StreamLoader were found");
return;
}
#endif
std::set<NzString> extensions;
std::copy(exts.begin(), exts.end(), std::inserter(extensions, extensions.begin()));
Type::s_loaders.push_front(std::make_tuple(std::move(extensions), checkFunc, loadFunc));
Type::s_loaders.push_front(std::make_tuple(extensionGetter, checkFunc, streamLoader, fileLoader));
}
template<typename Type, typename Parameters>
void NzResourceLoader<Type, Parameters>::UnregisterLoader(const NzString& fileExtensions, CheckFunction checkFunc, LoadFunction loadFunc)
void NzResourceLoader<Type, Parameters>::UnregisterLoader(ExtensionGetter extensionGetter, StreamChecker checkFunc, StreamLoader streamLoader, FileLoader fileLoader)
{
std::vector<NzString> exts;
fileExtensions.SplitAny(exts, " /\\.,;|-_");
std::set<NzString> extensions;
std::copy(exts.begin(), exts.end(), std::inserter(extensions, extensions.begin()));
Type::s_loaders.remove(std::make_tuple(std::move(extensions), checkFunc, loadFunc));
Type::s_loaders.remove(std::make_tuple(extensionGetter, checkFunc, streamLoader, fileLoader));
}
#include <Nazara/Core/DebugOff.hpp>

5
src/Nazara/Renderer/Loaders/Texture/Loader.cpp
View File

@ -38,11 +38,10 @@ namespace
void NzLoaders_Texture_Register()
{
///FIXME: Pas bon
NzMaterialLoader::RegisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", Check, Load);
NzMaterialLoader::RegisterLoader(NzImageLoader::IsExtensionSupported, Check, Load);
}
void NzLoaders_Texture_Unregister()
{
NzMaterialLoader::UnregisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", Check, Load);
NzMaterialLoader::UnregisterLoader(NzImageLoader::IsExtensionSupported, Check, Load);
}

10
src/Nazara/Utility/Loaders/MD2/Loader.cpp
View File

@ -19,7 +19,11 @@
namespace
{
/// Loader de mesh
bool IsSupported(const NzString& extension)
{
return (extension == "md2");
}
bool Check(NzInputStream& stream, const NzMeshParams& parameters)
{
NazaraUnused(parameters);
@ -221,10 +225,10 @@ namespace
void NzLoaders_MD2_Register()
{
NzMeshLoader::RegisterLoader("md2", Check, Load);
NzMeshLoader::RegisterLoader(IsSupported, Check, Load);
}
void NzLoaders_MD2_Unregister()
{
NzMeshLoader::UnregisterLoader("md2", Check, Load);
NzMeshLoader::UnregisterLoader(IsSupported, Check, Load);
}

9
src/Nazara/Utility/Loaders/MD5Anim/Loader.cpp
View File

@ -8,6 +8,11 @@
namespace
{
bool IsSupported(const NzString& extension)
{
return (extension == "md5anim");
}
bool Check(NzInputStream& stream, const NzAnimationParams& parameters)
{
NzMD5AnimParser parser(stream, parameters);
@ -23,10 +28,10 @@ namespace
void NzLoaders_MD5Anim_Register()
{
NzAnimationLoader::RegisterLoader("md5anim", Check, Load);
NzAnimationLoader::RegisterLoader(IsSupported, Check, Load);
}
void NzLoaders_MD5Anim_Unregister()
{
NzAnimationLoader::UnregisterLoader("md5anim", Check, Load);
NzAnimationLoader::UnregisterLoader(IsSupported, Check, Load);
}

9
src/Nazara/Utility/Loaders/MD5Mesh/Loader.cpp
View File

@ -8,6 +8,11 @@
namespace
{
bool IsSupported(const NzString& extension)
{
return (extension == "md5mesh");
}
bool Check(NzInputStream& stream, const NzMeshParams& parameters)
{
NzMD5MeshParser parser(stream, parameters);
@ -23,10 +28,10 @@ namespace
void NzLoaders_MD5Mesh_Register()
{
NzMeshLoader::RegisterLoader("md5mesh", Check, Load);
NzMeshLoader::RegisterLoader(IsSupported, Check, Load);
}
void NzLoaders_MD5Mesh_Unregister()
{
NzMeshLoader::UnregisterLoader("md5mesh", Check, Load);
NzMeshLoader::UnregisterLoader(IsSupported, Check, Load);
}

9
src/Nazara/Utility/Loaders/PCX/Loader.cpp
View File

@ -39,6 +39,11 @@ namespace
//static_assert(sizeof(pcx_header) == 1024, "PCX header must be 1024 bytes sized");
bool IsSupported(const NzString& extension)
{
return (extension == "pcx");
}
bool Check(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
@ -339,10 +344,10 @@ namespace
void NzLoaders_PCX_Register()
{
NzImageLoader::RegisterLoader("pcx", Check, Load);
NzImageLoader::RegisterLoader(IsSupported, Check, Load);
}
void NzLoaders_PCX_Unregister()
{
NzImageLoader::UnregisterLoader("pcx", Check, Load);
NzImageLoader::UnregisterLoader(IsSupported, Check, Load);
}

10
src/Nazara/Utility/Loaders/STB/Loader.cpp
View File

@ -37,6 +37,12 @@ namespace
static stbi_io_callbacks callbacks = {Read, Skip, Eof};
bool IsSupported(const NzString& extension)
{
static std::set<NzString> supportedExtensions = {"bmp", "gif", "hdr", "jpg", "jpeg", "pic", "png", "psd", "tga"};
return supportedExtensions.find(extension) != supportedExtensions.end();
}
bool Check(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
@ -117,10 +123,10 @@ namespace
void NzLoaders_STB_Register()
{
NzImageLoader::RegisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", Check, Load);
NzImageLoader::RegisterLoader(IsSupported, Check, Load);
}
void NzLoaders_STB_Unregister()
{
NzImageLoader::UnregisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", Check, Load);
NzImageLoader::UnregisterLoader(IsSupported, Check, Load);
}