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