Added Meshes and Animations (And many more)

Added NzTexture::IsMipmappingSupported Color::(FromTo)HSV now takes hue and saturation in degrees Fixed Context::EnsureContext Fixed COW thread-safety (String, Image, Matrix4) Fixed Quatenion<T>::operator*(const Vector3<T>&) Fixed ResourceLoader Fixed String::Resize with a size of 0 Fixed Texture mipmapping crash Fixed per-class thread-safety IndexBuffer and VertexBuffer are now resources It is now possible to use more than 8 texcoords per shader Moved all enumerations into separate files (Core/Enums.hpp, Utility/Enums.hpp, ..) Removed NzContextParameters::defaultWindow VertexDeclaration has been rewritten (New interface/COW)
2012-07-13 15:22:14 +02:00
parent 5f95f0b677
commit 06eda4eba9
75 changed files with 3385 additions and 861 deletions
--- a/src/Nazara/Utility/Animation.cpp
+++ b/src/Nazara/Utility/Animation.cpp
@@ -0,0 +1,318 @@
+// 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/Animation.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <vector>
+#include <Nazara/Utility/Debug.hpp>
+
+struct NzAnimationImpl
+{
+	std::map<NzString, unsigned int> sequenceMap;
+	std::vector<NzSequence> sequences;
+	nzAnimationType type;
+	unsigned int frameCount;
+};
+
+bool NzAnimationParams::IsValid() const
+{
+	if (startFrame > endFrame)
+	{
+		NazaraError("Start frame must be lower than end frame");
+		return false;
+	}
+
+	return true;
+}
+
+NzAnimation::~NzAnimation()
+{
+	Destroy();
+}
+
+unsigned int NzAnimation::AddSequence(const NzSequence& sequence)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return 0;
+	}
+	#endif
+
+	unsigned int index = m_impl->sequences.size();
+
+	if (!sequence.name.IsEmpty())
+	{
+		#if NAZARA_UTILITY_SAFE
+		auto it = m_impl->sequenceMap.find(sequence.name);
+		if (it != m_impl->sequenceMap.end())
+		{
+			NazaraError("Sequence name \"" + sequence.name + "\" is already used");
+			return 0;
+		}
+		#endif
+
+		m_impl->sequenceMap[sequence.name] = index;
+	}
+
+	m_impl->sequences.push_back(sequence);
+
+	return index;
+}
+
+bool NzAnimation::Create(nzAnimationType type, unsigned int frameCount)
+{
+	Destroy();
+
+	#if NAZARA_UTILITY_SAFE
+	if (type == nzAnimationType_Static)
+	{
+		NazaraError("Invalid type");
+		return false;
+	}
+
+	if (frameCount == 0)
+	{
+		NazaraError("Frame count must be over zero");
+		return false;
+	}
+	#endif
+
+	m_impl = new NzAnimationImpl;
+	m_impl->frameCount = frameCount;
+	m_impl->type = type;
+
+	return true;
+}
+
+void NzAnimation::Destroy()
+{
+	if (m_impl)
+	{
+		delete m_impl;
+		m_impl = nullptr;
+	}
+}
+
+unsigned int NzAnimation::GetFrameCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->frameCount;
+}
+
+NzSequence* NzAnimation::GetSequence(const NzString& sequenceName)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return nullptr;
+	}
+
+	auto it = m_impl->sequenceMap.find(sequenceName);
+	if (it == m_impl->sequenceMap.end())
+	{
+		NazaraError("Sequence not found");
+		return nullptr;
+	}
+
+	return &m_impl->sequences[it->second];
+	#else
+	return &m_impl->sequences[m_impl->sequenceMap[sequenceName]];
+	#endif
+}
+
+NzSequence* NzAnimation::GetSequence(unsigned int index)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return nullptr;
+	}
+
+	if (index >= m_impl->sequences.size())
+	{
+		NazaraError("Sequence index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->sequences.size()) + ')');
+		return nullptr;
+	}
+	#endif
+
+	return &m_impl->sequences[index];
+}
+
+const NzSequence* NzAnimation::GetSequence(const NzString& sequenceName) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return nullptr;
+	}
+
+	auto it = m_impl->sequenceMap.find(sequenceName);
+	if (it == m_impl->sequenceMap.end())
+	{
+		NazaraError("Sequence not found");
+		return nullptr;
+	}
+
+	return &m_impl->sequences[it->second];
+	#else
+	return &m_impl->sequences[m_impl->sequenceMap[sequenceName]];
+	#endif
+}
+
+const NzSequence* NzAnimation::GetSequence(unsigned int index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return nullptr;
+	}
+
+	if (index >= m_impl->sequences.size())
+	{
+		NazaraError("Sequence index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->sequences.size()) + ')');
+		return nullptr;
+	}
+	#endif
+
+	return &m_impl->sequences[index];
+}
+
+unsigned int NzAnimation::GetSequenceCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return 0;
+	}
+	#endif
+
+	return m_impl->sequences.size();
+}
+
+nzAnimationType NzAnimation::GetType() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return nzAnimationType_Static; // Ce qui est une valeur invalide pour NzAnimation
+	}
+	#endif
+
+	return m_impl->type;
+}
+
+bool NzAnimation::HasSequence(const NzString& sequenceName) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->sequenceMap.find(sequenceName) != m_impl->sequenceMap.end();
+}
+
+bool NzAnimation::HasSequence(unsigned int index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return false;
+	}
+	#endif
+
+	return index >= m_impl->sequences.size();
+}
+
+bool NzAnimation::IsValid() const
+{
+	return m_impl != nullptr;
+}
+
+bool NzAnimation::LoadFromFile(const NzString& filePath, const NzAnimationParams& params)
+{
+	return NzAnimationLoader::LoadFromFile(this, filePath, params);
+}
+
+bool NzAnimation::LoadFromMemory(const void* data, std::size_t size, const NzAnimationParams& params)
+{
+	return NzAnimationLoader::LoadFromMemory(this, data, size, params);
+}
+
+bool NzAnimation::LoadFromStream(NzInputStream& stream, const NzAnimationParams& params)
+{
+	return NzAnimationLoader::LoadFromStream(this, stream, params);
+}
+
+void NzAnimation::RemoveSequence(const NzString& identifier)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return;
+	}
+
+	auto it = m_impl->sequenceMap.find(identifier);
+	if (it == m_impl->sequenceMap.end())
+	{
+		NazaraError("SubMesh not found");
+		return;
+	}
+
+	unsigned int index = it->second;
+	#else
+	unsigned int index = m_impl->sequenceMap[identifier];
+	#endif
+
+	auto it2 = m_impl->sequences.begin();
+	std::advance(it2, index);
+
+	m_impl->sequences.erase(it2);
+}
+
+void NzAnimation::RemoveSequence(unsigned int index)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Animation not created");
+		return;
+	}
+
+	if (index >= m_impl->sequences.size())
+	{
+		NazaraError("Sequence index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->sequences.size()) + ')');
+		return;
+	}
+	#endif
+
+	auto it = m_impl->sequences.begin();
+	std::advance(it, index);
+
+	m_impl->sequences.erase(it);
+}
+
+std::list<NzAnimationLoader::MemoryLoader> NzAnimation::s_memoryLoaders;
+std::list<NzAnimationLoader::StreamLoader> NzAnimation::s_streamLoaders;
+std::multimap<NzString, NzAnimationLoader::LoadFileFunction> NzAnimation::s_fileLoaders;
--- a/src/Nazara/Utility/Image.cpp
+++ b/src/Nazara/Utility/Image.cpp
@@ -5,7 +5,6 @@
 #include <Nazara/Utility/Image.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Utility/Config.hpp>
-#include <Nazara/Utility/ResourceLoader.hpp>
 #include <cmath>
 #include <Nazara/Utility/Debug.hpp>

@@ -22,6 +21,11 @@ namespace
 	}
 }

+bool NzImageParams::IsValid() const
+{
+	return true;
+}
+
 NzImage::NzImage() :
 m_sharedImage(&emptyImage)
 {
@@ -799,17 +803,17 @@ bool NzImage::IsValid() const

 bool NzImage::LoadFromFile(const NzString& filePath, const NzImageParams& params)
 {
-	return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromFile(this, filePath, params);
+	return NzImageLoader::LoadFromFile(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);
+	return NzImageLoader::LoadFromMemory(this, data, size, params);
 }

 bool NzImage::LoadFromStream(NzInputStream& stream, const NzImageParams& params)
 {
-	return NzResourceLoader<NzImage, NzImageParams>::LoadResourceFromStream(this, stream, params);
+	return NzImageLoader::LoadFromStream(this, stream, params);
 }

 bool NzImage::SetLevelCount(nzUInt8 levelCount)
@@ -1091,36 +1095,6 @@ nzUInt8 NzImage::GetMaxLevel(unsigned int width, unsigned int height, unsigned i
 	return std::max(std::max(std::max(widthLevel, heightLevel), depthLevel), 1U);
 }

-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)
@@ -1149,10 +1123,10 @@ void NzImage::ReleaseImage()
 		return;

 	NazaraMutexLock(m_sharedImage->mutex);
-	m_sharedImage->refCount--;
+	bool freeSharedImage = (--m_sharedImage->refCount == 0);
 	NazaraMutexUnlock(m_sharedImage->mutex);

-	if (m_sharedImage->refCount == 0)
+	if (freeSharedImage)
 	{
 		for (unsigned int i = 0; i < m_sharedImage->levelCount; ++i)
 			delete[] m_sharedImage->pixels[i];
@@ -1165,3 +1139,6 @@ void NzImage::ReleaseImage()
 }

 NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_Undefined, 1, nullptr, 0, 0, 0);
+std::list<NzImageLoader::MemoryLoader> NzImage::s_memoryLoaders;
+std::list<NzImageLoader::StreamLoader> NzImage::s_streamLoaders;
+std::multimap<NzString, NzImageLoader::LoadFileFunction> NzImage::s_fileLoaders;
--- a/src/Nazara/Utility/IndexBuffer.cpp
+++ b/src/Nazara/Utility/IndexBuffer.cpp
@@ -52,6 +52,7 @@ m_startIndex(0)
 }

 NzIndexBuffer::NzIndexBuffer(const NzIndexBuffer& indexBuffer) :
+NzResource(true),
 m_buffer(indexBuffer.m_buffer),
 m_ownsBuffer(indexBuffer.m_ownsBuffer),
 m_indexCount(indexBuffer.m_indexCount),
--- a/src/Nazara/Utility/KeyframeMesh.cpp
+++ b/src/Nazara/Utility/KeyframeMesh.cpp
@@ -0,0 +1,13 @@
+// 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/KeyframeMesh.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+NzKeyframeMesh::NzKeyframeMesh(const NzMesh* parent) :
+NzSubMesh(parent)
+{
+}
+
+NzKeyframeMesh::~NzKeyframeMesh() = default;
--- a/src/Nazara/Utility/Loaders/MD2.hpp
+++ b/src/Nazara/Utility/Loaders/MD2.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_MD2_HPP
+#define NAZARA_LOADERS_MD2_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+void NzLoaders_MD2_Register();
+void NzLoaders_MD2_Unregister();
+
+#endif // NAZARA_LOADERS_MD2_HPP
--- a/src/Nazara/Utility/Loaders/MD2/Constants.cpp
+++ b/src/Nazara/Utility/Loaders/MD2/Constants.cpp
@@ -0,0 +1,173 @@
+// 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/MD2/Constants.hpp>
+
+const nzUInt32 md2Ident = 'I' + ('D'<<8) + ('P'<<16) + ('2'<<24);
+
+const NzVector3f md2Normals[162] =
+{
+	NzVector3f(-0.525731f, 0.000000f, 0.850651f),
+	NzVector3f(-0.442863f, 0.238856f, 0.864188f),
+	NzVector3f(-0.295242f, 0.000000f, 0.955423f),
+	NzVector3f(-0.309017f, 0.500000f, 0.809017f),
+	NzVector3f(-0.162460f, 0.262866f, 0.951056f),
+	NzVector3f(0.000000f, 0.000000f, 1.000000f),
+	NzVector3f(0.000000f, 0.850651f, 0.525731f),
+	NzVector3f(-0.147621f, 0.716567f, 0.681718f),
+	NzVector3f(0.147621f, 0.716567f, 0.681718f),
+	NzVector3f(0.000000f, 0.525731f, 0.850651f),
+	NzVector3f(0.309017f, 0.500000f, 0.809017f),
+	NzVector3f(0.525731f, 0.000000f, 0.850651f),
+	NzVector3f(0.295242f, 0.000000f, 0.955423f),
+	NzVector3f(0.442863f, 0.238856f, 0.864188f),
+	NzVector3f(0.162460f, 0.262866f, 0.951056f),
+	NzVector3f(-0.681718f, 0.147621f, 0.716567f),
+	NzVector3f(-0.809017f, 0.309017f, 0.500000f),
+	NzVector3f(-0.587785f, 0.425325f, 0.688191f),
+	NzVector3f(-0.850651f, 0.525731f, 0.000000f),
+	NzVector3f(-0.864188f, 0.442863f, 0.238856f),
+	NzVector3f(-0.716567f, 0.681718f, 0.147621f),
+	NzVector3f(-0.688191f, 0.587785f, 0.425325f),
+	NzVector3f(-0.500000f, 0.809017f, 0.309017f),
+	NzVector3f(-0.238856f, 0.864188f, 0.442863f),
+	NzVector3f(-0.425325f, 0.688191f, 0.587785f),
+	NzVector3f(-0.716567f, 0.681718f, -0.147621f),
+	NzVector3f(-0.500000f, 0.809017f, -0.309017f),
+	NzVector3f(-0.525731f, 0.850651f, 0.000000f),
+	NzVector3f(0.000000f, 0.850651f, -0.525731f),
+	NzVector3f(-0.238856f, 0.864188f, -0.442863f),
+	NzVector3f(0.000000f, 0.955423f, -0.295242f),
+	NzVector3f(-0.262866f, 0.951056f, -0.162460f),
+	NzVector3f(0.000000f, 1.000000f, 0.000000f),
+	NzVector3f(0.000000f, 0.955423f, 0.295242f),
+	NzVector3f(-0.262866f, 0.951056f, 0.162460f),
+	NzVector3f(0.238856f, 0.864188f, 0.442863f),
+	NzVector3f(0.262866f, 0.951056f, 0.162460f),
+	NzVector3f(0.500000f, 0.809017f, 0.309017f),
+	NzVector3f(0.238856f, 0.864188f, -0.442863f),
+	NzVector3f(0.262866f, 0.951056f, -0.162460f),
+	NzVector3f(0.500000f, 0.809017f, -0.309017f),
+	NzVector3f(0.850651f, 0.525731f, 0.000000f),
+	NzVector3f(0.716567f, 0.681718f, 0.147621f),
+	NzVector3f(0.716567f, 0.681718f, -0.147621f),
+	NzVector3f(0.525731f, 0.850651f, 0.000000f),
+	NzVector3f(0.425325f, 0.688191f, 0.587785f),
+	NzVector3f(0.864188f, 0.442863f, 0.238856f),
+	NzVector3f(0.688191f, 0.587785f, 0.425325f),
+	NzVector3f(0.809017f, 0.309017f, 0.500000f),
+	NzVector3f(0.681718f, 0.147621f, 0.716567f),
+	NzVector3f(0.587785f, 0.425325f, 0.688191f),
+	NzVector3f(0.955423f, 0.295242f, 0.000000f),
+	NzVector3f(1.000000f, 0.000000f, 0.000000f),
+	NzVector3f(0.951056f, 0.162460f, 0.262866f),
+	NzVector3f(0.850651f, -0.525731f, 0.000000f),
+	NzVector3f(0.955423f, -0.295242f, 0.000000f),
+	NzVector3f(0.864188f, -0.442863f, 0.238856f),
+	NzVector3f(0.951056f, -0.162460f, 0.262866f),
+	NzVector3f(0.809017f, -0.309017f, 0.500000f),
+	NzVector3f(0.681718f, -0.147621f, 0.716567f),
+	NzVector3f(0.850651f, 0.000000f, 0.525731f),
+	NzVector3f(0.864188f, 0.442863f, -0.238856f),
+	NzVector3f(0.809017f, 0.309017f, -0.500000f),
+	NzVector3f(0.951056f, 0.162460f, -0.262866f),
+	NzVector3f(0.525731f, 0.000000f, -0.850651f),
+	NzVector3f(0.681718f, 0.147621f, -0.716567f),
+	NzVector3f(0.681718f, -0.147621f, -0.716567f),
+	NzVector3f(0.850651f, 0.000000f, -0.525731f),
+	NzVector3f(0.809017f, -0.309017f, -0.500000f),
+	NzVector3f(0.864188f, -0.442863f, -0.238856f),
+	NzVector3f(0.951056f, -0.162460f, -0.262866f),
+	NzVector3f(0.147621f, 0.716567f, -0.681718f),
+	NzVector3f(0.309017f, 0.500000f, -0.809017f),
+	NzVector3f(0.425325f, 0.688191f, -0.587785f),
+	NzVector3f(0.442863f, 0.238856f, -0.864188f),
+	NzVector3f(0.587785f, 0.425325f, -0.688191f),
+	NzVector3f(0.688191f, 0.587785f, -0.425325f),
+	NzVector3f(-0.147621f, 0.716567f, -0.681718f),
+	NzVector3f(-0.309017f, 0.500000f, -0.809017f),
+	NzVector3f(0.000000f, 0.525731f, -0.850651f),
+	NzVector3f(-0.525731f, 0.000000f, -0.850651f),
+	NzVector3f(-0.442863f, 0.238856f, -0.864188f),
+	NzVector3f(-0.295242f, 0.000000f, -0.955423f),
+	NzVector3f(-0.162460f, 0.262866f, -0.951056f),
+	NzVector3f(0.000000f, 0.000000f, -1.000000f),
+	NzVector3f(0.295242f, 0.000000f, -0.955423f),
+	NzVector3f(0.162460f, 0.262866f, -0.951056f),
+	NzVector3f(-0.442863f, -0.238856f, -0.864188f),
+	NzVector3f(-0.309017f, -0.500000f, -0.809017f),
+	NzVector3f(-0.162460f, -0.262866f, -0.951056f),
+	NzVector3f(0.000000f, -0.850651f, -0.525731f),
+	NzVector3f(-0.147621f, -0.716567f, -0.681718f),
+	NzVector3f(0.147621f, -0.716567f, -0.681718f),
+	NzVector3f(0.000000f, -0.525731f, -0.850651f),
+	NzVector3f(0.309017f, -0.500000f, -0.809017f),
+	NzVector3f(0.442863f, -0.238856f, -0.864188f),
+	NzVector3f(0.162460f, -0.262866f, -0.951056f),
+	NzVector3f(0.238856f, -0.864188f, -0.442863f),
+	NzVector3f(0.500000f, -0.809017f, -0.309017f),
+	NzVector3f(0.425325f, -0.688191f, -0.587785f),
+	NzVector3f(0.716567f, -0.681718f, -0.147621f),
+	NzVector3f(0.688191f, -0.587785f, -0.425325f),
+	NzVector3f(0.587785f, -0.425325f, -0.688191f),
+	NzVector3f(0.000000f, -0.955423f, -0.295242f),
+	NzVector3f(0.000000f, -1.000000f, 0.000000f),
+	NzVector3f(0.262866f, -0.951056f, -0.162460f),
+	NzVector3f(0.000000f, -0.850651f, 0.525731f),
+	NzVector3f(0.000000f, -0.955423f, 0.295242f),
+	NzVector3f(0.238856f, -0.864188f, 0.442863f),
+	NzVector3f(0.262866f, -0.951056f, 0.162460f),
+	NzVector3f(0.500000f, -0.809017f, 0.309017f),
+	NzVector3f(0.716567f, -0.681718f, 0.147621f),
+	NzVector3f(0.525731f, -0.850651f, 0.000000f),
+	NzVector3f(-0.238856f, -0.864188f, -0.442863f),
+	NzVector3f(-0.500000f, -0.809017f, -0.309017f),
+	NzVector3f(-0.262866f, -0.951056f, -0.162460f),
+	NzVector3f(-0.850651f, -0.525731f, 0.000000f),
+	NzVector3f(-0.716567f, -0.681718f, -0.147621f),
+	NzVector3f(-0.716567f, -0.681718f, 0.147621f),
+	NzVector3f(-0.525731f, -0.850651f, 0.000000f),
+	NzVector3f(-0.500000f, -0.809017f, 0.309017f),
+	NzVector3f(-0.238856f, -0.864188f, 0.442863f),
+	NzVector3f(-0.262866f, -0.951056f, 0.162460f),
+	NzVector3f(-0.864188f, -0.442863f, 0.238856f),
+	NzVector3f(-0.809017f, -0.309017f, 0.500000f),
+	NzVector3f(-0.688191f, -0.587785f, 0.425325f),
+	NzVector3f(-0.681718f, -0.147621f, 0.716567f),
+	NzVector3f(-0.442863f, -0.238856f, 0.864188f),
+	NzVector3f(-0.587785f, -0.425325f, 0.688191f),
+	NzVector3f(-0.309017f, -0.500000f, 0.809017f),
+	NzVector3f(-0.147621f, -0.716567f, 0.681718f),
+	NzVector3f(-0.425325f, -0.688191f, 0.587785f),
+	NzVector3f(-0.162460f, -0.262866f, 0.951056f),
+	NzVector3f(0.442863f, -0.238856f, 0.864188f),
+	NzVector3f(0.162460f, -0.262866f, 0.951056f),
+	NzVector3f(0.309017f, -0.500000f, 0.809017f),
+	NzVector3f(0.147621f, -0.716567f, 0.681718f),
+	NzVector3f(0.000000f, -0.525731f, 0.850651f),
+	NzVector3f(0.425325f, -0.688191f, 0.587785f),
+	NzVector3f(0.587785f, -0.425325f, 0.688191f),
+	NzVector3f(0.688191f, -0.587785f, 0.425325f),
+	NzVector3f(-0.955423f, 0.295242f, 0.000000f),
+	NzVector3f(-0.951056f, 0.162460f, 0.262866f),
+	NzVector3f(-1.000000f, 0.000000f, 0.000000f),
+	NzVector3f(-0.850651f, 0.000000f, 0.525731f),
+	NzVector3f(-0.955423f, -0.295242f, 0.000000f),
+	NzVector3f(-0.951056f, -0.162460f, 0.262866f),
+	NzVector3f(-0.864188f, 0.442863f, -0.238856f),
+	NzVector3f(-0.951056f, 0.162460f, -0.262866f),
+	NzVector3f(-0.809017f, 0.309017f, -0.500000f),
+	NzVector3f(-0.864188f, -0.442863f, -0.238856f),
+	NzVector3f(-0.951056f, -0.162460f, -0.262866f),
+	NzVector3f(-0.809017f, -0.309017f, -0.500000f),
+	NzVector3f(-0.681718f, 0.147621f, -0.716567f),
+	NzVector3f(-0.681718f, -0.147621f, -0.716567f),
+	NzVector3f(-0.850651f, 0.000000f, -0.525731f),
+	NzVector3f(-0.688191f, 0.587785f, -0.425325f),
+	NzVector3f(-0.587785f, 0.425325f, -0.688191f),
+	NzVector3f(-0.425325f, 0.688191f, -0.587785f),
+	NzVector3f(-0.425325f, -0.688191f, -0.587785f),
+	NzVector3f(-0.587785f, -0.425325f, -0.688191f),
+	NzVector3f(-0.688191f, -0.587785f, -0.425325f)
+};
--- a/src/Nazara/Utility/Loaders/MD2/Constants.hpp
+++ b/src/Nazara/Utility/Loaders/MD2/Constants.hpp
@@ -0,0 +1,65 @@
+// 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
+
+#ifndef NAZARA_LOADERS_MD2_CONSTANTS_HPP
+#define NAZARA_LOADERS_MD2_CONSTANTS_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Math/Vector3.hpp>
+#include <vector>
+
+struct md2_header
+{
+	nzUInt32 ident;         // nombre magique : "IDP2"
+	nzUInt32 version;       // version du format : 8
+
+	nzUInt32 skinwidth;     // largeur texture
+	nzUInt32 skinheight;    // hauteur texture
+
+	nzUInt32 framesize;     // taille d'une frame en octets
+
+	nzUInt32 num_skins;     // nombre de skins
+	nzUInt32 num_vertices;  // nombre de vertices par frame
+	nzUInt32 num_st;        // nombre de coordonnées de texture
+	nzUInt32 num_tris;      // nombre de triangles
+	nzUInt32 num_glcmds;    // nombre de commandes opengl
+	nzUInt32 num_frames;    // nombre de frames
+
+	nzUInt32 offset_skins;  // offset données skins
+	nzUInt32 offset_st;     // offset données coordonnées de texture
+	nzUInt32 offset_tris;   // offset données triangles
+	nzUInt32 offset_frames; // offset données frames
+	nzUInt32 offset_glcmds; // offset données commandes OpenGL
+	nzUInt32 offset_end;    // offset fin de fichier
+};
+
+struct md2_vertex
+{
+	nzUInt8 x, y, z;
+	nzUInt8 n;
+};
+
+struct md2_texCoord
+{
+	nzInt16 u, v;
+};
+
+struct md2_triangle
+{
+	nzUInt16 vertices[3];
+	nzUInt16 texCoords[3];
+};
+
+struct md2_frame
+{
+	NzVector3f              scale;
+	NzVector3f              translate;
+	char                    name[16];
+	std::vector<md2_vertex>	vertices;
+};
+
+extern const nzUInt32 md2Ident;
+extern const NzVector3f md2Normals[162];
+
+#endif // NAZARA_LOADERS_MD2_CONSTANTS_HPP
--- a/src/Nazara/Utility/Loaders/MD2/Loader.cpp
+++ b/src/Nazara/Utility/Loaders/MD2/Loader.cpp
@@ -0,0 +1,266 @@
+// 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/MD2.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/Math/Basic.hpp>
+#include <Nazara/Utility/Mesh.hpp>
+#include <Nazara/Utility/Loaders/MD2/Constants.hpp>
+#include <Nazara/Utility/Loaders/MD2/Mesh.hpp>
+#include <cstddef>
+#include <cstring>
+#include <Nazara/Utility/Debug.hpp>
+
+namespace
+{
+	bool NzLoader_MD2_LoadStream(NzMesh* mesh, NzInputStream& stream, const NzMeshParams& parameters);
+
+	bool NzLoader_MD2_LoadFile(NzMesh* mesh, const NzString& filePath, const NzMeshParams& parameters)
+	{
+		NzFile file(filePath);
+		if (!file.Open(NzFile::ReadOnly))
+		{
+			NazaraError("Failed to open file");
+			return false;
+		}
+
+		return NzLoader_MD2_LoadStream(mesh, file, parameters);
+	}
+
+	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)
+	{
+		md2_header header;
+		if (stream.Read(&header, sizeof(md2_header)) != sizeof(md2_header))
+		{
+			NazaraError("Failed to read header");
+			return false;
+		}
+
+		// Les fichiers MD2 sont en little endian
+		#if NAZARA_BIG_ENDIAN
+		NzByteSwap(&header.ident, sizeof(nzUInt32));
+		#endif
+
+		if (header.ident != md2Ident)
+		{
+			NazaraError("Invalid MD2 file");
+			return false;
+		}
+
+		#if NAZARA_BIG_ENDIAN
+		NzByteSwap(&header.version, sizeof(nzUInt32));
+		#endif
+
+		if (header.version != 8)
+		{
+			NazaraError("Bad version number (" + NzString::Number(header.version) + ')');
+			return false;
+		}
+
+		#if NAZARA_BIG_ENDIAN
+		NzByteSwap(&header.skinwidth, sizeof(nzUInt32));
+		NzByteSwap(&header.skinheight, sizeof(nzUInt32));
+		NzByteSwap(&header.framesize, sizeof(nzUInt32));
+		NzByteSwap(&header.num_skins, sizeof(nzUInt32));
+		NzByteSwap(&header.num_vertices, sizeof(nzUInt32));
+		NzByteSwap(&header.num_st, sizeof(nzUInt32));
+		NzByteSwap(&header.num_tris, sizeof(nzUInt32));
+		NzByteSwap(&header.num_glcmds, sizeof(nzUInt32));
+		NzByteSwap(&header.num_frames, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_skins, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_st, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_tris, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_frames, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_glcmds, sizeof(nzUInt32));
+		NzByteSwap(&header.offset_end, sizeof(nzUInt32));
+		#endif
+
+		if (stream.GetSize() < header.offset_end)
+		{
+			NazaraError("Incomplete MD2 file");
+			return false;
+		}
+
+		/// Création du mesh
+		// Animé ou statique, c'est la question
+		bool animated;
+		unsigned int startFrame = NzClamp(parameters.animation.startFrame, 0U, static_cast<unsigned int>(header.num_frames-1));
+		unsigned int endFrame = NzClamp(parameters.animation.endFrame, 0U, static_cast<unsigned int>(header.num_frames-1));
+
+		if (parameters.loadAnimations && startFrame != endFrame)
+			animated = true;
+		else
+			animated = false;
+
+		if (!mesh->Create((animated) ? nzAnimationType_Keyframe : nzAnimationType_Static)) // Ne devrait pas échouer
+		{
+			NazaraInternalError("Failed to create mesh");
+			return false;
+		}
+
+		/// Chargement des skins
+		if (header.num_skins > 0)
+		{
+			stream.SetCursorPos(header.offset_skins);
+			{
+				char skin[68];
+				for (unsigned int i = 0; i < header.num_skins; ++i)
+				{
+					stream.Read(skin, 68*sizeof(char));
+					mesh->AddSkin(skin);
+				}
+			}
+		}
+
+		/// Chargement des animmations
+		if (animated)
+		{
+			NzAnimation* animation = new NzAnimation;
+			if (animation->Create(nzAnimationType_Keyframe, endFrame-startFrame+1))
+			{
+				NzString frameName;
+
+				NzSequence sequence;
+				sequence.framePerSecond = 10; // Par défaut pour les animations MD2
+
+				char name[16], last[16];
+				stream.SetCursorPos(header.offset_frames + startFrame*header.framesize + offsetof(md2_frame, name));
+				stream.Read(last, 16*sizeof(char));
+
+				int pos = std::strlen(last)-1;
+				for (unsigned int j = 0; j < 2; ++j)
+				{
+					if (!std::isdigit(last[pos]))
+						break;
+
+					pos--;
+				}
+				last[pos+1] = '\0';
+
+				unsigned int numFrames = 0;
+				for (unsigned int i = startFrame; i <= endFrame; ++i)
+				{
+					stream.SetCursorPos(header.offset_frames + i*header.framesize + offsetof(md2_frame, name));
+					stream.Read(name, 16*sizeof(char));
+
+					int pos = std::strlen(name)-1;
+					for (unsigned int j = 0; j < 2; ++j)
+					{
+						if (!std::isdigit(name[pos]))
+							break;
+
+						pos--;
+					}
+					name[pos+1] = '\0';
+
+					if (std::strcmp(name, last) != 0) // Si les deux frames n'ont pas le même nom
+					{
+						// Alors on enregistre la séquence
+						sequence.firstFrame = i-numFrames;
+						sequence.lastFrame = i-1;
+						sequence.name = last;
+						animation->AddSequence(sequence);
+
+						std::strcpy(last, name);
+
+						numFrames = 0;
+					}
+
+					numFrames++;
+				}
+
+				// On ajoute la dernière frame (Qui n'a pas été traitée par la boucle)
+				sequence.firstFrame = endFrame-numFrames;
+				sequence.lastFrame = endFrame;
+				sequence.name = last;
+				animation->AddSequence(sequence);
+
+				mesh->SetAnimation(animation);
+				animation->SetPersistent(false);
+			}
+			else
+				NazaraInternalError("Failed to create animaton");
+		}
+
+		/// Chargement des submesh
+		// Actuellement le loader ne charge qu'un submesh
+		// TODO: Utiliser les commandes OpenGL pour accélérer le rendu
+		NzMD2Mesh* subMesh = new NzMD2Mesh(mesh);
+		if (!subMesh->Create(header, stream, parameters))
+		{
+			NazaraError("Failed to create MD2 mesh");
+			return false;
+		}
+
+		mesh->AddSubMesh(subMesh);
+
+		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 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 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);
+}
+
+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);
+
+	NzMD2Mesh::Uninitialize();
+}
--- a/src/Nazara/Utility/Loaders/MD2/Mesh.cpp
+++ b/src/Nazara/Utility/Loaders/MD2/Mesh.cpp
@@ -0,0 +1,275 @@
+// 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/MD2/Mesh.hpp>
+#include <Nazara/Core/InputStream.hpp>
+#include <Nazara/Math/Matrix4.hpp>
+#include <Nazara/Utility/IndexBuffer.hpp>
+#include <Nazara/Utility/Mesh.hpp>
+#include <Nazara/Utility/VertexBuffer.hpp>
+#include <Nazara/Utility/Debug.hpp>
+
+NzMD2Mesh::NzMD2Mesh(const NzMesh* parent) :
+NzKeyframeMesh(parent),
+m_frames(nullptr),
+m_indexBuffer(nullptr),
+m_vertexBuffer(nullptr)
+{
+}
+
+NzMD2Mesh::~NzMD2Mesh()
+{
+	Destroy();
+}
+
+bool NzMD2Mesh::Create(const md2_header& header, NzInputStream& stream, const NzMeshParams& parameters)
+{
+	Destroy();
+
+	unsigned int startFrame = NzClamp(parameters.animation.startFrame, 0U, static_cast<unsigned int>(header.num_frames-1));
+	unsigned int endFrame = NzClamp(parameters.animation.endFrame, 0U, static_cast<unsigned int>(header.num_frames-1));
+
+	m_frameCount = endFrame - startFrame + 1;
+	m_vertexCount = header.num_tris*3;
+
+	/// Chargement des vertices
+	std::vector<md2_texCoord> texCoords(header.num_st);
+	std::vector<md2_triangle> triangles(header.num_tris);
+
+	// Lecture des coordonnées de texture
+	stream.SetCursorPos(header.offset_st);
+	stream.Read(&texCoords[0], header.num_st*sizeof(md2_texCoord));
+
+	#if NAZARA_BIG_ENDIAN
+	for (unsigned int i = 0; i < header.num_st; ++i)
+	{
+		NzByteSwap(&texCoords[i].u, sizeof(nzInt16));
+		NzByteSwap(&texCoords[i].v, sizeof(nzInt16));
+	}
+	#endif
+
+	stream.SetCursorPos(header.offset_tris);
+	stream.Read(&triangles[0], header.num_tris*sizeof(md2_triangle));
+
+	#if NAZARA_BIG_ENDIAN
+	for (unsigned int i = 0; i < header.num_tris; ++i)
+	{
+		NzByteSwap(&triangles[i].vertices[0], sizeof(nzUInt16));
+		NzByteSwap(&texCoords[i].texCoords[0], sizeof(nzUInt16));
+
+		NzByteSwap(&triangles[i].vertices[1], sizeof(nzUInt16));
+		NzByteSwap(&texCoords[i].texCoords[1], sizeof(nzUInt16));
+
+		NzByteSwap(&triangles[i].vertices[2], sizeof(nzUInt16));
+		NzByteSwap(&texCoords[i].texCoords[2], sizeof(nzUInt16));
+	}
+	#endif
+
+	stream.SetCursorPos(header.offset_frames + header.framesize*startFrame);
+
+	md2_frame frame;
+	frame.vertices.resize(header.num_vertices);
+
+	// Pour que le modèle soit correctement aligné, on génère une matrice de rotation que nous appliquerons à chacune des vertices
+	NzMatrix4f rotationMatrix = NzMatrix4f::Rotate(NzEulerAnglesf(-90.f, 0.f, -90.f));
+	//NzMatrix4f rotationMatrix;
+	//rotationMatrix.SetIdentity();
+
+	unsigned int stride = s_declaration.GetStride(nzElementStream_VertexData);
+
+	m_frames = new Frame[m_frameCount];
+	for (unsigned int i = 0; i < m_frameCount; ++i)
+	{
+		stream.Read(&frame.scale, sizeof(NzVector3f));
+		stream.Read(&frame.translate, sizeof(NzVector3f));
+		stream.Read(&frame.name, 16*sizeof(char));
+		stream.Read(&frame.vertices[0], header.num_vertices*sizeof(md2_vertex));
+
+		#if NAZARA_BIG_ENDIAN
+		NzByteSwap(&frame.scale.x, sizeof(float));
+		NzByteSwap(&frame.scale.y, sizeof(float));
+		NzByteSwap(&frame.scale.z, sizeof(float));
+
+		NzByteSwap(&frame.translate.x, sizeof(float));
+		NzByteSwap(&frame.translate.y, sizeof(float));
+		NzByteSwap(&frame.translate.z, sizeof(float));
+		#endif
+
+		m_frames[i].normal = new nzUInt8[m_vertexCount]; // Nous stockons l'indice de la normale plutôt que la normale (gain d'espace)
+		m_frames[i].vertices = new NzVector3f[m_vertexCount];
+		for (unsigned int t = 0; t < header.num_tris; ++t)
+		{
+			for (unsigned int v = 0; v < 3; ++v)
+			{
+				const md2_vertex& vert = frame.vertices[triangles[t].vertices[v]];
+
+				NzVector3f vertex = rotationMatrix * NzVector3f(vert.x * frame.scale.x + frame.translate.x, vert.y * frame.scale.y + frame.translate.y, vert.z * frame.scale.z + frame.translate.z);
+
+				m_frames[i].normal[t*3+v] = vert.n;
+				m_frames[i].vertices[t*3+v] = vertex;
+			}
+		}
+	}
+
+	nzBufferStorage storage = (NzBuffer::IsSupported(nzBufferStorage_Hardware) && !parameters.forceSoftware) ? nzBufferStorage_Hardware : nzBufferStorage_Software;
+
+	m_indexBuffer = nullptr; // Pas d'indexbuffer pour l'instant
+	m_vertexBuffer = new NzVertexBuffer(m_vertexCount, (3+3+2)*sizeof(float), storage, nzBufferUsage_Dynamic);
+
+	nzUInt8* ptr = reinterpret_cast<nzUInt8*>(m_vertexBuffer->Map(nzBufferAccess_WriteOnly));
+	if (!ptr)
+	{
+		NazaraError("Failed to map vertex buffer");
+		Destroy();
+
+		return false;
+	}
+
+	// On avance jusqu'aux premières coordonnées de texture
+	ptr += s_declaration.GetElement(nzElementStream_VertexData, nzElementUsage_TexCoord)->offset;
+	for (unsigned int t = 0; t < header.num_tris; ++t)
+	{
+		for (unsigned int v = 0; v < 3; ++v)
+		{
+			const md2_texCoord& texC = texCoords[triangles[t].texCoords[v]];
+
+			NzVector2f* coords = reinterpret_cast<NzVector2f*>(ptr);
+			coords->x = texC.u / static_cast<float>(header.skinwidth);
+			coords->y = 1.f - texC.v / static_cast<float>(header.skinheight);
+
+			ptr += stride;
+		}
+	}
+
+	if (!m_vertexBuffer->Unmap())
+	{
+		NazaraError("Failed to unmap buffer");
+		Destroy();
+
+		return false;
+	}
+
+	m_vertexBuffer->AddResourceReference();
+	m_vertexBuffer->SetPersistent(false);
+
+	AnimateImpl(0, 0, 0.f);
+
+	return true;
+}
+
+void NzMD2Mesh::Destroy()
+{
+	if (m_frames)
+	{
+		for (unsigned int i = 0; i < m_frameCount; ++i)
+		{
+			delete[] m_frames[i].normal;
+			delete[] m_frames[i].vertices;
+		}
+
+		delete[] m_frames;
+		m_frames = nullptr;
+	}
+
+	if (m_indexBuffer)
+	{
+		m_indexBuffer->RemoveResourceReference();
+		m_indexBuffer = nullptr;
+	}
+
+	if (m_vertexBuffer)
+	{
+		m_vertexBuffer->RemoveResourceReference();
+		m_vertexBuffer = nullptr;
+	}
+}
+
+nzAnimationType NzMD2Mesh::GetAnimationType() const
+{
+	if (m_frameCount > 1)
+		return nzAnimationType_Keyframe;
+	else
+		return nzAnimationType_Static;
+}
+
+unsigned int NzMD2Mesh::GetFrameCount() const
+{
+	return m_frameCount;
+}
+
+const NzIndexBuffer* NzMD2Mesh::GetIndexBuffer() const
+{
+	return nullptr;
+	//return m_indexBuffer;
+}
+
+nzPrimitiveType NzMD2Mesh::GetPrimitiveType() const
+{
+	return nzPrimitiveType_TriangleList;
+}
+
+const NzVertexBuffer* NzMD2Mesh::GetVertexBuffer() const
+{
+	return m_vertexBuffer;
+}
+
+const NzVertexDeclaration* NzMD2Mesh::GetVertexDeclaration() const
+{
+	return &s_declaration;
+}
+
+void NzMD2Mesh::Initialize()
+{
+	NzVertexElement elements[3];
+	elements[0].offset = 0;
+	elements[0].type = nzElementType_Float3;
+	elements[0].usage = nzElementUsage_Position;
+
+	elements[1].offset = 3*sizeof(float);
+	elements[1].type = nzElementType_Float3;
+	elements[1].usage = nzElementUsage_Normal;
+
+	elements[2].offset = 3*sizeof(float) + 3*sizeof(float);
+	elements[2].type = nzElementType_Float2;
+	elements[2].usage = nzElementUsage_TexCoord;
+
+	s_declaration.Create(elements, 3);
+}
+
+void NzMD2Mesh::Uninitialize()
+{
+	s_declaration.Destroy();
+}
+
+void NzMD2Mesh::AnimateImpl(unsigned int frameA, unsigned int frameB, float interpolation)
+{
+	nzUInt8* ptr = reinterpret_cast<nzUInt8*>(m_vertexBuffer->Map(nzBufferAccess_WriteOnly));
+	if (!ptr)
+	{
+		NazaraError("Failed to map vertex buffer");
+		return;
+	}
+
+	unsigned int stride = s_declaration.GetStride(nzElementStream_VertexData);
+	unsigned int positionOffset = s_declaration.GetElement(nzElementStream_VertexData, nzElementUsage_Position)->offset;
+	unsigned int normalOffset = s_declaration.GetElement(nzElementStream_VertexData, nzElementUsage_Normal)->offset;
+
+	Frame* fA = &m_frames[frameA];
+	Frame* fB = &m_frames[frameB];
+	for (unsigned int i = 0; i < m_vertexCount; ++i)
+	{
+		NzVector3f* position = reinterpret_cast<NzVector3f*>(ptr + positionOffset);
+		NzVector3f* normal = reinterpret_cast<NzVector3f*>(ptr + normalOffset);
+
+		*position	= fA->vertices[i] + interpolation * (fB->vertices[i] - fA->vertices[i]);
+		*normal		= md2Normals[fA->normal[i]] + interpolation * (md2Normals[fB->normal[i]] - md2Normals[fA->normal[i]]);
+
+		ptr += stride;
+	}
+
+	if (!m_vertexBuffer->Unmap())
+		NazaraWarning("Failed to unmap vertex buffer, expect mesh corruption");
+}
+
+NzVertexDeclaration NzMD2Mesh::s_declaration;
--- a/src/Nazara/Utility/Loaders/MD2/Mesh.hpp
+++ b/src/Nazara/Utility/Loaders/MD2/Mesh.hpp
@@ -0,0 +1,64 @@
+// 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_MD2_MESH_HPP
+#define NAZARA_LOADERS_MD2_MESH_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Math/Vector3.hpp>
+#include <Nazara/Utility/KeyframeMesh.hpp>
+#include <Nazara/Utility/VertexDeclaration.hpp>
+#include <Nazara/Utility/Loaders/MD2/Constants.hpp>
+
+class NzIndexBuffer;
+class NzInputStream;
+class NzVertexBuffer;
+struct NzMeshParams;
+
+class NAZARA_API NzMD2Mesh : public NzKeyframeMesh
+{
+	public:
+		NzMD2Mesh(const NzMesh* parent);
+		~NzMD2Mesh();
+
+		bool Create(const md2_header& header, NzInputStream& stream, const NzMeshParams& parameters);
+		void Destroy();
+
+		nzAnimationType GetAnimationType() const;
+		unsigned int GetFrameCount() const;
+		const NzIndexBuffer* GetIndexBuffer() const;
+		nzPrimitiveType GetPrimitiveType() const;
+		const NzVertexBuffer* GetVertexBuffer() const;
+		const NzVertexDeclaration* GetVertexDeclaration() const;
+
+		bool IsAnimated() const;
+
+		static void Initialize();
+		static void Uninitialize();
+
+	private:
+		void AnimateImpl(unsigned int frameA, unsigned int frameB, float interpolation);
+
+		struct Frame
+		{
+			//AxisAlignedBox aabb;
+			nzUInt8* normal;
+			NzVector3f* tangents;
+			NzVector3f* vertices;
+			char name[16];
+		};
+
+		//AxisAlignedBox m_aabb;
+		Frame* m_frames;
+		NzIndexBuffer* m_indexBuffer;
+		NzVertexBuffer* m_vertexBuffer;
+		unsigned int m_frameCount;
+		unsigned int m_vertexCount;
+
+		static NzVertexDeclaration s_declaration;
+};
+
+#endif // NAZARA_LOADERS_MD2_MESH_HPP
--- a/src/Nazara/Utility/Loaders/PCX/Loader.cpp
+++ b/src/Nazara/Utility/Loaders/PCX/Loader.cpp
@@ -37,9 +37,9 @@ namespace
 		nzUInt8 padding[54];
 	};

-	bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
+	bool NzLoader_PCX_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters);

-	bool NzLoader_PCX_LoadFile(NzImage* resource, const NzString& filePath, const NzImageParams& parameters)
+	bool NzLoader_PCX_LoadFile(NzImage* image, const NzString& filePath, const NzImageParams& parameters)
 	{
 		NzFile file(filePath);
 		if (!file.Open(NzFile::ReadOnly))
@@ -48,16 +48,16 @@ namespace
 			return false;
 		}

-		return NzLoader_PCX_LoadStream(resource, file, parameters);
+		return NzLoader_PCX_LoadStream(image, file, parameters);
 	}

-	bool NzLoader_PCX_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
+	bool NzLoader_PCX_LoadMemory(NzImage* image, const void* data, unsigned int size, const NzImageParams& parameters)
 	{
 		NzMemoryStream stream(data, size);
-		return NzLoader_PCX_LoadStream(resource, stream, parameters);
+		return NzLoader_PCX_LoadStream(image, stream, parameters);
 	}

-	bool NzLoader_PCX_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
+	bool NzLoader_PCX_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

@@ -93,13 +93,13 @@ namespace
 		unsigned int width = header.xmax - header.xmin+1;
 		unsigned int height = header.ymax - header.ymin+1;

-		if (!resource->Create(nzImageType_2D, nzPixelFormat_RGB8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1))
+		if (!image->Create(nzImageType_2D, nzPixelFormat_RGB8, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1))
 		{
 			NazaraError("Failed to create image");
 			return false;
 		}

-		nzUInt8* pixels = resource->GetPixels();
+		nzUInt8* pixels = image->GetPixels();

 		int rle_value = 0;
 		unsigned int rle_count = 0;
@@ -339,17 +339,17 @@ namespace
 			}

 			default:
-				NazaraError("Unknown " + NzString::Number(bitCount) + " bitcount pcx files");
+				NazaraError("Unable to load " + NzString::Number(bitCount) + " bitcount pcx files");
 				return false;
 		}

 		if (parameters.loadFormat != nzPixelFormat_Undefined)
-			resource->Convert(parameters.loadFormat);
+			image->Convert(parameters.loadFormat);

 		return true;
 	}

-	bool NzLoader_PCX_IsMemoryLoadingSupported(const void* data, unsigned int size, const NzImageParams& parameters)
+	bool NzLoader_PCX_IdentifyMemory(const void* data, unsigned int size, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

@@ -359,12 +359,13 @@ namespace
 		return *reinterpret_cast<const nzUInt8*>(data) == 0x0a;
 	}

-	bool NzLoader_PCX_IsStreamLoadingSupported(NzInputStream& stream, const NzImageParams& parameters)
+	bool NzLoader_PCX_IdentifyStream(NzInputStream& stream, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

 		nzUInt8 manufacturer;
-		stream.Read(&manufacturer, 1);
+		if (stream.Read(&manufacturer, 1) != 1)
+			return false;

 		return manufacturer == 0x0a;
 	}
@@ -372,14 +373,14 @@ namespace

 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);
+	NzImageLoader::RegisterFileLoader("pcx", NzLoader_PCX_LoadFile);
+	NzImageLoader::RegisterMemoryLoader(NzLoader_PCX_IdentifyMemory, NzLoader_PCX_LoadMemory);
+	NzImageLoader::RegisterStreamLoader(NzLoader_PCX_IdentifyStream, NzLoader_PCX_LoadStream);
 }

 void NzLoaders_PCX_Unregister()
 {
-	NzImage::UnregisterStreamLoader(NzLoader_PCX_IsStreamLoadingSupported, NzLoader_PCX_LoadStream);
-	NzImage::UnregisterMemoryLoader(NzLoader_PCX_IsMemoryLoadingSupported, NzLoader_PCX_LoadMemory);
-	NzImage::UnregisterFileLoader("pcx", NzLoader_PCX_LoadFile);
+	NzImageLoader::UnregisterStreamLoader(NzLoader_PCX_IdentifyStream, NzLoader_PCX_LoadStream);
+	NzImageLoader::UnregisterMemoryLoader(NzLoader_PCX_IdentifyMemory, NzLoader_PCX_LoadMemory);
+	NzImageLoader::UnregisterFileLoader("pcx", NzLoader_PCX_LoadFile);
 }
--- a/src/Nazara/Utility/Loaders/STB/Loader.cpp
+++ b/src/Nazara/Utility/Loaders/STB/Loader.cpp
@@ -15,8 +15,6 @@

 #include <Nazara/Utility/Debug.hpp>

-// Auteur du loader original : David Henry
-
 namespace
 {
    int Read(void* userdata, char* data, int size)
@@ -39,9 +37,9 @@ namespace

 	static stbi_io_callbacks callbacks = {Read, Skip, Eof};

-	bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters);
+	bool NzLoader_STB_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters);

-	bool NzLoader_STB_LoadFile(NzImage* resource, const NzString& filePath, const NzImageParams& parameters)
+	bool NzLoader_STB_LoadFile(NzImage* image, const NzString& filePath, const NzImageParams& parameters)
 	{
 		NzFile file(filePath);
 		if (!file.Open(NzFile::ReadOnly))
@@ -50,16 +48,16 @@ namespace
 			return false;
 		}

-		return NzLoader_STB_LoadStream(resource, file, parameters);
+		return NzLoader_STB_LoadStream(image, file, parameters);
 	}

-	bool NzLoader_STB_LoadMemory(NzImage* resource, const void* data, unsigned int size, const NzImageParams& parameters)
+	bool NzLoader_STB_LoadMemory(NzImage* image, const void* data, unsigned int size, const NzImageParams& parameters)
 	{
 		NzMemoryStream stream(data, size);
-		return NzLoader_STB_LoadStream(resource, stream, parameters);
+		return NzLoader_STB_LoadStream(image, stream, parameters);
 	}

-	bool NzLoader_STB_LoadStream(NzImage* resource, NzInputStream& stream, const NzImageParams& parameters)
+	bool NzLoader_STB_LoadStream(NzImage* image, NzInputStream& stream, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

@@ -112,7 +110,7 @@ namespace
 		if (format == nzPixelFormat_Undefined)
 			format = formats[bpp-1];

-		if (!resource->Create(nzImageType_2D, format, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1))
+		if (!image->Create(nzImageType_2D, format, width, height, 1, (parameters.levelCount > 0) ? parameters.levelCount : 1))
 		{
 			NazaraError("Failed to create image");
 			stbi_image_free(ptr);
@@ -120,17 +118,17 @@ namespace
 			return false;
 		}

-		resource->Update(ptr);
+		image->Update(ptr);

 		stbi_image_free(ptr);

 		if (stbiFormat == STBI_default && parameters.loadFormat != nzPixelFormat_Undefined)
-			resource->Convert(parameters.loadFormat);
+			image->Convert(parameters.loadFormat);

 		return true;
 	}

-	bool NzLoader_STB_IsMemoryLoadingSupported(const void* data, unsigned int size, const NzImageParams& parameters)
+	bool NzLoader_STB_IdentifyMemory(const void* data, unsigned int size, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

@@ -138,7 +136,7 @@ namespace
 		return stbi_info_from_memory(reinterpret_cast<const stbi_uc*>(data), size, &width, &height, &bpp);
 	}

-	bool NzLoader_STB_IsStreamLoadingSupported(NzInputStream& stream, const NzImageParams& parameters)
+	bool NzLoader_STB_IdentifyStream(NzInputStream& stream, const NzImageParams& parameters)
 	{
 		NazaraUnused(parameters);

@@ -149,14 +147,14 @@ namespace

 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);
+	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);
 }

 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);
+	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);
 }
--- a/src/Nazara/Utility/Mesh.cpp
+++ b/src/Nazara/Utility/Mesh.cpp
@@ -0,0 +1,575 @@
+// 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/Mesh.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/SubMesh.hpp>
+#include <cstring>
+#include <deque>
+#include <Nazara/Utility/Debug.hpp>
+
+bool NzMeshParams::IsValid() const
+{
+	if (!animation.IsValid())
+	{
+		NazaraError("Invalid animation parameters");
+		return false;
+	}
+
+	return true;
+}
+
+struct NzMeshImpl
+{
+	std::map<NzString, nzUInt8> subMeshMap;
+	std::deque<NzString> skins;
+	std::vector<NzSubMesh*> subMeshes;
+	nzAnimationType animationType;
+	const NzAnimation* animation = nullptr;
+};
+
+NzMesh::~NzMesh()
+{
+	Destroy();
+}
+
+unsigned int NzMesh::AddSkin(const NzString& skin, bool setDefault)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+
+	if (skin.IsEmpty())
+	{
+		NazaraError("Skin is empty");
+		return 0;
+	}
+	#endif
+
+	if (setDefault)
+		m_impl->skins.push_front(skin);
+	else
+		m_impl->skins.push_back(skin);
+
+	return m_impl->skins.size()-1;
+}
+
+nzUInt8 NzMesh::AddSubMesh(NzSubMesh* subMesh)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+
+	if (!subMesh)
+	{
+		NazaraError("Invalid submesh");
+		return 0;
+	}
+	#endif
+
+	subMesh->AddResourceReference();
+	m_impl->subMeshes.push_back(subMesh);
+
+	return m_impl->subMeshes.size()-1;
+}
+
+nzUInt8 NzMesh::AddSubMesh(const NzString& identifier, NzSubMesh* subMesh)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+
+	if (identifier.IsEmpty())
+	{
+		NazaraError("Identifier is empty");
+		return 0;
+	}
+
+	auto it = m_impl->subMeshMap.find(identifier);
+	if (it != m_impl->subMeshMap.end())
+	{
+		NazaraError("SubMesh identifier \"" + identifier + "\" is already used");
+		return it->second;
+	}
+
+	if (!subMesh)
+	{
+		NazaraError("Invalid submesh");
+		return 0;
+	}
+	#endif
+
+	nzUInt8 index = m_impl->subMeshes.size();
+
+	subMesh->AddResourceReference();
+
+	m_impl->subMeshes.push_back(subMesh);
+	m_impl->subMeshMap[identifier] = index;
+
+	return index;
+}
+
+void NzMesh::Animate(unsigned int frameA, unsigned int frameB, float interpolation)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return;
+	}
+
+	if (!m_impl->animation)
+	{
+		NazaraError("Mesh has no animation");
+		return;
+	}
+
+	unsigned int frameCount = m_impl->animation->GetFrameCount();
+	if (frameA >= frameCount)
+	{
+		NazaraError("Frame A is out of range (" + NzString::Number(frameA) + " >= " + NzString::Number(frameCount) + ')');
+		return;
+	}
+
+	if (frameB >= frameCount)
+	{
+		NazaraError("Frame B is out of range (" + NzString::Number(frameB) + " >= " + NzString::Number(frameCount) + ')');
+		return;
+	}
+
+	if (interpolation < 0.f || interpolation > 1.f)
+	{
+		NazaraError("Interpolation must be in range [0..1] (Got " + NzString::Number(interpolation) + ')');
+		return;
+	}
+	#endif
+
+	for (NzSubMesh* subMesh : m_impl->subMeshes)
+		subMesh->AnimateImpl(frameA, frameB, interpolation);
+}
+
+bool NzMesh::Create(nzAnimationType type)
+{
+	Destroy();
+
+	m_impl = new NzMeshImpl;
+	m_impl->animationType = type;
+
+	return true;
+}
+
+void NzMesh::Destroy()
+{
+	if (m_impl)
+	{
+		if (m_impl->animation)
+			m_impl->animation->RemoveResourceReference();
+
+		for (NzSubMesh* subMesh : m_impl->subMeshes)
+			subMesh->RemoveResourceReference();
+
+		delete m_impl;
+		m_impl = nullptr;
+	}
+}
+
+const NzAnimation* NzMesh::GetAnimation() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->animation;
+}
+
+nzAnimationType NzMesh::GetAnimationType() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nzAnimationType_Static;
+	}
+	#endif
+
+	return m_impl->animationType;
+}
+
+unsigned int NzMesh::GetFrameCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+
+	if (!m_impl->animation)
+	{
+		NazaraError("Mesh has no animation");
+		return 0;
+	}
+	#endif
+
+	return m_impl->animation->GetFrameCount();
+}
+
+NzString NzMesh::GetSkin(unsigned int index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return NzString();
+	}
+
+	if (index >= m_impl->skins.size())
+	{
+		NazaraError("Skin index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->skins.size()) + ')');
+		return NzString();
+	}
+	#endif
+
+	return m_impl->skins[index];
+}
+
+unsigned int NzMesh::GetSkinCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+	#endif
+
+	return m_impl->skins.size();
+}
+
+NzSubMesh* NzMesh::GetSubMesh(const NzString& identifier)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nullptr;
+	}
+
+	auto it = m_impl->subMeshMap.find(identifier);
+	if (it == m_impl->subMeshMap.end())
+	{
+		NazaraError("SubMesh not found");
+		return nullptr;
+	}
+
+	return m_impl->subMeshes[it->second];
+	#else
+	return m_impl->subMeshes[m_impl->subMeshMap[identifier]];
+	#endif
+}
+
+NzSubMesh* NzMesh::GetSubMesh(nzUInt8 index)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nullptr;
+	}
+
+	if (index >= m_impl->subMeshes.size())
+	{
+		NazaraError("SubMesh index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->subMeshes.size()) + ')');
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->subMeshes[index];
+}
+
+const NzSubMesh* NzMesh::GetSubMesh(const NzString& identifier) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nullptr;
+	}
+
+	auto it = m_impl->subMeshMap.find(identifier);
+	if (it == m_impl->subMeshMap.end())
+	{
+		NazaraError("SubMesh not found");
+		return nullptr;
+	}
+
+	return m_impl->subMeshes[it->second];
+	#else
+	return m_impl->subMeshes[m_impl->subMeshMap[identifier]];
+	#endif
+}
+
+const NzSubMesh* NzMesh::GetSubMesh(nzUInt8 index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return nullptr;
+	}
+
+	if (index >= m_impl->subMeshes.size())
+	{
+		NazaraError("SubMesh index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->subMeshes.size()) + ')');
+		return nullptr;
+	}
+	#endif
+
+	return m_impl->subMeshes[index];
+}
+
+nzUInt8 NzMesh::GetSubMeshCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+	#endif
+
+	return m_impl->subMeshes.size();
+}
+
+unsigned int NzMesh::GetVertexCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return 0;
+	}
+	#endif
+
+	unsigned int vertexCount = 0;
+	for (NzSubMesh* subMesh : m_impl->subMeshes)
+		vertexCount += subMesh->GetVertexCount();
+
+	return vertexCount;
+}
+
+bool NzMesh::HasAnimation() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->animation != nullptr;
+}
+
+bool NzMesh::HasSkin(unsigned int index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->skins.size() > index;
+}
+
+bool NzMesh::HasSubMesh(const NzString& identifier) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->subMeshMap.find(identifier) != m_impl->subMeshMap.end();
+}
+
+bool NzMesh::HasSubMesh(nzUInt8 index) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+	#endif
+
+	return index < m_impl->subMeshes.size();
+}
+
+bool NzMesh::IsAnimable() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+	#endif
+
+	return m_impl->animationType != nzAnimationType_Static;
+}
+
+bool NzMesh::IsValid() const
+{
+	return m_impl != nullptr;
+}
+
+bool NzMesh::LoadFromFile(const NzString& filePath, const NzMeshParams& params)
+{
+	return NzMeshLoader::LoadFromFile(this, filePath, params);
+}
+
+bool NzMesh::LoadFromMemory(const void* data, std::size_t size, const NzMeshParams& params)
+{
+	return NzMeshLoader::LoadFromMemory(this, data, size, params);
+}
+
+bool NzMesh::LoadFromStream(NzInputStream& stream, const NzMeshParams& params)
+{
+	return NzMeshLoader::LoadFromStream(this, stream, params);
+}
+
+void NzMesh::RemoveSkin(unsigned int index)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return;
+	}
+
+	if (m_impl->skins.size() <= index)
+	{
+		NazaraError("Skin index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->skins.size()) + ')');
+		return;
+	}
+	#endif
+
+	auto it = m_impl->skins.begin();
+	std::advance(it, index);
+
+	m_impl->skins.erase(it);
+}
+
+void NzMesh::RemoveSubMesh(const NzString& identifier)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return;
+	}
+
+	auto it = m_impl->subMeshMap.find(identifier);
+	if (it == m_impl->subMeshMap.end())
+	{
+		NazaraError("SubMesh not found");
+		return;
+	}
+
+	unsigned int index = it->second;
+	#else
+	unsigned int index = m_impl->subMeshMap[identifier];
+	#endif
+
+	auto it2 = m_impl->subMeshes.begin();
+	std::advance(it2, index);
+
+	m_impl->subMeshes.erase(it2);
+}
+
+void NzMesh::RemoveSubMesh(nzUInt8 index)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return;
+	}
+
+	if (index >= m_impl->subMeshes.size())
+	{
+		NazaraError("SubMesh index out of range (" + NzString::Number(index) + " >= " + NzString::Number(m_impl->subMeshes.size()) + ')');
+		return;
+	}
+	#endif
+
+	auto it = m_impl->subMeshes.begin();
+	std::advance(it, index);
+
+	m_impl->subMeshes.erase(it);
+}
+
+bool NzMesh::SetAnimation(const NzAnimation* animation)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_impl)
+	{
+		NazaraError("Mesh not created");
+		return false;
+	}
+
+	if (m_impl->animationType == nzAnimationType_Static)
+	{
+		NazaraError("Static meshes cannot have animation");
+		return false;
+	}
+	#endif
+
+	if (animation == m_impl->animation)
+		return true;
+
+	if (m_impl->animation)
+		m_impl->animation->RemoveResourceReference();
+
+	if (animation)
+	{
+		#if NAZARA_UTILITY_SAFE
+		if (animation->GetType() != m_impl->animationType)
+		{
+			NazaraError("Animation's type must match mesh animation type");
+			return false;
+		}
+		#endif
+
+		m_impl->animation = animation;
+		m_impl->animation->AddResourceReference();
+	}
+	else
+		m_impl->animation = nullptr;
+
+	return true;
+}
+
+std::list<NzMeshLoader::MemoryLoader> NzMesh::s_memoryLoaders;
+std::list<NzMeshLoader::StreamLoader> NzMesh::s_streamLoaders;
+std::multimap<NzString, NzMeshLoader::LoadFileFunction> NzMesh::s_fileLoaders;
--- a/src/Nazara/Utility/StaticMesh.cpp
+++ b/src/Nazara/Utility/StaticMesh.cpp
@@ -0,0 +1,141 @@
+// 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/StaticMesh.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <stdexcept>
+#include <Nazara/Utility/Debug.hpp>
+
+NzStaticMesh::NzStaticMesh(const NzMesh* parent) :
+NzSubMesh(parent)
+{
+}
+
+NzStaticMesh::NzStaticMesh(const NzMesh* parent, const NzVertexBuffer* vertexBuffer, const NzVertexDeclaration* vertexDeclaration, const NzIndexBuffer* indexBuffer) :
+NzSubMesh(parent)
+{
+	#ifdef NAZARA_DEBUG
+	if (!Create(vertexBuffer, vertexDeclaration, indexBuffer))
+	{
+		NazaraError("Failed to create mesh");
+		throw std::runtime_error("Constructor failed");
+	}
+	#else
+	Create(vertexBuffer, vertexDeclaration, indexBuffer);
+	#endif
+}
+
+NzStaticMesh::~NzStaticMesh()
+{
+	Destroy();
+}
+
+bool NzStaticMesh::Create(const NzVertexBuffer* vertexBuffer, const NzVertexDeclaration* vertexDeclaration, const NzIndexBuffer* indexBuffer)
+{
+	Destroy();
+
+	#if NAZARA_UTILITY_SAFE
+	if (!vertexBuffer)
+	{
+		NazaraError("Vertex buffer is null");
+		return false;
+	}
+
+	if (!vertexDeclaration)
+	{
+		NazaraError("Vertex declaration is null");
+		return false;
+	}
+	#endif
+
+	if (indexBuffer)
+	{
+		m_indexBuffer = indexBuffer;
+		m_indexBuffer->AddResourceReference();
+	}
+
+	m_vertexBuffer = vertexBuffer;
+	m_vertexBuffer->AddResourceReference();
+
+	m_vertexDeclaration = vertexDeclaration;
+	m_vertexDeclaration->AddResourceReference();
+
+	return true;
+}
+
+void NzStaticMesh::Destroy()
+{
+	if (m_indexBuffer)
+	{
+		m_indexBuffer->RemoveResourceReference();
+		m_indexBuffer = nullptr;
+	}
+
+	if (m_vertexBuffer)
+	{
+		m_vertexBuffer->RemoveResourceReference();
+		m_vertexBuffer = nullptr;
+	}
+
+	if (m_vertexDeclaration)
+	{
+		m_vertexDeclaration->RemoveResourceReference();
+		m_vertexDeclaration = nullptr;
+	}
+}
+
+nzAnimationType NzStaticMesh::GetAnimationType() const
+{
+	return nzAnimationType_Static;
+}
+
+unsigned int NzStaticMesh::GetFrameCount() const
+{
+	return 1;
+}
+
+const NzIndexBuffer* NzStaticMesh::GetIndexBuffer() const
+{
+	return m_indexBuffer;
+}
+
+nzPrimitiveType NzStaticMesh::GetPrimitiveType() const
+{
+	return m_primitiveType;
+}
+
+const NzVertexBuffer* NzStaticMesh::GetVertexBuffer() const
+{
+	return m_vertexBuffer;
+}
+
+const NzVertexDeclaration* NzStaticMesh::GetVertexDeclaration() const
+{
+	return m_vertexDeclaration;
+}
+
+bool NzStaticMesh::IsAnimated() const
+{
+	return false;
+}
+
+bool NzStaticMesh::IsValid() const
+{
+	return m_vertexBuffer != nullptr && m_vertexDeclaration != nullptr;
+}
+
+void NzStaticMesh::SetPrimitiveType(nzPrimitiveType primitiveType)
+{
+	m_primitiveType = primitiveType;
+}
+
+void NzStaticMesh::AnimateImpl(unsigned int frameA, unsigned int frameB, float interpolation)
+{
+	NazaraUnused(frameA);
+	NazaraUnused(frameB);
+	NazaraUnused(interpolation);
+
+	// Le safe mode est censé nous protéger de cet appel
+	NazaraError("Static mesh have no animation, please enable safe mode");
+}
--- a/src/Nazara/Utility/SubMesh.cpp
+++ b/src/Nazara/Utility/SubMesh.cpp
@@ -0,0 +1,68 @@
+// 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/SubMesh.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Mesh.hpp>
+#include <stdexcept>
+#include <Nazara/Utility/Debug.hpp>
+
+NzSubMesh::NzSubMesh(const NzMesh* parent) :
+NzResource(false), // Un SubMesh n'est pas persistant par défaut
+m_parent(parent)
+{
+	#if NAZARA_DEBUG
+	if (!m_parent)
+	{
+		NazaraError("Parent mesh is null");
+		throw std::invalid_argument("Parent mesh must be valid");
+	}
+	#endif
+}
+
+NzSubMesh::~NzSubMesh() = default;
+
+void NzSubMesh::Animate(unsigned int frameA, unsigned int frameB, float interpolation)
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_parent->HasAnimation())
+	{
+		NazaraError("SubMesh is not animated");
+		return;
+	}
+
+	unsigned int frameCount = m_parent->GetFrameCount();
+	if (frameA >= frameCount)
+	{
+		NazaraError("Frame A is out of range (" + NzString::Number(frameA) + " >= " + NzString::Number(frameCount) + ')');
+		return;
+	}
+
+	if (frameB >= frameCount)
+	{
+		NazaraError("Frame B is out of range (" + NzString::Number(frameB) + " >= " + NzString::Number(frameCount) + ')');
+		return;
+	}
+
+	if (interpolation < 0.f || interpolation > 1.f)
+	{
+		NazaraError("Interpolation must be in range [0..1] (Got " + NzString::Number(interpolation) + ')');
+		return;
+	}
+	#endif
+
+	AnimateImpl(frameA, frameB, interpolation);
+}
+
+const NzMesh* NzSubMesh::GetParent() const
+{
+	return m_parent;
+}
+
+unsigned int NzSubMesh::GetVertexCount() const
+{
+	return GetVertexBuffer()->GetVertexCount();
+}
--- a/src/Nazara/Utility/Utility.cpp
+++ b/src/Nazara/Utility/Utility.cpp
@@ -6,6 +6,7 @@
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 #include <Nazara/Utility/Config.hpp>
+#include <Nazara/Utility/Loaders/MD2.hpp>
 #include <Nazara/Utility/Loaders/PCX.hpp>
 #include <Nazara/Utility/Loaders/STB.hpp>
 #include <Nazara/Utility/PixelFormat.hpp>
@@ -53,9 +54,14 @@ bool NzUtility::Initialize()
 	}

 	/// Loaders spécialisés
+	// Mesh
+	NzLoaders_MD2_Register(); // Loader de fichiers .MD2 (v8)
+
+	// Image
 	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)
+	// Image
 	NzLoaders_STB_Register(); // Loader générique (STB)

 	s_initialized = true;
@@ -73,8 +79,9 @@ void NzUtility::Uninitialize()
 	}
 	#endif

-	NzLoaders_STB_Unregister();
+	NzLoaders_MD2_Unregister();
 	NzLoaders_PCX_Unregister();
+	NzLoaders_STB_Unregister();

 	NzWindow::Uninitialize();
 	NzPixelFormat::Uninitialize();
--- a/src/Nazara/Utility/VertexBuffer.cpp
+++ b/src/Nazara/Utility/VertexBuffer.cpp
@@ -4,6 +4,7 @@

 #include <Nazara/Utility/VertexBuffer.hpp>
 #include <Nazara/Core/Error.hpp>
+#include <stdexcept>
 #include <Nazara/Utility/Debug.hpp>

 NzVertexBuffer::NzVertexBuffer(NzBuffer* buffer, unsigned int startVertex, unsigned int vertexCount) :
@@ -15,8 +16,8 @@ m_vertexCount(vertexCount)
 	#ifdef NAZARA_DEBUG
 	if (!m_buffer)
 	{
-		NazaraError("Passed buffer is null");
-		return;
+		NazaraError("Buffer is null");
+		throw std::invalid_argument("Buffer must be valid");
 	}
 	#endif

@@ -34,6 +35,7 @@ m_vertexCount(length)
 }

 NzVertexBuffer::NzVertexBuffer(const NzVertexBuffer& vertexBuffer) :
+NzResource(true),
 m_ownsBuffer(vertexBuffer.m_ownsBuffer),
 m_startVertex(vertexBuffer.m_startVertex),
 m_vertexCount(vertexBuffer.m_vertexCount)
--- a/src/Nazara/Utility/VertexDeclaration.cpp
+++ b/src/Nazara/Utility/VertexDeclaration.cpp
@@ -5,6 +5,17 @@
 #include <Nazara/Utility/VertexDeclaration.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Utility/Config.hpp>
+#include <algorithm>
+#include <cstring>
+#include <stdexcept>
+#include <vector>
+
+#if NAZARA_THREADSAFETY_VERTEXDECLARATION
+#include <Nazara/Core/ThreadSafety.hpp>
+#else
+#include <Nazara/Core/ThreadSafetyOff.hpp>
+#endif
+
 #include <Nazara/Utility/Debug.hpp>

 namespace
@@ -21,99 +32,315 @@ namespace
 		12,	// nzElementType_Float3
 		16	// nzElementType_Float4
 	};
+
+	bool VertexElementCompare(const NzVertexElement& elementA, const NzVertexElement& elementB)
+	{
+		// Nous classons d'abord par stream
+		if (elementA.stream == elementB.stream)
+		{
+			// Ensuite par usage
+			if (elementA.usage == elementB.usage)
+				// Et finalement par usageIndex
+				return elementA.usageIndex < elementB.usageIndex;
+			else
+				return elementA.usage < elementB.usage;
+		}
+		else
+			return elementA.stream < elementB.stream;
+	}
+}
+
+struct NzVertexDeclarationImpl
+{
+	std::vector<NzVertexElement> elements;
+	int elementPos[nzElementStream_Max+1][nzElementUsage_Max+1];
+	int streamPos[nzElementStream_Max+1];
+	unsigned int stride[nzElementStream_Max+1] = {0};
+
+	unsigned short refCount;
+	NazaraMutex(mutex)
+};
+
+NzVertexDeclaration::NzVertexDeclaration(const NzVertexElement* elements, unsigned int elementCount)
+{
+	#ifdef NAZARA_DEBUG
+	if (!Create(elements, elementCount))
+	{
+		NazaraError("Failed to create declaration");
+		throw std::runtime_error("Constructor failed");
+	}
+	#else
+	Create(elements, elementCount);
+	#endif
+}
+
+NzVertexDeclaration::NzVertexDeclaration(const NzVertexDeclaration& declaration) :
+NzResource(),
+m_sharedImpl(declaration.m_sharedImpl)
+{
+	if (m_sharedImpl)
+	{
+		NazaraMutexLock(m_sharedImpl->mutex);
+		m_sharedImpl->refCount++;
+		NazaraMutexUnlock(m_sharedImpl->mutex);
+	}
+}
+
+NzVertexDeclaration::NzVertexDeclaration(NzVertexDeclaration&& declaration) :
+m_sharedImpl(declaration.m_sharedImpl)
+{
+	declaration.m_sharedImpl = nullptr;
+}
+
+NzVertexDeclaration::~NzVertexDeclaration()
+{
+	Destroy();
 }

 bool NzVertexDeclaration::Create(const NzVertexElement* elements, unsigned int elementCount)
 {
+	Destroy();
+
+	#if NAZARA_UTILITY_SAFE
+	if (!elements || elementCount == 0)
+	{
+		NazaraError("No element");
+		return false;
+	}
+	#endif
+
+	NzVertexDeclarationImpl* impl = new NzVertexDeclarationImpl;
+	std::memset(&impl->elementPos, -1, (nzElementStream_Max+1)*(nzElementUsage_Max+1)*sizeof(int));
+	std::memset(&impl->streamPos, -1, (nzElementStream_Max+1)*sizeof(int));
+
+	// On copie et trie les éléments
+	impl->elements.resize(elementCount);
+	std::memcpy(&impl->elements[0], elements, elementCount*sizeof(NzVertexElement));
+	std::sort(impl->elements.begin(), impl->elements.end(), VertexElementCompare);
+
 	for (unsigned int i = 0; i < elementCount; ++i)
 	{
-		unsigned int stream = elements[i].stream;
-
-		if (stream >= m_streams.size())
-			m_streams.resize(stream+1);
+		NzVertexElement& current = impl->elements[i];
 		#if NAZARA_UTILITY_SAFE
-		else // Seulement si le stream ne vient pas d'être créé (Autrement c'est inutile)
+		// Notre tableau étant trié, s'il y a collision, les deux éléments identiques se suivent...
+		if (i > 0)
 		{
-			for (unsigned int j = 0; j < i; ++j)
+			NzVertexElement& previous = impl->elements[i-1]; // On accède à l'élément précédent
+			if (previous.usage == current.usage && previous.usageIndex == current.usageIndex && previous.stream == current.stream)
 			{
-				if (elements[j].stream == stream && elements[j].usage == elements[i].usage && elements[j].usageIndex == elements[i].usageIndex)
-				{
-					NazaraError("Element usage (" + NzString::Number(elements[j].usage, 16) + ") collision on stream " + NzString::Number(stream) + " with usage index " + NzString::Number(elements[j].usageIndex));
-					return false;
-				}
+				// Les deux éléments sont identiques là où ils ne devraient pas, nous avons une collision...
+				NazaraError("Element usage 0x" + NzString::Number(current.usage, 16) + " collision with usage index " + NzString::Number(current.usageIndex) + " on stream 0x" + NzString::Number(current.stream, 16));
+				delete impl;
+
+				return false;
 			}
 		}
 		#endif

-		Element element;
-		element.offset = elements[i].offset;
-		element.type = elements[i].type;
-		element.usage = elements[i].usage;
-		element.usageIndex = elements[i].usageIndex;
+		if (current.usageIndex == 0)
+			impl->elementPos[current.stream][current.usage] = i;

-		m_streams[stream].elements.push_back(element);
+		if (impl->streamPos[current.stream] == -1)
+			impl->streamPos[current.stream] = i; // Premier élément du stream (via le triage)
+
+		impl->stride[current.stream] += size[current.type];
 	}

-	for (Stream& stream : m_streams)
-	{
-		stream.stride = 0;
-		for (const Element& element : stream.elements)
-			stream.stride += size[element.type];
+	#if NAZARA_RENDERER_FORCE_DECLARATION_STRIDE_MULTIPLE_OF_32
+	for (unsigned int& stride : impl->stride)
+		stride = ((static_cast<int>(stride)-1)/32+1)*32;
+	#endif

-		#if NAZARA_RENDERER_FORCE_DECLARATION_STRIDE_MULTIPLE_OF_32
-		stream.stride = ((static_cast<int>(stream.stride)-1)/32+1)*32;
-		#endif
-	}
+	m_sharedImpl = impl;

 	return true;
 }

-const NzVertexDeclaration::Element* NzVertexDeclaration::GetElement(unsigned int i, unsigned int stream) const
+void NzVertexDeclaration::Destroy()
+{
+	if (!m_sharedImpl)
+		return;
+
+	NazaraMutexLock(m_sharedImpl->mutex);
+	bool freeSharedImpl = (--m_sharedImpl->refCount == 0);
+	NazaraMutexUnlock(m_sharedImpl->mutex);
+
+	if (freeSharedImpl)
+		delete m_sharedImpl;
+
+	m_sharedImpl = nullptr;
+}
+
+const NzVertexElement* NzVertexDeclaration::GetElement(unsigned int i) const
 {
 	#if NAZARA_UTILITY_SAFE
-	if (stream >= m_streams.size())
+	if (!m_sharedImpl)
 	{
-		NazaraError("Stream out of range");
+		NazaraError("Declaration not created");
 		return nullptr;
 	}

-	if (i >= m_streams[stream].elements.size())
+	if (i >= m_sharedImpl->elements.size())
 	{
-		NazaraError("Index out of range");
+		NazaraError("Element index out of range (" + NzString::Number(i) + " >= " + NzString::Number(m_sharedImpl->elements.size()) + ')');
 		return nullptr;
 	}
 	#endif

-	return &m_streams[stream].elements[i];
+	return &m_sharedImpl->elements[i];
 }

-unsigned int NzVertexDeclaration::GetElementCount(unsigned int stream) const
+const NzVertexElement* NzVertexDeclaration::GetElement(nzElementStream stream, unsigned int i) const
 {
 	#if NAZARA_UTILITY_SAFE
-	if (stream >= m_streams.size())
+	if (!m_sharedImpl)
 	{
-		NazaraError("Stream out of range");
+		NazaraError("Declaration not created");
+		return nullptr;
+	}
+
+	int streamPos = m_sharedImpl->streamPos[stream];
+	if (streamPos == -1)
+	{
+		NazaraError("Declaration has no stream 0x" + NzString::Number(stream, 16));
+		return nullptr;
+	}
+
+	unsigned int upperLimit = GetElementCount(stream);
+	if (i >= upperLimit)
+	{
+		NazaraError("Element index out of range (" + NzString::Number(i) + " >= " + NzString::Number(upperLimit) + ')');
+		return nullptr;
+	}
+	#endif
+
+	return &m_sharedImpl->elements[m_sharedImpl->streamPos[stream]+i];
+}
+
+const NzVertexElement* NzVertexDeclaration::GetElement(nzElementStream stream, nzElementUsage usage, unsigned int usageIndex) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_sharedImpl)
+	{
+		NazaraError("Declaration not created");
+		return nullptr;
+	}
+	#endif
+
+	int elementPos = m_sharedImpl->elementPos[stream][usage];
+	if (elementPos == -1)
+		return nullptr;
+
+	elementPos += usageIndex;
+	if (static_cast<unsigned int>(elementPos) >= m_sharedImpl->elements.size())
+		return nullptr;
+
+	NzVertexElement& element = m_sharedImpl->elements[elementPos];
+	if (element.stream != stream || element.usage != usage || element.usageIndex != usageIndex)
+		return nullptr;
+
+	return &element;
+}
+
+unsigned int NzVertexDeclaration::GetElementCount() const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_sharedImpl)
+	{
+		NazaraError("Declaration not created");
 		return 0;
 	}
 	#endif

-	return m_streams[stream].elements.size();
+	return m_sharedImpl->elements.size();
 }

-unsigned int NzVertexDeclaration::GetStreamCount() const
-{
-	return m_streams.size();
-}
-
-unsigned int NzVertexDeclaration::GetStride(unsigned int stream) const
+unsigned int NzVertexDeclaration::GetElementCount(nzElementStream stream) const
 {
 	#if NAZARA_UTILITY_SAFE
-	if (stream >= m_streams.size())
+	if (!m_sharedImpl)
 	{
-		NazaraError("Stream out of range");
+		NazaraError("Declaration not created");
 		return 0;
 	}
 	#endif

-	return m_streams[stream].stride;
+	int streamPos = m_sharedImpl->streamPos[stream];
+	if (streamPos == -1)
+		return 0;
+
+	unsigned int upperLimit = 0;
+	if (stream == nzElementStream_Max)
+		upperLimit = m_sharedImpl->elements.size();
+	else
+	{
+		for (unsigned int upperStream = stream+1; upperStream <= nzElementStream_Max; ++upperStream)
+		{
+			if (m_sharedImpl->streamPos[upperStream] != -1)
+			{
+				upperLimit = m_sharedImpl->streamPos[upperStream];
+				break;
+			}
+			else if (upperStream == nzElementStream_Max) // Dernier stream, toujours pas de limite
+				upperLimit = m_sharedImpl->elements.size();
+		}
+	}
+
+	return upperLimit-streamPos;
+}
+
+unsigned int NzVertexDeclaration::GetStride(nzElementStream stream) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_sharedImpl)
+	{
+		NazaraError("Declaration not created");
+		return 0;
+	}
+	#endif
+
+	return m_sharedImpl->stride[stream];
+}
+
+bool NzVertexDeclaration::HasStream(nzElementStream stream) const
+{
+	#if NAZARA_UTILITY_SAFE
+	if (!m_sharedImpl)
+	{
+		NazaraError("Declaration not created");
+		return false;
+	}
+	#endif
+
+	return m_sharedImpl->streamPos[stream] != -1;
+}
+
+bool NzVertexDeclaration::IsValid() const
+{
+	return m_sharedImpl != nullptr;
+}
+
+NzVertexDeclaration& NzVertexDeclaration::operator=(const NzVertexDeclaration& declaration)
+{
+	Destroy();
+
+	m_sharedImpl = declaration.m_sharedImpl;
+	if (m_sharedImpl)
+	{
+		NazaraMutexLock(m_sharedImpl->mutex);
+		m_sharedImpl->refCount++;
+		NazaraMutexUnlock(m_sharedImpl->mutex);
+	}
+
+	return *this;
+}
+
+NzVertexDeclaration& NzVertexDeclaration::operator=(NzVertexDeclaration&& declaration)
+{
+	Destroy();
+
+	m_sharedImpl = declaration.m_sharedImpl;
+	declaration.m_sharedImpl = nullptr;
+
+	return *this;
 }