Added Image

Added pixel format support
Added MemoryStream
Added Rect
Added ResourceLoader
Added generic loader (bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga)
Added PCX loader
Added utility module initializer
Fixed Config.hpp include
Prerequesites.hpp now overwrites _WIN32_WINNT when defined
version is less than requiered version
Renderer's initialisation will implicitly initialize utility module
Removed RENDERER_SINGLETON option
Shaders are now resources

src/Nazara/Utility/Image.cpp

@@ -0,0 +1,475 @@
+// Copyright (C) 2012 Jérôme Leclercq
+// This file is part of the "Nazara Engine".
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/Image.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/ResourceLoader.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+NzImage::NzImage() :
+m_sharedImage(&emptyImage)
+{
+}
+
+NzImage::NzImage(const NzImage& image) :
+NzResource(image),
+m_sharedImage(image.m_sharedImage)
+{
+	if (m_sharedImage != &emptyImage)
+	{
+		NazaraMutexLock(m_sharedImage->mutex);
+		m_sharedImage->refCount++;
+		NazaraMutexUnlock(m_sharedImage->mutex);
+	}
+}
+
+NzImage::NzImage(NzImage&& image) :
+m_sharedImage(image.m_sharedImage)
+{
+	image.m_sharedImage = &emptyImage;
+}
+
+NzImage::~NzImage()
+{
+	ReleaseImage();
+}
+
+bool NzImage::Copy(const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!source.IsValid())
+	{
+		NazaraError("Source image must be valid");
+		return false;
+	}
+
+	if (source.GetFormat() != m_sharedImage->format)
+	{
+		NazaraError("Source image format does not match destination image format");
+		return false;
+	}
+	#endif
+
+	return Update(&source.GetConstPixels()[(srcRect.x + srcRect.y * source.GetHeight()) * source.GetBPP()], NzRectui(dstPos.x, dstPos.y, srcRect.width, srcRect.height));
+}
+
+bool NzImage::CopyToFace(nzCubemapFace face, const NzImage& source, const NzRectui& srcRect, const NzVector2ui& dstPos)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!source.IsValid())
+	{
+		NazaraError("Source image must be valid");
+		return false;
+	}
+
+	if (source.GetFormat() != m_sharedImage->format)
+	{
+		NazaraError("Source image format does not match destination image format");
+		return false;
+	}
+	#endif
+
+	return UpdateFace(face, &source.GetConstPixels()[(srcRect.x + srcRect.y * source.GetHeight()) * source.GetBPP()], NzRectui(dstPos.x, dstPos.y, srcRect.width, srcRect.height));
+}
+
+bool NzImage::Create(nzImageType type, nzPixelFormat format, unsigned int width, unsigned int height, unsigned int depth)
+{
+	ReleaseImage();
+
+	unsigned int size = width*height*depth*NzPixelFormat::GetBPP(format);
+	if (size == 0)
+		return true;
+
+	#if NAZARA_UTILITY_SAFE
+	switch (type)
+	{
+		case nzImageType_1D:
+			if (height > 1)
+			{
+				NazaraError("1D textures must be 1 height");
+				return false;
+			}
+
+			if (depth > 1)
+			{
+				NazaraError("1D textures must be 1 depth");
+				return false;
+			}
+			break;
+
+		case nzImageType_2D:
+			if (depth > 1)
+			{
+				NazaraError("2D textures must be 1 depth");
+				return false;
+			}
+			break;
+
+		case nzImageType_Cubemap:
+			if (depth > 1)
+			{
+				NazaraError("Cubemaps must be 1 depth");
+				return false;
+			}
+
+			if (width != height)
+			{
+				NazaraError("Cubemaps must have square dimensions");
+				return false;
+			}
+
+			size *= 6; // Les cubemaps ont six faces
+			break;
+
+		default:
+			break;
+	}
+	#else
+	if (type == nzImageType_Cubemap)
+		size *= 6; // Les cubemaps ont six faces
+	#endif
+
+	m_sharedImage = new SharedImage(1, type, format, new nzUInt8[size], width, height, depth);
+
+	return true;
+}
+
+void NzImage::Destroy()
+{
+	ReleaseImage();
+}
+
+nzUInt8 NzImage::GetBPP() const
+{
+	return NzPixelFormat::GetBPP(m_sharedImage->format);
+}
+
+const nzUInt8* NzImage::GetConstPixels() const
+{
+	return m_sharedImage->pixels;
+}
+
+unsigned int NzImage::GetDepth() const
+{
+	return m_sharedImage->depth;
+}
+
+nzPixelFormat NzImage::GetFormat() const
+{
+	return m_sharedImage->format;
+}
+
+unsigned int NzImage::GetHeight() const
+{
+	return m_sharedImage->height;
+}
+
+nzUInt8* NzImage::GetPixels()
+{
+	EnsureOwnership();
+
+	return m_sharedImage->pixels;
+}
+
+unsigned int NzImage::GetSize() const
+{
+	return m_sharedImage->width * m_sharedImage->height * m_sharedImage->depth * NzPixelFormat::GetBPP(m_sharedImage->format);
+}
+
+nzImageType	NzImage::GetType() const
+{
+	return m_sharedImage->type;
+}
+
+unsigned int NzImage::GetWidth() const
+{
+	return m_sharedImage->width;
+}
+
+bool NzImage::IsCompressed() const
+{
+	return NzPixelFormat::IsCompressed(m_sharedImage->format);
+}
+
+bool NzImage::IsCubemap() const
+{
+	return m_sharedImage->type == nzImageType_Cubemap;
+}
+
+bool NzImage::IsValid() const
+{
+	return m_sharedImage != &emptyImage;
+}
+
+bool NzImage::LoadFromFile(const NzString& filePath, const NzImageParams& params)
+{
+	return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromFile(this, filePath, params);
+}
+
+bool NzImage::LoadFromMemory(const void* data, std::size_t size, const NzImageParams& params)
+{
+	return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromMemory(this, data, size, params);
+}
+
+bool NzImage::LoadFromStream(NzInputStream& stream, const NzImageParams& params)
+{
+	return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromStream(this, stream, params);
+}
+
+bool NzImage::Update(const nzUInt8* pixels)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!IsValid())
+	{
+		NazaraError("Image must be valid");
+		return false;
+	}
+
+	if (IsCubemap())
+	{
+		NazaraError("Update is not designed for cubemaps, use UpdateFace instead");
+		return false;
+	}
+
+	if (!pixels)
+	{
+		NazaraError("Invalid pixel source");
+		return false;
+	}
+	#endif
+
+	EnsureOwnership();
+
+	std::memcpy(m_sharedImage->pixels, pixels, GetSize());
+
+	return true;
+}
+
+bool NzImage::Update(const nzUInt8* pixels, const NzRectui& rect)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!IsValid())
+	{
+		NazaraError("Image must be valid");
+		return false;
+	}
+
+	if (IsCubemap())
+	{
+		NazaraError("Update is not designed for cubemaps, use UpdateFace instead");
+		return false;
+	}
+
+	if (!pixels)
+	{
+		NazaraError("Invalid pixel source");
+		return false;
+	}
+
+	if (!rect.IsValid())
+	{
+		NazaraError("Invalid rectangle");
+		return false;
+	}
+
+	if (rect.width > m_sharedImage->width || rect.height > m_sharedImage->height)
+	{
+		NazaraError("Rectangle dimensions are out of bounds");
+		return false;
+	}
+	#endif
+
+	EnsureOwnership();
+
+	nzUInt8 bpp = NzPixelFormat::GetBPP(m_sharedImage->format);
+
+	nzUInt8* dstPixels = m_sharedImage->pixels + (rect.x + rect.y * m_sharedImage->width) * bpp;
+	unsigned int srcStride = rect.width * bpp;
+	unsigned int dstStride = m_sharedImage->width * bpp;
+
+	unsigned int blockSize = m_sharedImage->width * bpp;
+	for (unsigned int i = 0; i < rect.height; ++i)
+	{
+		std::memcpy(dstPixels, pixels, blockSize);
+		pixels += srcStride;
+		dstPixels += dstStride;
+	}
+
+	return true;
+}
+
+bool NzImage::UpdateFace(nzCubemapFace face, const nzUInt8* pixels)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!IsValid())
+	{
+		NazaraError("Image must be valid");
+		return false;
+	}
+
+	if (!IsCubemap())
+	{
+		NazaraError("Update is only designed for cubemaps, use Update instead");
+		return false;
+	}
+
+	if (!pixels)
+	{
+		NazaraError("Invalid pixel source");
+		return false;
+	}
+	#endif
+
+	EnsureOwnership();
+
+	unsigned int size = GetSize();
+	std::memcpy(&m_sharedImage->pixels[size*(face-nzCubemapFace_PositiveX)], pixels, size);
+
+	return true;
+}
+
+bool NzImage::UpdateFace(nzCubemapFace face, const nzUInt8* pixels, const NzRectui& rect)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!IsValid())
+	{
+		NazaraError("Image must be valid");
+		return false;
+	}
+
+	if (!IsCubemap())
+	{
+		NazaraError("Update is only designed for cubemaps, use Update instead");
+		return false;
+	}
+
+	if (!pixels)
+	{
+		NazaraError("Invalid pixel source");
+		return false;
+	}
+
+	if (!rect.IsValid())
+	{
+		NazaraError("Invalid rectangle");
+		return false;
+	}
+
+	if (rect.width > m_sharedImage->width || rect.height > m_sharedImage->height)
+	{
+		NazaraError("Rectangle dimensions are out of bounds");
+		return false;
+	}
+	#endif
+
+	EnsureOwnership();
+
+	nzUInt8 bpp = NzPixelFormat::GetBPP(m_sharedImage->format);
+
+	nzUInt8* dstPixels = m_sharedImage->pixels + (rect.x + rect.y * m_sharedImage->width + (face-nzCubemapFace_PositiveX)*m_sharedImage->width*m_sharedImage->height) * bpp;
+	unsigned int srcStride = rect.width * bpp;
+	unsigned int dstStride = m_sharedImage->width * bpp;
+
+	unsigned int blockSize = m_sharedImage->width * bpp;
+	for (unsigned int i = 0; i < rect.height; ++i)
+	{
+		std::memcpy(dstPixels, pixels, blockSize);
+		pixels += srcStride;
+		dstPixels += dstStride;
+	}
+
+	return true;
+}
+
+NzImage& NzImage::operator=(const NzImage& image)
+{
+	ReleaseImage();
+
+	m_sharedImage = image.m_sharedImage;
+	if (m_sharedImage != &emptyImage)
+	{
+		NazaraMutexLock(m_sharedImage->mutex);
+		m_sharedImage->refCount++;
+		NazaraMutexUnlock(m_sharedImage->mutex);
+	}
+
+	return *this;
+}
+
+NzImage& NzImage::operator=(NzImage&& image)
+{
+	std::swap(m_sharedImage, image.m_sharedImage);
+
+	return *this;
+}
+
+void NzImage::RegisterFileLoader(const NzString& extensions, LoadFileFunction loadFile)
+{
+	return RegisterResourceFileLoader(extensions, loadFile);
+}
+
+void NzImage::RegisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
+{
+	return RegisterResourceMemoryLoader(isLoadingSupported, loadMemory);
+}
+
+void NzImage::RegisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
+{
+	return RegisterResourceStreamLoader(isLoadingSupported, loadStream);
+}
+
+void NzImage::UnregisterFileLoader(const NzString& extensions, LoadFileFunction loadFile)
+{
+	UnregisterResourceFileLoader(extensions, loadFile);
+}
+
+void NzImage::UnregisterMemoryLoader(IsMemoryLoadingSupportedFunction isLoadingSupported, LoadMemoryFunction loadMemory)
+{
+	UnregisterResourceMemoryLoader(isLoadingSupported, loadMemory);
+}
+
+void NzImage::UnregisterStreamLoader(IsStreamLoadingSupportedFunction isLoadingSupported, LoadStreamFunction loadStream)
+{
+	UnregisterResourceStreamLoader(isLoadingSupported, loadStream);
+}
+
+void NzImage::EnsureOwnership()
+{
+	if (m_sharedImage == &emptyImage)
+		return;
+
+	NazaraLock(m_sharedImage->mutex);
+	if (m_sharedImage->refCount > 1)
+	{
+		m_sharedImage->refCount--;
+
+		unsigned int size = GetSize();
+
+		nzUInt8* pixels = new nzUInt8[size];
+		std::memcpy(pixels, m_sharedImage->pixels, size);
+
+		m_sharedImage = new SharedImage(1, m_sharedImage->type, m_sharedImage->format, pixels, m_sharedImage->width, m_sharedImage->height, m_sharedImage->depth);
+	}
+}
+
+void NzImage::ReleaseImage()
+{
+	if (m_sharedImage == &emptyImage)
+		return;
+
+	NazaraMutexLock(m_sharedImage->mutex);
+	m_sharedImage->refCount--;
+	NazaraMutexUnlock(m_sharedImage->mutex);
+
+	if (m_sharedImage->refCount == 0)
+	{
+		delete[] m_sharedImage->pixels;
+		delete m_sharedImage;
+	}
+
+	m_sharedImage = &emptyImage;
+}
+
+NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_R8G8B8, nullptr, 0, 0, 0);

src/Nazara/Utility/Loaders/PCX.cpp

@@ -0,0 +1,365 @@
+// Copyright (C) 2011 Jérôme Leclercq
+// This file is part of the "Ungine".
+// For conditions of distribution and use, see copyright notice in Core.h
+
+#include <Nazara/Utility/Loaders/PCX.hpp>
+#include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/File.hpp>
+#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/MemoryStream.hpp>
+#include <Nazara/Utility/Image.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+// Auteur du loader original : David Henry
+
+namespace
+{
+	struct pcx_header
+	{
+		nzUInt8 manufacturer;
+		nzUInt8 version;
+		nzUInt8 encoding;
+		nzUInt8 bitsPerPixel;
+
+		nzUInt16 xmin, ymin;
+		nzUInt16 xmax, ymax;
+		nzUInt16 horzRes, vertRes;
+
+		nzUInt8 palette[48];
+		nzUInt8 reserved;
+		nzUInt8 numColorPlanes;
+
+		nzUInt16 bytesPerScanLine;
+		nzUInt16 paletteType;
+		nzUInt16 horzSize, vertSize;
+
+		nzUInt8 padding[54];
+	};
+
+	bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
+
+	bool NzLoader_PCX_LoadFile(NzImage* resource, const NzString& filePath, const NzImageParams& parameters)
+	{
+		NzFile file(filePath);
+		if (!file.Open(NzFile::ReadOnly))
+		{
+			NazaraError("Failed to open file");
+			return false;
+		}
+
+		return NzLoader_PCX_LoadStream(resource, file, parameters);
+	}
+
+	bool NzLoader_PCX_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
+	{
+		NzMemoryStream stream(data, size);
+		return NzLoader_PCX_LoadStream(resource, stream, parameters);
+	}
+
+	bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		pcx_header header;
+		if (stream.Read(&header, sizeof(pcx_header)) != sizeof(pcx_header))
+		{
+			NazaraError("Failed to read header");
+			return false;
+		}
+
+		if (header.manufacturer != 0x0a)
+		{
+			NazaraError("Bad version number (" + NzString::Number(header.manufacturer) + ')');
+			return false;
+		}
+
+		unsigned int bitCount = header.bitsPerPixel * header.numColorPlanes;
+		unsigned int width = header.xmax - header.xmin+1;
+		unsigned int height = header.ymax - header.ymin+1;
+
+		if (!resource->Create(nzImageType_2D, nzPixelFormat_R8G8B8, width, height))
+		{
+			NazaraError("Failed to create image");
+			return false;
+		}
+
+		nzUInt8* pixels = resource->GetPixels();
+
+		int rle_value = 0;
+		unsigned int rle_count = 0;
+
+		switch (bitCount)
+		{
+			case 1:
+			{
+				for (unsigned int y = 0; y < height; ++y)
+				{
+					nzUInt8* ptr = &pixels[y * width * 3];
+					int bytes = header.bytesPerScanLine;
+
+					/* decode line number y */
+					while (bytes--)
+					{
+						if (rle_count == 0)
+						{
+							if (!stream.Read(&rle_value, 1))
+							{
+								NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+								return false;
+							}
+
+							if (rle_value < 0xc0)
+								rle_count = 1;
+							else
+							{
+								rle_count = rle_value - 0xc0;
+								if (!stream.Read(&rle_value, 1))
+								{
+									NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+									return false;
+								}
+							}
+						}
+
+						rle_count--;
+
+						for (int i = 7; i >= 0; --i)
+						{
+							int colorIndex = ((rle_value & (1 << i)) > 0);
+
+							*ptr++ = header.palette[colorIndex * 3 + 0];
+							*ptr++ = header.palette[colorIndex * 3 + 1];
+							*ptr++ = header.palette[colorIndex * 3 + 2];
+						}
+					}
+				}
+				break;
+			}
+
+			case 4:
+			{
+				nzUInt8* colorIndex = new nzUInt8[width];
+				nzUInt8* line = new nzUInt8[header.bytesPerScanLine];
+
+				for (unsigned int y = 0; y < height; ++y)
+				{
+					nzUInt8* ptr = &pixels[y * width * 3];
+
+					std::memset(colorIndex, 0, width);
+
+					for (unsigned int c = 0; c < 4; ++c)
+					{
+						nzUInt8* pLine = line;
+						int bytes = header.bytesPerScanLine;
+
+						/* decode line number y */
+						while (bytes--)
+						{
+							if (rle_count == 0)
+							{
+								if (!stream.Read(&rle_value, 1))
+								{
+									NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+									delete[] colorIndex;
+									delete[] line;
+
+									return false;
+								}
+
+								if (rle_value < 0xc0)
+									rle_count = 1;
+								else
+								{
+									rle_count = rle_value - 0xc0;
+									if (!stream.Read(&rle_value, 1))
+									{
+										NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+										delete[] colorIndex;
+										delete[] line;
+
+										return false;
+									}
+								}
+							}
+
+							rle_count--;
+							*(pLine++) = rle_value;
+						}
+
+						/* compute line's color indexes */
+						for (unsigned int x = 0; x < width; ++x)
+						{
+							if (line[x / 8] & (128 >> (x % 8)))
+								colorIndex[x] += (1 << c);
+						}
+					}
+
+					/* decode scan line.  color index => rgb  */
+					for (unsigned int x = 0; x < width; ++x)
+					{
+						*ptr++ = header.palette[colorIndex[x] * 3 + 0];
+						*ptr++ = header.palette[colorIndex[x] * 3 + 1];
+						*ptr++ = header.palette[colorIndex[x] * 3 + 2];
+					}
+				}
+
+				/* release memory */
+				delete[] colorIndex;
+				delete[] line;
+				break;
+			}
+
+			case 8:
+			{
+				nzUInt8 palette[768];
+
+				/* the palette is contained in the last 769 bytes of the file */
+				unsigned int curPos = stream.GetCursorPos();
+				stream.SetCursorPos(stream.GetSize()-769);
+				nzUInt8 magic;
+				if (!stream.Read(&magic, 1))
+				{
+					NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+					return false;
+				}
+
+				/* first byte must be equal to 0x0c (12) */
+				if (magic != 0x0c)
+				{
+					NazaraError("Colormap's first byte must be 0x0c (0x" + NzString::Number(magic, 16) + ')');
+					return false;
+				}
+
+				/* read palette */
+				if (stream.Read(palette, 768) != 768)
+				{
+					NazaraError("Failed to read palette");
+					return false;
+				}
+
+				stream.SetCursorPos(curPos);
+
+				/* read pixel data */
+				for (unsigned int y = 0; y < height; ++y)
+				{
+					nzUInt8* ptr = &pixels[y * width * 3];
+					int bytes = header.bytesPerScanLine;
+
+					/* decode line number y */
+					while (bytes--)
+					{
+						if (rle_count == 0)
+						{
+							if (!stream.Read(&rle_value, 1))
+							{
+								NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+								return false;
+							}
+
+							if (rle_value < 0xc0)
+								rle_count = 1;
+							else
+							{
+								rle_count = rle_value - 0xc0;
+								if (!stream.Read(&rle_value, 1))
+								{
+									NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+									return false;
+								}
+							}
+						}
+
+						rle_count--;
+
+						*ptr++ = palette[rle_value * 3 + 0];
+						*ptr++ = palette[rle_value * 3 + 1];
+						*ptr++ = palette[rle_value * 3 + 2];
+					}
+				}
+				break;
+			}
+
+			case 24:
+			{
+				for (unsigned int y = 0; y < height; ++y)
+				{
+					/* for each color plane */
+					for (int c = 0; c < 3; ++c)
+					{
+						nzUInt8* ptr = &pixels[y * width * 4];
+						int bytes = header.bytesPerScanLine;
+
+						/* decode line number y */
+						while (bytes--)
+						{
+							if (rle_count == 0)
+							{
+								if (!stream.Read(&rle_value, 1))
+								{
+									NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+									return false;
+								}
+
+								if (rle_value < 0xc0)
+									rle_count = 1;
+								else
+								{
+									rle_count = rle_value - 0xc0;
+									if (!stream.Read(&rle_value, 1))
+									{
+										NazaraError("Failed to read stream (byte " + NzString::Number(stream.GetCursorPos()) + ')');
+										return false;
+									}
+								}
+							}
+
+							rle_count--;
+							ptr[c] = static_cast<nzUInt8>(rle_value);
+							ptr += 3;
+						}
+					}
+				}
+				break;
+			}
+
+			default:
+				NazaraError("Unknown " + NzString::Number(bitCount) + " bitcount pcx files");
+				return false;
+		}
+
+		return true;
+	}
+
+	bool NzLoader_PCX_IsMemoryLoadingSupported(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_IsStreamLoadingSupported(NzInputStream& stream, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		nzUInt8 manufacturer;
+		stream.Read(&manufacturer, 1);
+
+		return manufacturer == 0x0a;
+	}
+}
+
+void NzLoaders_PCX_Register()
+{
+	NzImage::RegisterFileLoader("pcx", NzLoader_PCX_LoadFile);
+	NzImage::RegisterMemoryLoader(NzLoader_PCX_IsMemoryLoadingSupported, NzLoader_PCX_LoadMemory);
+	NzImage::RegisterStreamLoader(NzLoader_PCX_IsStreamLoadingSupported, NzLoader_PCX_LoadStream);
+}
+
+void NzLoaders_PCX_Unregister()
+{
+	///TODO
+}

src/Nazara/Utility/Loaders/PCX.hpp

@@ -0,0 +1,15 @@
+// Copyright (C) 2012 Jérôme Leclercq
+// This file is part of the "Nazara Engine".
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_LOADERS_PCX_HPP
+#define NAZARA_LOADERS_PCX_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+void NzLoaders_PCX_Register();
+void NzLoaders_PCX_Unregister();
+
+#endif // NAZARA_LOADERS_PCX_HPP

src/Nazara/Utility/Loaders/STB.cpp

@@ -0,0 +1,125 @@
+// Copyright (C) 2011 Jérôme Leclercq
+// This file is part of the "Ungine".
+// For conditions of distribution and use, see copyright notice in Core.h
+
+#include <Nazara/Utility/Loaders/STB.hpp>
+#include <Nazara/Core/Endianness.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/File.hpp>
+#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Core/MemoryStream.hpp>
+#include <Nazara/Utility/Image.hpp>
+
+#define STBI_HEADER_FILE_ONLY
+#include <Nazara/Utility/Loaders/STB/stb_image.c>
+
+#include <Nazara/Utility/Debug.hpp>
+
+// Auteur du loader original : David Henry
+
+namespace
+{
+    int Read(void* userdata, char* data, int size)
+    {
+        NzInputStream* stream = static_cast<NzInputStream*>(userdata);
+        return static_cast<int>(stream->Read(data, size));
+    }
+
+    void Skip(void* userdata, unsigned int size)
+    {
+        NzInputStream* stream = static_cast<NzInputStream*>(userdata);
+        stream->Read(nullptr, size);
+    }
+
+    int Eof(void* userdata)
+    {
+        NzInputStream* stream = static_cast<NzInputStream*>(userdata);
+        return stream->GetCursorPos() >= stream->GetSize();
+    }
+
+	static stbi_io_callbacks callbacks = {Read, Skip, Eof};
+
+	bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
+
+	bool NzLoader_STB_LoadFile(NzImage* resource, 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(resource, file, parameters);
+	}
+
+	bool NzLoader_STB_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
+	{
+		NzMemoryStream stream(data, size);
+		return NzLoader_STB_LoadStream(resource, stream, parameters);
+	}
+
+	bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		static nzPixelFormat format[4] = {
+			nzPixelFormat_L8,
+			nzPixelFormat_L8A8,
+			nzPixelFormat_R8G8B8,
+			nzPixelFormat_R8G8B8A8
+		};
+
+		int width, height, bpp;
+		nzUInt8* ptr = stbi_load_from_callbacks(&callbacks, &stream, &width, &height, &bpp, STBI_default);
+
+		if (!ptr)
+		{
+			NazaraError("Failed to load image: " + NzString(stbi_failure_reason()));
+			return false;
+		}
+
+		if (!resource->Create(nzImageType_2D, format[bpp-1], width, height))
+		{
+			NazaraError("Failed to create image");
+			stbi_image_free(ptr);
+
+			return false;
+		}
+
+		resource->Update(ptr);
+		stbi_image_free(ptr);
+
+		return true;
+	}
+
+	bool NzLoader_STB_IsMemoryLoadingSupported(const void* data, unsigned int size, const NzImageParams& parameters)
+	{
+		NazaraUnused(parameters);
+
+		int width, height, bpp;
+		return stbi_info_from_memory(static_cast<const stbi_uc*>(data), size, &width, &height, &bpp);
+	}
+
+	bool NzLoader_STB_IsStreamLoadingSupported(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()
+{
+	NzImage::RegisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
+	NzImage::RegisterMemoryLoader(NzLoader_STB_IsMemoryLoadingSupported, NzLoader_STB_LoadMemory);
+	NzImage::RegisterStreamLoader(NzLoader_STB_IsStreamLoadingSupported, NzLoader_STB_LoadStream);
+}
+
+void NzLoaders_STB_Unregister()
+{
+	NzImage::UnregisterStreamLoader(NzLoader_STB_IsStreamLoadingSupported, NzLoader_STB_LoadStream);
+	NzImage::UnregisterMemoryLoader(NzLoader_STB_IsMemoryLoadingSupported, NzLoader_STB_LoadMemory);
+	NzImage::UnregisterFileLoader("bmp, gif, hdr, jpg, jpeg, pic, png, psd, tga", NzLoader_STB_LoadFile);
+}

src/Nazara/Utility/Loaders/STB.hpp

@@ -0,0 +1,15 @@
+// Copyright (C) 2012 Jérôme Leclercq
+// This file is part of the "Nazara Engine".
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_LOADERS_STB_HPP
+#define NAZARA_LOADERS_STB_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+void NzLoaders_STB_Register();
+void NzLoaders_STB_Unregister();
+
+#endif // NAZARA_LOADERS_STB_HPP

src/Nazara/Utility/Resource.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Utility/Resource.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Debug.hpp>
 
 NzResource::NzResource(bool persistent) :
 m_resourcePersistent(persistent),
@@ -12,6 +13,12 @@ m_resourceReferenceCount(0)
 {
 }
 
+NzResource::NzResource(const NzResource& resource) :
+m_resourcePersistent(resource.m_resourcePersistent),
+m_resourceReferenceCount(0)
+{
+}
+
 NzResource::~NzResource() = default;
 
 void NzResource::AddResourceReference() const

src/Nazara/Utility/Utility.cpp

@@ -0,0 +1,62 @@
+// Copyright (C) 2012 Jérôme Leclercq
+// This file is part of the "Nazara Engine".
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Utility/Utility.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Loaders/PCX.hpp>
+#include <Nazara/Utility/Loaders/STB.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+NzUtility::NzUtility()
+{
+}
+
+NzUtility::~NzUtility()
+{
+	if (s_initialized)
+		Uninitialize();
+}
+
+bool NzUtility::Initialize()
+{
+	#if NAZARA_UTILITY_SAFE
+	if (s_initialized)
+	{
+		NazaraError("Renderer already initialized");
+		return true;
+	}
+	#endif
+
+	// Loaders spécialisés
+	NzLoaders_PCX_Register(); // Loader de fichiers .PCX (1, 4, 8, 24)
+
+	// Loaders génériques (En dernier pour donner la priorité aux loaders spécialisés)
+	NzLoaders_STB_Register(); // Loader générique (STB)
+
+	s_initialized = true;
+
+	return true;
+}
+
+void NzUtility::Uninitialize()
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!s_initialized)
+	{
+		NazaraError("Utility not initialized");
+		return;
+	}
+	#endif
+
+	NzLoaders_STB_Unregister();
+	NzLoaders_PCX_Unregister();
+}
+
+bool NzUtility::IsInitialized()
+{
+	return s_initialized;
+}
+
+bool NzUtility::s_initialized = false;

src/Nazara/Utility/Win32/WindowImpl.cpp

@@ -9,6 +9,7 @@
 #include <Nazara/Core/Mutex.hpp>
 #include <Nazara/Core/Thread.hpp>
 #include <Nazara/Core/ThreadCondition.hpp>
+#include <Nazara/Utility/Config.hpp>
 #include <cstdio>
 #include <windowsx.h>
 #include <Nazara/Utility/Debug.hpp>