Rename and move loaders, expose parsers

Former-commit-id: 932ae2aab020f956d3fdb91107f6842ff292aa08

src/Nazara/Utility/Formats/DDSConstants.hpp

@@ -0,0 +1,374 @@
+// Copyright (C) 2009 Cruden BV - 2014 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
+
+#pragma once
+
+#ifndef NAZARA_LOADERS_DDS_CONSTANTS_HPP
+#define NAZARA_LOADERS_DDS_CONSTANTS_HPP
+
+#define DDS_MAGIC                  0x20534444
+#define DDS_DXT1                   0x31545844
+#define DDS_DXT3                   0x33545844
+#define DDS_DXT5                   0x35545844
+
+inline constexpr nzUInt32 FourCC(nzUInt32 a, nzUInt32 b, nzUInt32 c, nzUInt32 d)
+{
+	return a <<  0 |
+	       b <<  8 |
+	       c << 16 |
+	       d << 24;
+}
+
+enum D3D10_RESOURCE_DIMENSION : nzUInt32
+{
+	D3D10_RESOURCE_DIMENSION_UNKNOWN   = 0,
+	D3D10_RESOURCE_DIMENSION_BUFFER    = 1,
+	D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2,
+	D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3,
+	D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4
+};
+
+enum D3D10_RESOURCE_MISC
+{
+	D3D10_RESOURCE_MISC_GENERATE_MIPS     = 0x1L,
+	D3D10_RESOURCE_MISC_SHARED            = 0x2L,
+	D3D10_RESOURCE_MISC_TEXTURECUBE       = 0x4L,
+	D3D10_RESOURCE_MISC_SHARED_KEYEDMUTEX = 0x10L,
+	D3D10_RESOURCE_MISC_GDI_COMPATIBLE    = 0x20L
+};
+
+enum D3DFMT : nzUInt32
+{
+	D3DFMT_UNKNOWN              =  0,
+
+	D3DFMT_R8G8B8               = 20,
+	D3DFMT_A8R8G8B8             = 21,
+	D3DFMT_X8R8G8B8             = 22,
+	D3DFMT_R5G6B5               = 23,
+	D3DFMT_X1R5G5B5             = 24,
+	D3DFMT_A1R5G5B5             = 25,
+	D3DFMT_A4R4G4B4             = 26,
+	D3DFMT_R3G3B2               = 27,
+	D3DFMT_A8                   = 28,
+	D3DFMT_A8R3G3B2             = 29,
+	D3DFMT_X4R4G4B4             = 30,
+	D3DFMT_A2B10G10R10          = 31,
+	D3DFMT_A8B8G8R8             = 32,
+	D3DFMT_X8B8G8R8             = 33,
+	D3DFMT_G16R16               = 34,
+	D3DFMT_A2R10G10B10          = 35,
+	D3DFMT_A16B16G16R16         = 36,
+
+	D3DFMT_A8P8                 = 40,
+	D3DFMT_P8                   = 41,
+
+	D3DFMT_L8                   = 50,
+	D3DFMT_A8L8                 = 51,
+	D3DFMT_A4L4                 = 52,
+
+	D3DFMT_V8U8                 = 60,
+	D3DFMT_L6V5U5               = 61,
+	D3DFMT_X8L8V8U8             = 62,
+	D3DFMT_Q8W8V8U8             = 63,
+	D3DFMT_V16U16               = 64,
+	D3DFMT_A2W10V10U10          = 67,
+
+	D3DFMT_UYVY                 = FourCC('U', 'Y', 'V', 'Y'),
+	D3DFMT_R8G8_B8G8            = FourCC('R', 'G', 'B', 'G'),
+	D3DFMT_YUY2                 = FourCC('Y', 'U', 'Y', '2'),
+	D3DFMT_G8R8_G8B8            = FourCC('G', 'R', 'G', 'B'),
+	D3DFMT_DXT1                 = FourCC('D', 'X', 'T', '1'),
+	D3DFMT_DXT2                 = FourCC('D', 'X', 'T', '2'),
+	D3DFMT_DXT3                 = FourCC('D', 'X', 'T', '3'),
+	D3DFMT_DXT4                 = FourCC('D', 'X', 'T', '4'),
+	D3DFMT_DXT5                 = FourCC('D', 'X', 'T', '5'),
+
+	D3DFMT_D16_LOCKABLE         = 70,
+	D3DFMT_D32                  = 71,
+	D3DFMT_D15S1                = 73,
+	D3DFMT_D24S8                = 75,
+	D3DFMT_D24X8                = 77,
+	D3DFMT_D24X4S4              = 79,
+	D3DFMT_D16                  = 80,
+
+	D3DFMT_D32F_LOCKABLE        = 82,
+	D3DFMT_D24FS8               = 83,
+
+	D3DFMT_L16                  = 81,
+
+	D3DFMT_VERTEXDATA           = 100,
+	D3DFMT_INDEX16              = 101,
+	D3DFMT_INDEX32              = 102,
+
+	D3DFMT_Q16W16V16U16         = 110,
+
+	D3DFMT_MULTI2_ARGB8         = FourCC('M','E','T','1'),
+
+	D3DFMT_R16F                 = 111,
+	D3DFMT_G16R16F              = 112,
+	D3DFMT_A16B16G16R16F        = 113,
+
+	D3DFMT_R32F                 = 114,
+	D3DFMT_G32R32F              = 115,
+	D3DFMT_A32B32G32R32F        = 116,
+
+	D3DFMT_CxV8U8               = 117,
+
+	D3DFMT_DX10                 = FourCC('D', 'X', '1', '0')
+};
+
+enum DDPF
+{
+	DDPF_ALPHAPIXELS = 0x00001,
+	DDPF_ALPHA       = 0x00002,
+	DDPF_FOURCC      = 0x00004,
+	DDPF_RGB         = 0x00040,
+	DDPF_YUV         = 0x00200,
+	DDPF_LUMINANCE   = 0x20000
+};
+
+enum DDSD
+{
+	DDSD_CAPS			= 0x00000001,
+	DDSD_HEIGHT			= 0x00000002,
+	DDSD_WIDTH			= 0x00000004,
+	DDSD_PITCH			= 0x00000008,
+	DDSD_PIXELFORMAT	= 0x00001000,
+	DDSD_MIPMAPCOUNT	= 0x00020000,
+	DDSD_LINEARSIZE		= 0x00080000,
+	DDSD_DEPTH			= 0x00800000
+};
+
+enum DDSCAPS
+{
+	DDSCAPS_COMPLEX				= 0x00000008,
+	DDSCAPS_MIPMAP				= 0x00400000,
+	DDSCAPS_TEXTURE				= 0x00001000
+};
+
+enum DDSCAPS2
+{
+	DDSCAPS2_CUBEMAP				= 0x00000200,
+	DDSCAPS2_CUBEMAP_POSITIVEX		= 0x00000400,
+	DDSCAPS2_CUBEMAP_NEGATIVEX		= 0x00000800,
+	DDSCAPS2_CUBEMAP_POSITIVEY		= 0x00001000,
+	DDSCAPS2_CUBEMAP_NEGATIVEY		= 0x00002000,
+	DDSCAPS2_CUBEMAP_POSITIVEZ		= 0x00004000,
+	DDSCAPS2_CUBEMAP_NEGATIVEZ		= 0x00008000,
+	DDSCAPS2_VOLUME					= 0x00200000
+};
+
+enum DDS_COLOR
+{
+   DDS_COLOR_DEFAULT = 0,
+   DDS_COLOR_DISTANCE,
+   DDS_COLOR_LUMINANCE,
+   DDS_COLOR_INSET_BBOX,
+   DDS_COLOR_MAX
+};
+
+enum DDS_COMPRESS
+{
+   DDS_COMPRESS_NONE = 0,
+   DDS_COMPRESS_BC1,        /* DXT1  */
+   DDS_COMPRESS_BC2,        /* DXT3  */
+   DDS_COMPRESS_BC3,        /* DXT5  */
+   DDS_COMPRESS_BC3N,       /* DXT5n */
+   DDS_COMPRESS_BC4,        /* ATI1  */
+   DDS_COMPRESS_BC5,        /* ATI2  */
+   DDS_COMPRESS_AEXP,       /* DXT5  */
+   DDS_COMPRESS_YCOCG,      /* DXT5  */
+   DDS_COMPRESS_YCOCGS,     /* DXT5  */
+   DDS_COMPRESS_MAX
+};
+
+enum DDS_FORMAT
+{
+   DDS_FORMAT_DEFAULT = 0,
+   DDS_FORMAT_RGB8,
+   DDS_FORMAT_RGBA8,
+   DDS_FORMAT_BGR8,
+   DDS_FORMAT_ABGR8,
+   DDS_FORMAT_R5G6B5,
+   DDS_FORMAT_RGBA4,
+   DDS_FORMAT_RGB5A1,
+   DDS_FORMAT_RGB10A2,
+   DDS_FORMAT_R3G3B2,
+   DDS_FORMAT_A8,
+   DDS_FORMAT_L8,
+   DDS_FORMAT_L8A8,
+   DDS_FORMAT_AEXP,
+   DDS_FORMAT_YCOCG,
+   DDS_FORMAT_MAX
+};
+
+enum DDS_MIPMAP
+{
+   DDS_MIPMAP_DEFAULT = 0,
+   DDS_MIPMAP_NEAREST,
+   DDS_MIPMAP_BOX,
+   DDS_MIPMAP_BILINEAR,
+   DDS_MIPMAP_BICUBIC,
+   DDS_MIPMAP_LANCZOS,
+   DDS_MIPMAP_MAX
+};
+
+enum DDS_SAVE
+{
+   DDS_SAVE_SELECTED_LAYER = 0,
+   DDS_SAVE_CUBEMAP,
+   DDS_SAVE_VOLUMEMAP,
+   DDS_SAVE_MAX
+};
+
+enum DXGI_FORMAT : nzUInt32
+{
+	DXGI_FORMAT_UNKNOWN                      = 0,
+	DXGI_FORMAT_R32G32B32A32_TYPELESS        = 1,
+	DXGI_FORMAT_R32G32B32A32_FLOAT           = 2,
+	DXGI_FORMAT_R32G32B32A32_UINT            = 3,
+	DXGI_FORMAT_R32G32B32A32_SINT            = 4,
+	DXGI_FORMAT_R32G32B32_TYPELESS           = 5,
+	DXGI_FORMAT_R32G32B32_FLOAT              = 6,
+	DXGI_FORMAT_R32G32B32_UINT               = 7,
+	DXGI_FORMAT_R32G32B32_SINT               = 8,
+	DXGI_FORMAT_R16G16B16A16_TYPELESS        = 9,
+	DXGI_FORMAT_R16G16B16A16_FLOAT           = 10,
+	DXGI_FORMAT_R16G16B16A16_UNORM           = 11,
+	DXGI_FORMAT_R16G16B16A16_UINT            = 12,
+	DXGI_FORMAT_R16G16B16A16_SNORM           = 13,
+	DXGI_FORMAT_R16G16B16A16_SINT            = 14,
+	DXGI_FORMAT_R32G32_TYPELESS              = 15,
+	DXGI_FORMAT_R32G32_FLOAT                 = 16,
+	DXGI_FORMAT_R32G32_UINT                  = 17,
+	DXGI_FORMAT_R32G32_SINT                  = 18,
+	DXGI_FORMAT_R32G8X24_TYPELESS            = 19,
+	DXGI_FORMAT_D32_FLOAT_S8X24_UINT         = 20,
+	DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS     = 21,
+	DXGI_FORMAT_X32_TYPELESS_G8X24_UINT      = 22,
+	DXGI_FORMAT_R10G10B10A2_TYPELESS         = 23,
+	DXGI_FORMAT_R10G10B10A2_UNORM            = 24,
+	DXGI_FORMAT_R10G10B10A2_UINT             = 25,
+	DXGI_FORMAT_R11G11B10_FLOAT              = 26,
+	DXGI_FORMAT_R8G8B8A8_TYPELESS            = 27,
+	DXGI_FORMAT_R8G8B8A8_UNORM               = 28,
+	DXGI_FORMAT_R8G8B8A8_UNORM_SRGB          = 29,
+	DXGI_FORMAT_R8G8B8A8_UINT                = 30,
+	DXGI_FORMAT_R8G8B8A8_SNORM               = 31,
+	DXGI_FORMAT_R8G8B8A8_SINT                = 32,
+	DXGI_FORMAT_R16G16_TYPELESS              = 33,
+	DXGI_FORMAT_R16G16_FLOAT                 = 34,
+	DXGI_FORMAT_R16G16_UNORM                 = 35,
+	DXGI_FORMAT_R16G16_UINT                  = 36,
+	DXGI_FORMAT_R16G16_SNORM                 = 37,
+	DXGI_FORMAT_R16G16_SINT                  = 38,
+	DXGI_FORMAT_R32_TYPELESS                 = 39,
+	DXGI_FORMAT_D32_FLOAT                    = 40,
+	DXGI_FORMAT_R32_FLOAT                    = 41,
+	DXGI_FORMAT_R32_UINT                     = 42,
+	DXGI_FORMAT_R32_SINT                     = 43,
+	DXGI_FORMAT_R24G8_TYPELESS               = 44,
+	DXGI_FORMAT_D24_UNORM_S8_UINT            = 45,
+	DXGI_FORMAT_R24_UNORM_X8_TYPELESS        = 46,
+	DXGI_FORMAT_X24_TYPELESS_G8_UINT         = 47,
+	DXGI_FORMAT_R8G8_TYPELESS                = 48,
+	DXGI_FORMAT_R8G8_UNORM                   = 49,
+	DXGI_FORMAT_R8G8_UINT                    = 50,
+	DXGI_FORMAT_R8G8_SNORM                   = 51,
+	DXGI_FORMAT_R8G8_SINT                    = 52,
+	DXGI_FORMAT_R16_TYPELESS                 = 53,
+	DXGI_FORMAT_R16_FLOAT                    = 54,
+	DXGI_FORMAT_D16_UNORM                    = 55,
+	DXGI_FORMAT_R16_UNORM                    = 56,
+	DXGI_FORMAT_R16_UINT                     = 57,
+	DXGI_FORMAT_R16_SNORM                    = 58,
+	DXGI_FORMAT_R16_SINT                     = 59,
+	DXGI_FORMAT_R8_TYPELESS                  = 60,
+	DXGI_FORMAT_R8_UNORM                     = 61,
+	DXGI_FORMAT_R8_UINT                      = 62,
+	DXGI_FORMAT_R8_SNORM                     = 63,
+	DXGI_FORMAT_R8_SINT                      = 64,
+	DXGI_FORMAT_A8_UNORM                     = 65,
+	DXGI_FORMAT_R1_UNORM                     = 66,
+	DXGI_FORMAT_R9G9B9E5_SHAREDEXP           = 67,
+	DXGI_FORMAT_R8G8_B8G8_UNORM              = 68,
+	DXGI_FORMAT_G8R8_G8B8_UNORM              = 69,
+	DXGI_FORMAT_BC1_TYPELESS                 = 70,
+	DXGI_FORMAT_BC1_UNORM                    = 71,
+	DXGI_FORMAT_BC1_UNORM_SRGB               = 72,
+	DXGI_FORMAT_BC2_TYPELESS                 = 73,
+	DXGI_FORMAT_BC2_UNORM                    = 74,
+	DXGI_FORMAT_BC2_UNORM_SRGB               = 75,
+	DXGI_FORMAT_BC3_TYPELESS                 = 76,
+	DXGI_FORMAT_BC3_UNORM                    = 77,
+	DXGI_FORMAT_BC3_UNORM_SRGB               = 78,
+	DXGI_FORMAT_BC4_TYPELESS                 = 79,
+	DXGI_FORMAT_BC4_UNORM                    = 80,
+	DXGI_FORMAT_BC4_SNORM                    = 81,
+	DXGI_FORMAT_BC5_TYPELESS                 = 82,
+	DXGI_FORMAT_BC5_UNORM                    = 83,
+	DXGI_FORMAT_BC5_SNORM                    = 84,
+	DXGI_FORMAT_B5G6R5_UNORM                 = 85,
+	DXGI_FORMAT_B5G5R5A1_UNORM               = 86,
+	DXGI_FORMAT_B8G8R8A8_UNORM               = 87,
+	DXGI_FORMAT_B8G8R8X8_UNORM               = 88,
+	DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM   = 89,
+	DXGI_FORMAT_B8G8R8A8_TYPELESS            = 90,
+	DXGI_FORMAT_B8G8R8A8_UNORM_SRGB          = 91,
+	DXGI_FORMAT_B8G8R8X8_TYPELESS            = 92,
+	DXGI_FORMAT_B8G8R8X8_UNORM_SRGB          = 93,
+	DXGI_FORMAT_BC6H_TYPELESS                = 94,
+	DXGI_FORMAT_BC6H_UF16                    = 95,
+	DXGI_FORMAT_BC6H_SF16                    = 96,
+	DXGI_FORMAT_BC7_TYPELESS                 = 97,
+	DXGI_FORMAT_BC7_UNORM                    = 98,
+	DXGI_FORMAT_BC7_UNORM_SRGB               = 99
+};
+
+struct DDSPixelFormat // DDPIXELFORMAT
+{
+	nzUInt32 size;
+	nzUInt32 flags;
+	nzUInt32 fourCC;
+	nzUInt32 bpp;
+	nzUInt32 redMask;
+	nzUInt32 greenMask;
+	nzUInt32 blueMask;
+	nzUInt32 alphaMask;
+};
+
+static_assert(sizeof(DDSPixelFormat) == 8*sizeof(nzUInt32), "DDSPixelFormat must be packed");
+
+struct DDSHeader
+{
+	nzUInt32 size;
+	nzUInt32 flags;
+	nzUInt32 height;
+	nzUInt32 width;
+	nzUInt32 pitch;
+	nzUInt32 depth;
+	nzUInt32 levelCount;
+	nzUInt32 reserved1[11];
+	DDSPixelFormat format;
+	nzUInt32 ddsCaps1;
+	nzUInt32 ddsCaps2;
+	nzUInt32 ddsCaps3;
+	nzUInt32 ddsCaps4;
+	nzUInt32 reserved2;
+};
+
+static_assert(sizeof(DDSHeader) == 23*sizeof(nzUInt32) + sizeof(DDSPixelFormat), "DDSHeader must be packed");
+
+struct DDSHeaderDX10Ext
+{
+	DXGI_FORMAT dxgiFormat;
+	D3D10_RESOURCE_DIMENSION resourceDimension;
+	nzUInt32 miscFlag;
+	nzUInt32 arraySize;
+	nzUInt32 reserved;
+};
+
+static_assert(sizeof(DDSHeaderDX10Ext) == 5*sizeof(nzUInt32), "DDSHeaderDX10Ext must be packed");
+
+#endif // NAZARA_LOADERS_DDS_CONSTANTS_HPP

src/Nazara/Utility/Formats/DDSLoader.cpp

@@ -0,0 +1,123 @@
+// Copyright (C) 2015 Jérôme Leclercq - 2009 Cruden BV
+// This file is part of the "Nazara Engine - Utility module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/Formats/DDSLoader.hpp>
+#include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <Nazara/Utility/Formats/DDSConstants.hpp>
+#include <memory>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace
+{
+	bool IsSupported(const NzString& extension)
+	{
+		return (extension == "dds");
+	}
+
+	nzTernary Check(NzInputStream& stream, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		nzUInt32 magic;
+		if (stream.Read(&magic, sizeof(nzUInt32)) == sizeof(nzUInt32))
+		{
+			#ifdef NAZARA_BIG_ENDIAN
+			NzByteSwap(&magic, sizeof(nzUInt32));
+			#endif
+
+			if (magic == DDS_MAGIC)
+				return nzTernary_True;
+		}
+
+		return nzTernary_False;
+	}
+
+	bool Load(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		DDSHeader header;
+		if (stream.Read(&header, sizeof(DDSHeader)) != sizeof(DDSHeader))
+		{
+			NazaraError("Failed to read DDS header");
+			return false;
+		}
+
+		DDSHeaderDX10Ext headerDX10;
+		if (header.format.flags & DDPF_FOURCC && header.format.fourCC == D3DFMT_DX10)
+		{
+			if (stream.Read(&headerDX10, sizeof(DDSHeaderDX10Ext)) != sizeof(DDSHeaderDX10Ext))
+			{
+				NazaraError("Failed to read DDS DX10 extension header");
+				return false;
+			}
+		}
+		else
+		{
+			headerDX10.arraySize = 1;
+			headerDX10.dxgiFormat = DXGI_FORMAT_UNKNOWN;
+			headerDX10.miscFlag = 0;
+			headerDX10.resourceDimension = D3D10_RESOURCE_DIMENSION_UNKNOWN;
+		}
+
+		#ifdef NAZARA_BIG_ENDIAN
+		// Les fichiers DDS sont en little endian
+		NzByteSwap(&header.size, sizeof(nzUInt32));
+		NzByteSwap(&header.flags, sizeof(nzUInt32));
+		NzByteSwap(&header.height, sizeof(nzUInt32));
+		NzByteSwap(&header.width, sizeof(nzUInt32));
+		NzByteSwap(&header.pitch, sizeof(nzUInt32));
+		NzByteSwap(&header.depth, sizeof(nzUInt32));
+		NzByteSwap(&header.levelCount, sizeof(nzUInt32));
+
+		// DDS_PixelFormat
+		NzByteSwap(&header.format.size, sizeof(nzUInt32));
+		NzByteSwap(&header.format.flags, sizeof(nzUInt32));
+		NzByteSwap(&header.format.fourCC, sizeof(nzUInt32));
+		NzByteSwap(&header.format.bpp, sizeof(nzUInt32));
+		NzByteSwap(&header.format.redMask, sizeof(nzUInt32));
+		NzByteSwap(&header.format.greenMask, sizeof(nzUInt32));
+		NzByteSwap(&header.format.blueMask, sizeof(nzUInt32));
+		NzByteSwap(&header.format.alphaMask, sizeof(nzUInt32));
+
+		NzByteSwap(&header.ddsCaps1, sizeof(nzUInt32));
+		NzByteSwap(&header.ddsCaps2, sizeof(nzUInt32));
+		NzByteSwap(&header.ddsCaps3, sizeof(nzUInt32));
+		NzByteSwap(&header.ddsCaps4, sizeof(nzUInt32));
+		#endif
+
+		unsigned int width = header.width;
+		unsigned int height = header.height;
+		unsigned int depth = std::max(header.depth, 1U);
+		unsigned int levelCount = (parameters.levelCount > 0) ? std::min(parameters.levelCount, static_cast<nzUInt8>(header.levelCount)) : header.levelCount;
+
+		// Détermination du type
+		nzImageType type;
+		if (header.ddsCaps2 & DDSCAPS2_CUBEMAP)
+			type = nzImageType_Cubemap;
+		else if (header.ddsCaps2 & DDSCAPS2_VOLUME)
+			type = nzImageType_3D;
+
+		// Détermination du format
+		nzPixelFormat format;
+
+		if (parameters.loadFormat != nzPixelFormat_Undefined)
+			image->Convert(parameters.loadFormat);
+
+		return true;
+	}
+}
+
+void NzLoaders_DDS_Register()
+{
+	NzImageLoader::RegisterLoader(IsSupported, Check, Load);
+}
+
+void NzLoaders_DDS_Unregister()
+{
+	NzImageLoader::UnregisterLoader(IsSupported, Check, Load);
+}

src/Nazara/Utility/Formats/DDSLoader.hpp

@@ -0,0 +1,15 @@
+// Copyright (C) 2015 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
+
+#pragma once
+
+#ifndef NAZARA_LOADERS_DDS_HPP
+#define NAZARA_LOADERS_DDS_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+void NzLoaders_DDS_Register();
+void NzLoaders_DDS_Unregister();
+
+#endif // NAZARA_LOADERS_DDS_HPP

src/Nazara/Utility/Formats/FreeTypeLoader.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/FreeType.hpp>
+#include <Nazara/Utility/Formats/FreeTypeLoader.hpp>
 #include <freetype/ft2build.h>
 #include FT_FREETYPE_H
 #include FT_BITMAP_H

src/Nazara/Utility/Formats/MD2Constants.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD2/Constants.hpp>
+#include <Nazara/Utility/Formats/MD2Constants.hpp>
 #include <Nazara/Utility/Debug.hpp>
 
 const nzUInt32 md2Ident = 'I' + ('D'<<8) + ('P'<<16) + ('2'<<24);

src/Nazara/Utility/Formats/MD2Loader.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD2.hpp>
+#include <Nazara/Utility/Formats/MD2Loader.hpp>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/InputStream.hpp>
@@ -11,7 +11,7 @@
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
-#include <Nazara/Utility/Loaders/MD2/Constants.hpp>
+#include <Nazara/Utility/Formats/MD2Constants.hpp>
 #include <cstddef>
 #include <cstring>
 #include <memory>

src/Nazara/Utility/Formats/MD5AnimLoader.cpp

@@ -2,8 +2,8 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD5Anim.hpp>
-#include <Nazara/Utility/Loaders/MD5Anim/Parser.hpp>
+#include <Nazara/Utility/Formats/MD5AnimLoader.hpp>
+#include <Nazara/Utility/Formats/MD5AnimParser.hpp>
 #include <Nazara/Utility/Debug.hpp>
 
 namespace

src/Nazara/Utility/Formats/MD5AnimParser.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD5Anim/Parser.hpp>
+#include <Nazara/Utility/Formats/MD5AnimParser.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Utility/Config.hpp>

src/Nazara/Utility/Formats/MD5MeshLoader.cpp

@@ -2,12 +2,12 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD5Mesh.hpp>
-#include <Nazara/Utility/Loaders/MD5Mesh/Parser.hpp>
+#include <Nazara/Utility/Formats/MD5MeshLoader.hpp>
 #include <Nazara/Utility/IndexIterator.hpp>
 #include <Nazara/Utility/IndexMapper.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
+#include <Nazara/Utility/Formats/MD5MeshParser.hpp>
 #include <memory>
 #include <Nazara/Utility/Debug.hpp>
 

src/Nazara/Utility/Formats/MD5MeshParser.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/MD5Mesh/Parser.hpp>
+#include <Nazara/Utility/Formats/MD5MeshParser.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>

src/Nazara/Utility/Formats/MTLParser.cpp

@@ -0,0 +1,333 @@
+// Copyright (C) 2015 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
+
+#include <Nazara/Utility/Formats/MTLParser.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Log.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <cstdio>
+#include <memory>
+#include <Nazara/Utility/Debug.hpp>
+
+NzMTLParser::NzMTLParser(NzInputStream& stream) :
+m_stream(stream),
+m_streamFlags(stream.GetStreamOptions())
+{
+	if ((m_streamFlags & nzStreamOption_Text) == 0)
+		m_stream.SetStreamOptions(m_streamFlags | nzStreamOption_Text);
+}
+
+NzMTLParser::~NzMTLParser()
+{
+	if ((m_streamFlags & nzStreamOption_Text) == 0)
+		m_stream.SetStreamOptions(m_streamFlags);
+}
+
+const NzMTLParser::Material* NzMTLParser::GetMaterial(const NzString& materialName) const
+{
+	auto it = m_materials.find(materialName);
+	if (it != m_materials.end())
+		return &it->second;
+	else
+		return nullptr;
+}
+
+const std::unordered_map<NzString, NzMTLParser::Material>& NzMTLParser::GetMaterials() const
+{
+	return m_materials;
+}
+
+bool NzMTLParser::Parse()
+{
+	m_keepLastLine = false;
+	m_lineCount = 0;
+	m_materials.clear();
+
+	Material* currentMaterial = nullptr;
+
+	while (Advance(false))
+	{
+		NzString keyword = m_currentLine.GetWord(0).ToLower();
+		if (keyword == "ka")
+		{
+			float r, g, b;
+			if (std::sscanf(&m_currentLine[3], "%f %f %f", &r, &g, &b) == 3)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->ambient = NzColor(static_cast<nzUInt8>(r*255.f), static_cast<nzUInt8>(g*255.f), static_cast<nzUInt8>(b*255.f));
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "kd")
+		{
+			float r, g, b;
+			if (std::sscanf(&m_currentLine[3], "%f %f %f", &r, &g, &b) == 3)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->diffuse = NzColor(static_cast<nzUInt8>(r*255.f), static_cast<nzUInt8>(g*255.f), static_cast<nzUInt8>(b*255.f));
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "ks")
+		{
+			float r, g, b;
+			if (std::sscanf(&m_currentLine[3], "%f %f %f", &r, &g, &b) == 3)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->specular = NzColor(static_cast<nzUInt8>(r*255.f), static_cast<nzUInt8>(g*255.f), static_cast<nzUInt8>(b*255.f));
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "ni")
+		{
+			float density;
+			if (std::sscanf(&m_currentLine[3], "%f", &density) == 1)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->refractionIndex = density;
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "ns")
+		{
+			float coef;
+			if (std::sscanf(&m_currentLine[3], "%f", &coef) == 1)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->shininess = coef;
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == 'd')
+		{
+			float alpha;
+			if (std::sscanf(&m_currentLine[(keyword[0] == 'd') ? 2 : 3], "%f", &alpha) == 1)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->alpha = alpha;
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "tr")
+		{
+			float alpha;
+			if (std::sscanf(&m_currentLine[(keyword[0] == 'd') ? 2 : 3], "%f", &alpha) == 1)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->alpha = 1.f - alpha; // tr vaut pour la "valeur de transparence", 0 = opaque
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "illum")
+		{
+			unsigned int model;
+			if (std::sscanf(&m_currentLine[6], "%u", &model) == 1)
+			{
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->illumModel = model;
+			}
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		else if (keyword == "map_ka")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->ambientMap = map;
+			}
+		}
+		else if (keyword == "map_kd")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->diffuseMap = map;
+			}
+		}
+		else if (keyword == "map_ks")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->specularMap = map;
+			}
+		}
+		else if (keyword == "map_bump" || keyword == "bump")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->bumpMap = map;
+			}
+		}
+		else if (keyword == "map_d")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->alphaMap = map;
+			}
+		}
+		else if (keyword == "map_decal" || keyword == "decal")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->decalMap = map;
+			}
+		}
+		else if (keyword == "map_disp" || keyword == "disp")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->displacementMap = map;
+			}
+		}
+		else if (keyword == "map_refl" || keyword == "refl")
+		{
+			unsigned int mapPos = m_currentLine.GetWordPosition(1);
+			if (mapPos != NzString::npos)
+			{
+				NzString map = m_currentLine.SubString(mapPos);
+				if (!currentMaterial)
+					currentMaterial = &m_materials["default"];
+
+				currentMaterial->reflectionMap = map;
+			}
+		}
+		else if (keyword == "newmtl")
+		{
+			NzString materialName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
+			if (!materialName.IsEmpty())
+				currentMaterial = &m_materials[materialName];
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			else
+				UnrecognizedLine();
+			#endif
+		}
+		#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+		else
+			UnrecognizedLine();
+		#endif
+	}
+
+	return true;
+}
+
+bool NzMTLParser::Advance(bool required)
+{
+	if (!m_keepLastLine)
+	{
+		do
+		{
+			if (m_stream.EndOfStream())
+			{
+				if (required)
+					Error("Incomplete MTL file");
+
+				return false;
+			}
+
+			m_lineCount++;
+
+			m_currentLine = m_stream.ReadLine();
+			m_currentLine = m_currentLine.SubStringTo("#"); // On ignore les commentaires
+			m_currentLine.Simplify(); // Pour un traitement plus simple
+		}
+		while (m_currentLine.IsEmpty());
+	}
+	else
+		m_keepLastLine = false;
+
+	return true;
+}
+
+void NzMTLParser::Error(const NzString& message)
+{
+	NazaraError(message + " at line #" + NzString::Number(m_lineCount));
+}
+
+void NzMTLParser::Warning(const NzString& message)
+{
+	NazaraWarning(message + " at line #" + NzString::Number(m_lineCount));
+}
+
+void NzMTLParser::UnrecognizedLine(bool error)
+{
+	NzString message = "Unrecognized \"" + m_currentLine + '"';
+
+	if (error)
+		Error(message);
+	else
+		Warning(message);
+}

src/Nazara/Utility/Formats/OBJParser.cpp

@@ -0,0 +1,439 @@
+// Copyright (C) 2015 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
+
+#include <Nazara/Utility/Formats/OBJParser.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Log.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <cctype>
+#include <memory>
+#include <unordered_map>
+#include <Nazara/Utility/Debug.hpp>
+
+NzOBJParser::NzOBJParser(NzInputStream& stream) :
+m_stream(stream),
+m_streamFlags(stream.GetStreamOptions())
+{
+	if ((m_streamFlags & nzStreamOption_Text) == 0)
+		m_stream.SetStreamOptions(m_streamFlags | nzStreamOption_Text);
+}
+
+NzOBJParser::~NzOBJParser()
+{
+	if ((m_streamFlags & nzStreamOption_Text) == 0)
+		m_stream.SetStreamOptions(m_streamFlags);
+}
+
+const NzString* NzOBJParser::GetMaterials() const
+{
+	return m_materials.data();
+}
+
+unsigned int NzOBJParser::GetMaterialCount() const
+{
+	return m_materials.size();
+}
+
+const NzOBJParser::Mesh* NzOBJParser::GetMeshes() const
+{
+	return m_meshes.data();
+}
+
+unsigned int NzOBJParser::GetMeshCount() const
+{
+	return m_meshes.size();
+}
+
+const NzString& NzOBJParser::GetMtlLib() const
+{
+	return m_mtlLib;
+}
+
+const NzVector3f* NzOBJParser::GetNormals() const
+{
+	return m_normals.data();
+}
+
+unsigned int NzOBJParser::GetNormalCount() const
+{
+	return m_normals.size();
+}
+
+const NzVector4f* NzOBJParser::GetPositions() const
+{
+	return m_positions.data();
+}
+
+unsigned int NzOBJParser::GetPositionCount() const
+{
+	return m_positions.size();
+}
+
+const NzVector3f* NzOBJParser::GetTexCoords() const
+{
+	return m_texCoords.data();
+}
+
+unsigned int NzOBJParser::GetTexCoordCount() const
+{
+	return m_texCoords.size();
+}
+
+bool NzOBJParser::Parse()
+{
+	NzString matName, meshName;
+	matName = meshName = "default";
+	m_keepLastLine = false;
+	m_lineCount = 0;
+	m_meshes.clear();
+	m_mtlLib.Clear();
+
+	m_normals.clear();
+	m_positions.clear();
+	m_texCoords.clear();
+
+	// Beaucoup de meshs font plus de 100 sommets, préparons le terrain
+	m_normals.reserve(100);
+	m_positions.reserve(100);
+	m_texCoords.reserve(100);
+
+	// On va regrouper les meshs par nom et par matériau
+	std::unordered_map<NzString, std::unordered_map<NzString, std::vector<Face>>> meshes;
+
+	// On prépare le mesh par défaut
+	std::vector<Face>* currentMesh = &meshes[meshName][matName];
+
+	while (Advance(false))
+	{
+		switch (std::tolower(m_currentLine[0]))
+		{
+			case 'f': // Une face
+			{
+				if (m_currentLine.GetSize() < 7) // Le minimum syndical pour définir une face de trois sommets (f 1 2 3)
+				{
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					UnrecognizedLine();
+					#endif
+					break;
+				}
+
+				unsigned int vertexCount = m_currentLine.Count(' ');
+				if (vertexCount < 3)
+				{
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					UnrecognizedLine();
+					#endif
+					break;
+				}
+
+				Face face;
+				face.vertices.resize(vertexCount);
+
+				bool error = false;
+				unsigned int pos = 2;
+				for (unsigned int i = 0; i < vertexCount; ++i)
+				{
+					int offset;
+					int& n = face.vertices[i].normal;
+					int& p = face.vertices[i].position;
+					int& t = face.vertices[i].texCoord;
+
+					if (std::sscanf(&m_currentLine[pos], "%d/%d/%d%n", &p, &t, &n, &offset) != 3)
+					{
+						if (std::sscanf(&m_currentLine[pos], "%d//%d%n", &p, &n, &offset) != 2)
+						{
+							if (std::sscanf(&m_currentLine[pos], "%d/%d%n", &p, &t, &offset) != 2)
+							{
+								if (std::sscanf(&m_currentLine[pos], "%d%n", &p, &offset) != 1)
+								{
+									#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+									UnrecognizedLine();
+									#endif
+									error = true;
+									break;
+								}
+								else
+								{
+									n = 0;
+									t = 0;
+								}
+							}
+							else
+								n = 0;
+						}
+						else
+							t = 0;
+					}
+
+					if (p < 0)
+					{
+						p += m_positions.size();
+						if (p < 0)
+						{
+							Error("Vertex index out of range (" + NzString::Number(p) + " < 0");
+							error = true;
+							break;
+						}
+					}
+					else
+						p--;
+
+					if (n < 0)
+					{
+						n += m_normals.size();
+						if (n < 0)
+						{
+							Error("Vertex index out of range (" + NzString::Number(n) + " < 0");
+							error = true;
+							break;
+						}
+					}
+					else
+						n--;
+
+					if (t < 0)
+					{
+						t += m_texCoords.size();
+						if (t < 0)
+						{
+							Error("Vertex index out of range (" + NzString::Number(t) + " < 0");
+							error = true;
+							break;
+						}
+					}
+					else
+						t--;
+
+					if (static_cast<unsigned int>(p) >= m_positions.size())
+					{
+						Error("Vertex index out of range (" + NzString::Number(p) + " >= " + NzString::Number(m_positions.size()) + ')');
+						error = true;
+						break;
+					}
+					else if (n >= 0 && static_cast<unsigned int>(n) >= m_normals.size())
+					{
+						Error("Normal index out of range (" + NzString::Number(n) + " >= " + NzString::Number(m_normals.size()) + ')');
+						error = true;
+						break;
+					}
+					else if (t >= 0 && static_cast<unsigned int>(t) >= m_texCoords.size())
+					{
+						Error("TexCoord index out of range (" + NzString::Number(t) + " >= " + NzString::Number(m_texCoords.size()) + ')');
+						error = true;
+						break;
+					}
+
+					pos += offset;
+				}
+
+				if (!error)
+					currentMesh->push_back(std::move(face));
+
+				break;
+			}
+
+			case 'm':
+				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+				if (m_currentLine.GetWord(0).ToLower() != "mtllib")
+					UnrecognizedLine();
+				#endif
+
+				m_mtlLib = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
+				break;
+
+			case 'g':
+			case 'o':
+			{
+				if (m_currentLine.GetSize() <= 2 || m_currentLine[1] != ' ')
+				{
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					UnrecognizedLine();
+					#endif
+					break;
+				}
+
+				NzString objectName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
+				if (objectName.IsEmpty())
+				{
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					UnrecognizedLine();
+					#endif
+					break;
+				}
+
+				meshName = objectName;
+				currentMesh = &meshes[meshName][matName];
+				break;
+			}
+
+			#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+			case 's':
+				if (m_currentLine.GetSize() <= 2 || m_currentLine[1] == ' ')
+				{
+					NzString param = m_currentLine.SubString(2);
+					if (param != "all" && param != "on" && param != "off" && !param.IsNumber())
+						UnrecognizedLine();
+				}
+				else
+					UnrecognizedLine();
+				break;
+			#endif
+
+			case 'u':
+				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+				if (m_currentLine.GetWord(0) != "usemtl")
+					UnrecognizedLine();
+				#endif
+
+				matName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
+				if (matName.IsEmpty())
+				{
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					UnrecognizedLine();
+					#endif
+					break;
+				}
+
+				currentMesh = &meshes[meshName][matName];
+				break;
+
+			case 'v':
+			{
+				NzString word = m_currentLine.GetWord(0).ToLower();
+				if (word == 'v')
+				{
+					NzVector4f vertex(NzVector3f::Zero(), 1.f);
+					unsigned int paramCount = std::sscanf(&m_currentLine[2], "%f %f %f %f", &vertex.x, &vertex.y, &vertex.z, &vertex.w);
+					if (paramCount >= 3)
+						m_positions.push_back(vertex);
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					else
+						UnrecognizedLine();
+					#endif
+				}
+				else if (word == "vn")
+				{
+					NzVector3f normal(NzVector3f::Zero());
+					unsigned int paramCount = std::sscanf(&m_currentLine[3], "%f %f %f", &normal.x, &normal.y, &normal.z);
+					if (paramCount == 3)
+						m_normals.push_back(normal);
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					else
+						UnrecognizedLine();
+					#endif
+				}
+				else if (word == "vt")
+				{
+					NzVector3f uvw(NzVector3f::Zero());
+					unsigned int paramCount = std::sscanf(&m_currentLine[3], "%f %f %f", &uvw.x, &uvw.y, &uvw.z);
+					if (paramCount >= 2)
+						m_texCoords.push_back(uvw);
+					#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+					else
+						UnrecognizedLine();
+					#endif
+				}
+				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+				else
+					UnrecognizedLine();
+				#endif
+
+				break;
+			}
+
+			default:
+				#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
+				UnrecognizedLine();
+				#endif
+				break;
+		}
+	}
+
+	std::unordered_map<NzString, unsigned int> materials;
+	unsigned int matCount = 0;
+
+	for (auto& meshIt : meshes)
+	{
+		for (auto& matIt : meshIt.second)
+		{
+			if (!matIt.second.empty())
+			{
+				Mesh mesh;
+				mesh.faces = std::move(matIt.second);
+				mesh.name = meshIt.first;
+
+				auto it = materials.find(matIt.first);
+				if (it == materials.end())
+				{
+					mesh.material = matCount;
+					materials[matIt.first] = matCount++;
+				}
+				else
+					mesh.material = it->second;
+
+				m_meshes.push_back(std::move(mesh));
+			}
+		}
+	}
+
+	if (m_meshes.empty())
+	{
+		NazaraError("No meshes");
+		return false;
+	}
+
+	m_materials.resize(matCount);
+	for (const std::pair<NzString, unsigned int>& pair : materials)
+		m_materials[pair.second] = pair.first;
+
+	return true;
+}
+
+bool NzOBJParser::Advance(bool required)
+{
+	if (!m_keepLastLine)
+	{
+		do
+		{
+			if (m_stream.EndOfStream())
+			{
+				if (required)
+					Error("Incomplete OBJ file");
+
+				return false;
+			}
+
+			m_lineCount++;
+
+			m_currentLine = m_stream.ReadLine();
+			m_currentLine = m_currentLine.SubStringTo("#"); // On ignore les commentaires
+			m_currentLine.Simplify(); // Pour un traitement plus simple
+		}
+		while (m_currentLine.IsEmpty());
+	}
+	else
+		m_keepLastLine = false;
+
+	return true;
+}
+
+void NzOBJParser::Error(const NzString& message)
+{
+	NazaraError(message + " at line #" + NzString::Number(m_lineCount));
+}
+
+void NzOBJParser::Warning(const NzString& message)
+{
+	NazaraWarning(message + " at line #" + NzString::Number(m_lineCount));
+}
+
+void NzOBJParser::UnrecognizedLine(bool error)
+{
+	NzString message = "Unrecognized \"" + m_currentLine + '"';
+
+	if (error)
+		Error(message);
+	else
+		Warning(message);
+}

src/Nazara/Utility/Formats/PCXLoader.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/PCX.hpp>
+#include <Nazara/Utility/Formats/PCXLoader.hpp>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/InputStream.hpp>

src/Nazara/Utility/Formats/STBLoader.cpp

@@ -2,7 +2,7 @@
 // This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Utility/Loaders/STB.hpp>
+#include <Nazara/Utility/Formats/STBLoader.hpp>
 #include <stb_image/stb_image.h>
 #include <Nazara/Core/Endianness.hpp>
 #include <Nazara/Core/Error.hpp>

src/Nazara/Utility/Loaders/MD5Anim/Parser.hpp

@@ -1,79 +0,0 @@
-// Copyright (C) 2015 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
-
-#pragma once
-
-#ifndef NAZARA_LOADERS_MD5ANIM_PARSER_HPP
-#define NAZARA_LOADERS_MD5ANIM_PARSER_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
-#include <Nazara/Math/Box.hpp>
-#include <Nazara/Math/Quaternion.hpp>
-#include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Utility/Animation.hpp>
-#include <vector>
-
-class NzMD5AnimParser
-{
-	public:
-		struct FrameJoint
-		{
-			NzQuaternionf orient;
-			NzVector3f pos;
-		};
-
-		struct Frame
-		{
-			std::vector<FrameJoint> joints;
-			NzBoxf bounds;
-		};
-
-		struct Joint
-		{
-			NzQuaternionf bindOrient;
-			NzString name;
-			NzVector3f bindPos;
-			int parent;
-			unsigned int flags;
-			unsigned int index;
-		};
-
-		NzMD5AnimParser(NzInputStream& stream);
-		~NzMD5AnimParser();
-
-		nzTernary Check();
-
-		unsigned int GetAnimatedComponentCount() const;
-		const Frame* GetFrames() const;
-		unsigned int GetFrameCount() const;
-		unsigned int GetFrameRate() const;
-		const Joint* GetJoints() const;
-		unsigned int GetJointCount() const;
-
-		bool Parse();
-
-	private:
-		bool Advance(bool required = true);
-		void Error(const NzString& message);
-		bool ParseBaseframe();
-		bool ParseBounds();
-		bool ParseFrame();
-		bool ParseHierarchy();
-		void Warning(const NzString& message);
-		void UnrecognizedLine(bool error = false);
-
-		std::vector<float> m_animatedComponents;
-		std::vector<Frame> m_frames;
-		std::vector<Joint> m_joints;
-		NzInputStream& m_stream;
-		NzString m_currentLine;
-		bool m_keepLastLine;
-		unsigned int m_frameIndex;
-		unsigned int m_frameRate;
-		unsigned int m_lineCount;
-		unsigned int m_streamFlags;
-};
-
-#endif // NAZARA_LOADERS_MD5ANIM_PARSER_HPP

src/Nazara/Utility/Loaders/MD5Mesh/Parser.hpp

@@ -1,83 +0,0 @@
-// Copyright (C) 2015 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
-
-#pragma once
-
-#ifndef NAZARA_LOADERS_MD5MESH_PARSER_HPP
-#define NAZARA_LOADERS_MD5MESH_PARSER_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/InputStream.hpp>
-#include <Nazara/Core/String.hpp>
-#include <Nazara/Math/Quaternion.hpp>
-#include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Utility/Mesh.hpp>
-#include <vector>
-
-class NzMD5MeshParser
-{
-	public:
-		struct Joint
-		{
-			NzQuaternionf bindOrient;
-			NzString name;
-			NzVector3f bindPos;
-			int parent;
-		};
-
-		typedef NzVector3ui Triangle;
-
-		struct Vertex
-		{
-			NzVector2f uv;
-			unsigned int startWeight;
-			unsigned int weightCount;
-		};
-
-		struct Weight
-		{
-			NzVector3f pos;
-			float bias;
-			unsigned int joint;
-		};
-
-		struct Mesh
-		{
-			std::vector<Triangle> triangles;
-			std::vector<Vertex> vertices;
-			std::vector<Weight> weights;
-			NzString shader;
-		};
-
-		NzMD5MeshParser(NzInputStream& stream);
-		~NzMD5MeshParser();
-
-		nzTernary Check();
-
-		const Joint* GetJoints() const;
-		unsigned int GetJointCount() const;
-		const Mesh* GetMeshes() const;
-		unsigned int GetMeshCount() const;
-
-		bool Parse();
-
-	private:
-		bool Advance(bool required = true);
-		void Error(const NzString& message);
-		bool ParseJoints();
-		bool ParseMesh();
-		void Warning(const NzString& message);
-		void UnrecognizedLine(bool error = false);
-
-		std::vector<Joint> m_joints;
-		std::vector<Mesh> m_meshes;
-		NzInputStream& m_stream;
-		NzString m_currentLine;
-		bool m_keepLastLine;
-		unsigned int m_lineCount;
-		unsigned int m_meshIndex;
-		unsigned int m_streamFlags;
-};
-
-#endif // NAZARA_LOADERS_MD5MESH_PARSER_HPP

src/Nazara/Utility/Utility.cpp

@@ -15,17 +15,17 @@
 #include <Nazara/Utility/Config.hpp>
 #include <Nazara/Utility/Font.hpp>
 #include <Nazara/Utility/Image.hpp>
-#include <Nazara/Utility/Loaders/FreeType.hpp>
-#include <Nazara/Utility/Loaders/MD2.hpp>
-#include <Nazara/Utility/Loaders/MD5Anim.hpp>
-#include <Nazara/Utility/Loaders/MD5Mesh.hpp>
-#include <Nazara/Utility/Loaders/PCX.hpp>
-#include <Nazara/Utility/Loaders/STB.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <Nazara/Utility/PixelFormat.hpp>
 #include <Nazara/Utility/Skeleton.hpp>
 #include <Nazara/Utility/VertexDeclaration.hpp>
 #include <Nazara/Utility/Window.hpp>
+#include <Nazara/Utility/Formats/FreeTypeLoader.hpp>
+#include <Nazara/Utility/Formats/MD2Loader.hpp>
+#include <Nazara/Utility/Formats/MD5AnimLoader.hpp>
+#include <Nazara/Utility/Formats/MD5MeshLoader.hpp>
+#include <Nazara/Utility/Formats/PCXLoader.hpp>
+#include <Nazara/Utility/Formats/STBLoader.hpp>
 #include <Nazara/Utility/Debug.hpp>
 
 bool NzUtility::Initialize()