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

Rewritted ResourceLoader and moved it to core

Browse Source 
Added creation constructor to NzImage
Added member function functor
Added option to build Nazara as one library (instead of many)
Fixed some 2011 copyrights
Made use of "using def = T" C++11 feature instead of some illigible
typedefs
Removed unused premake file
This commit is contained in:
Lynix
2012-08-18 01:46:01 +02:00
parent 5619ddb0b1
commit 15afde86c8
51 changed files with 542 additions and 629 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,4 +1,4 @@
// Copyright (C) 2011 Jérôme Leclercq
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Utility module"
// For conditions of distribution and use, see copyright notice in Config.hpp
@@ -18,27 +18,23 @@
namespace
{
bool NzLoader_MD2_LoadStream(NzMesh* mesh, NzInputStream& stream, const NzMeshParams& parameters);
bool NzLoader_MD2_LoadFile(NzMesh* mesh, const NzString& filePath, const NzMeshParams& parameters)
bool NzLoader_MD2_Check(NzInputStream& stream, const NzMeshParams& parameters)
{
NzFile file(filePath);
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to open file");
NazaraUnused(parameters);
nzUInt32 magic[2];
if (stream.Read(&magic[0], 2*sizeof(nzUInt32)) != 2*sizeof(nzUInt32))
return false;
}
return NzLoader_MD2_LoadStream(mesh, file, parameters);
#if defined(NAZARA_BIG_ENDIAN)
NzByteSwap(&magic[0], sizeof(nzUInt32));
NzByteSwap(&magic[1], sizeof(nzUInt32));
#endif
return magic[0] == md2Ident && magic[1] == 8;
}
bool NzLoader_MD2_LoadMemory(NzMesh* mesh, const void* data, unsigned int size, const NzMeshParams& parameters)
{
NzMemoryStream stream(data, size);
return NzLoader_MD2_LoadStream(mesh, stream, parameters);
}
bool NzLoader_MD2_LoadStream(NzMesh* mesh, NzInputStream& stream, const NzMeshParams& parameters)
bool NzLoader_MD2_Load(NzMesh* mesh, NzInputStream& stream, const NzMeshParams& parameters)
{
md2_header header;
if (stream.Read(&header, sizeof(md2_header)) != sizeof(md2_header))
@@ -208,60 +204,18 @@ namespace
return true;
}
bool NzLoader_MD2_IdentifyMemory(const void* data, unsigned int size, const NzMeshParams& parameters)
{
NazaraUnused(parameters);
if (size < sizeof(md2_header))
return false;
const md2_header* header = reinterpret_cast<const md2_header*>(data);
#if defined(NAZARA_BIG_ENDIAN)
nzUInt32 ident = header->ident;
nzUInt32 version = header->version;
NzByteSwap(&ident, sizeof(nzUInt32));
NzByteSwap(&version, sizeof(nzUInt32));
return ident == md2Ident && version == 8;
#else
return header->ident == md2Ident && header->version == 8;
#endif
}
bool NzLoader_MD2_IdentifyStream(NzInputStream& stream, const NzMeshParams& parameters)
{
NazaraUnused(parameters);
nzUInt32 magic[2];
if (stream.Read(&magic[0], 2*sizeof(nzUInt32)) != 2*sizeof(nzUInt32))
return false;
#if defined(NAZARA_BIG_ENDIAN)
NzByteSwap(&magic[0], sizeof(nzUInt32));
NzByteSwap(&magic[1], sizeof(nzUInt32));
#endif
return magic[0] == md2Ident && magic[1] == 8;
}
}
void NzLoaders_MD2_Register()
{
NzMD2Mesh::Initialize();
NzMeshLoader::RegisterFileLoader("md2", NzLoader_MD2_LoadFile);
NzMeshLoader::RegisterMemoryLoader(NzLoader_MD2_IdentifyMemory, NzLoader_MD2_LoadMemory);
NzMeshLoader::RegisterStreamLoader(NzLoader_MD2_IdentifyStream, NzLoader_MD2_LoadStream);
NzMeshLoader::RegisterLoader("md2", NzLoader_MD2_Check, NzLoader_MD2_Load);
}
void NzLoaders_MD2_Unregister()
{
NzMeshLoader::UnregisterStreamLoader(NzLoader_MD2_IdentifyStream, NzLoader_MD2_LoadStream);
NzMeshLoader::UnregisterMemoryLoader(NzLoader_MD2_IdentifyMemory, NzLoader_MD2_LoadMemory);
NzMeshLoader::UnregisterFileLoader("md2", NzLoader_MD2_LoadFile);
NzMeshLoader::UnregisterLoader("md2", NzLoader_MD2_Check, NzLoader_MD2_Load);
NzMD2Mesh::Uninitialize();
}

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

@@ -1,4 +1,4 @@
// Copyright (C) 2011 Jérôme Leclercq
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Utility module"
// For conditions of distribution and use, see copyright notice in Config.hpp

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

@@ -37,27 +37,18 @@ namespace
nzUInt8 padding[54];
};
bool NzLoader_PCX_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters);
bool NzLoader_PCX_LoadFile(NzImage* image, const NzString& filePath, const NzImageParams& parameters)
bool NzLoader_PCX_Check(NzInputStream& stream, const NzImageParams& parameters)
{
NzFile file(filePath);
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to open file");
NazaraUnused(parameters);
nzUInt8 manufacturer;
if (stream.Read(&manufacturer, 1) != 1)
return false;
}
return NzLoader_PCX_LoadStream(image, file, parameters);
return manufacturer == 0x0a;
}
bool NzLoader_PCX_LoadMemory(NzImage* image, const void* data, unsigned int size, const NzImageParams& parameters)
{
NzMemoryStream stream(data, size);
return NzLoader_PCX_LoadStream(image, stream, parameters);
}
bool NzLoader_PCX_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
bool NzLoader_PCX_Load(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
@@ -348,39 +339,14 @@ namespace
return true;
}
bool NzLoader_PCX_IdentifyMemory(const void* data, unsigned int size, const NzImageParams& parameters)
{
NazaraUnused(parameters);
if (size < sizeof(pcx_header))
return false;
return *reinterpret_cast<const nzUInt8*>(data) == 0x0a;
}
bool NzLoader_PCX_IdentifyStream(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
nzUInt8 manufacturer;
if (stream.Read(&manufacturer, 1) != 1)
return false;
return manufacturer == 0x0a;
}
}
void NzLoaders_PCX_Register()
{
NzImageLoader::RegisterFileLoader("pcx", NzLoader_PCX_LoadFile);
NzImageLoader::RegisterMemoryLoader(NzLoader_PCX_IdentifyMemory, NzLoader_PCX_LoadMemory);
NzImageLoader::RegisterStreamLoader(NzLoader_PCX_IdentifyStream, NzLoader_PCX_LoadStream);
NzImageLoader::RegisterLoader("pcx", NzLoader_PCX_Check, NzLoader_PCX_Load);
}
void NzLoaders_PCX_Unregister()
{
NzImageLoader::UnregisterStreamLoader(NzLoader_PCX_IdentifyStream, NzLoader_PCX_LoadStream);
NzImageLoader::UnregisterMemoryLoader(NzLoader_PCX_IdentifyMemory, NzLoader_PCX_LoadMemory);
NzImageLoader::UnregisterFileLoader("pcx", NzLoader_PCX_LoadFile);
NzImageLoader::UnregisterLoader("pcx", NzLoader_PCX_Check, NzLoader_PCX_Load);
}

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

@@ -1,4 +1,4 @@
// Copyright (C) 2011 Jérôme Leclercq
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Utility module"
// For conditions of distribution and use, see copyright notice in Config.hpp
@@ -37,30 +37,16 @@ namespace
static stbi_io_callbacks callbacks = {Read, Skip, Eof};
bool NzLoader_STB_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters);
bool NzLoader_STB_LoadFile(NzImage* image, const NzString& filePath, const NzImageParams& parameters)
{
NzFile file(filePath);
if (!file.Open(NzFile::ReadOnly))
{
NazaraError("Failed to open file");
return false;
}
return NzLoader_STB_LoadStream(image, file, parameters);
}
bool NzLoader_STB_LoadMemory(NzImage* image, const void* data, unsigned int size, const NzImageParams& parameters)
{
NzMemoryStream stream(data, size);
return NzLoader_STB_LoadStream(image, stream, parameters);
}
bool NzLoader_STB_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
bool NzLoader_STB_Check(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
int width, height, bpp;
return stbi_info_from_callbacks(&callbacks, &stream, &width, &height, &bpp);
}
bool NzLoader_STB_Load(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
{
static const nzPixelFormat formats[4] =
{
nzPixelFormat_L8,
@@ -127,34 +113,14 @@ namespace
return true;
}
bool NzLoader_STB_IdentifyMemory(const void* data, unsigned int size, const NzImageParams& parameters)
{
NazaraUnused(parameters);
int width, height, bpp;
return stbi_info_from_memory(reinterpret_cast<const stbi_uc*>(data), size, &width, &height, &bpp);
}
bool NzLoader_STB_IdentifyStream(NzInputStream& stream, const NzImageParams& parameters)
{
NazaraUnused(parameters);
int width, height, bpp;
return stbi_info_from_callbacks(&callbacks, &stream, &width, &height, &bpp);
}
}
void NzLoaders_STB_Register()
{
NzImageLoader::RegisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
NzImageLoader::RegisterMemoryLoader(NzLoader_STB_IdentifyMemory, NzLoader_STB_LoadMemory);
NzImageLoader::RegisterStreamLoader(NzLoader_STB_IdentifyStream, NzLoader_STB_LoadStream);
NzImageLoader::RegisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", NzLoader_STB_Check, NzLoader_STB_Load);
}
void NzLoaders_STB_Unregister()
{
NzImageLoader::UnregisterStreamLoader(NzLoader_STB_IdentifyStream, NzLoader_STB_LoadStream);
NzImageLoader::UnregisterMemoryLoader(NzLoader_STB_IdentifyMemory, NzLoader_STB_LoadMemory);
NzImageLoader::UnregisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
NzImageLoader::UnregisterLoader("bmp,gif,hdr,jpg,jpeg,pic,png,psd,tga", NzLoader_STB_Check, NzLoader_STB_Load);
}