Added a Library to most reference-counted classes

Former-commit-id: 3ed409a71dcd5ce4eec7672ac26f8fff00e3b136

src/Nazara/Audio/Audio.cpp

@@ -6,6 +6,7 @@
 #include <Nazara/Audio/Config.hpp>
 #include <Nazara/Audio/Enums.hpp>
 #include <Nazara/Audio/OpenAL.hpp>
+#include <Nazara/Audio/SoundBuffer.hpp>
 #include <Nazara/Audio/Loaders/sndfile.hpp>
 #include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Core.hpp>
@@ -103,13 +104,19 @@ bool NzAudio::Initialize()
 	// Initialisation du module
 	NzCallOnExit onExit(NzAudio::Uninitialize);
 
-	// Initialisation d'OpenGL
+	// Initialisation d'OpenAL
 	if (!NzOpenAL::Initialize())
 	{
 		NazaraError("Failed to initialize OpenAL");
 		return false;
 	}
 
+	if (!NzSoundBuffer::Initialize())
+	{
+		NazaraError("Failed to initialize sound buffers");
+		return false;
+	}
+
 	// Définition de l'orientation par défaut
 	SetListenerDirection(NzVector3f::Forward());
 
@@ -227,6 +234,7 @@ void NzAudio::Uninitialize()
 	// Loaders
 	NzLoaders_sndfile_Unregister();
 
+	NzSoundBuffer::Uninitialize();
 	NzOpenAL::Uninitialize();
 
 	NazaraNotice("Uninitialized: Audio module");

src/Nazara/Audio/SoundBuffer.cpp

@@ -226,4 +226,21 @@ unsigned int NzSoundBuffer::GetOpenALBuffer() const
 	return m_impl->buffer;
 }
 
+bool NzSoundBuffer::Initialize()
+{
+	if (!NzSoundBufferLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzSoundBuffer::Uninitialize()
+{
+	NzSoundBufferLibrary::Uninitialize();
+}
+
+NzSoundBufferLibrary::LibraryMap NzSoundBuffer::s_library;
 NzSoundBufferLoader::LoaderList NzSoundBuffer::s_loaders;

src/Nazara/Graphics/Graphics.cpp

@@ -11,7 +11,10 @@
 #include <Nazara/Graphics/ForwardRenderTechnique.hpp>
 #include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
 #include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/ParticleController.hpp>
 #include <Nazara/Graphics/ParticleDeclaration.hpp>
+#include <Nazara/Graphics/ParticleGenerator.hpp>
+#include <Nazara/Graphics/ParticleRenderer.hpp>
 #include <Nazara/Graphics/RenderTechniques.hpp>
 #include <Nazara/Graphics/SkinningManager.hpp>
 #include <Nazara/Graphics/Loaders/Mesh.hpp>
@@ -47,12 +50,30 @@ bool NzGraphics::Initialize()
 		return false;
 	}
 
+	if (!NzParticleController::Initialize())
+	{
+		NazaraError("Failed to initialize particle controllers");
+		return false;
+	}
+
 	if (!NzParticleDeclaration::Initialize())
 	{
 		NazaraError("Failed to initialize particle declarations");
 		return false;
 	}
 
+	if (!NzParticleGenerator::Initialize())
+	{
+		NazaraError("Failed to initialize particle generators");
+		return false;
+	}
+
+	if (!NzParticleRenderer::Initialize())
+	{
+		NazaraError("Failed to initialize particle renderers");
+		return false;
+	}
+
 	if (!NzSkinningManager::Initialize())
 	{
 		NazaraError("Failed to initialize skinning manager");
@@ -144,9 +165,12 @@ void NzGraphics::Uninitialize()
 
 	NzDeferredRenderTechnique::Uninitialize();
 	NzForwardRenderTechnique::Uninitialize();
-	NzMaterial::Uninitialize();
-	NzParticleDeclaration::Uninitialize();
 	NzSkinningManager::Uninitialize();
+	NzParticleRenderer::Uninitialize();
+	NzParticleGenerator::Uninitialize();
+	NzParticleDeclaration::Uninitialize();
+	NzParticleController::Uninitialize();
+	NzMaterial::Uninitialize();
 
 	NazaraNotice("Uninitialized: Graphics module");
 

src/Nazara/Graphics/Material.cpp

@@ -705,6 +705,17 @@ void NzMaterial::InvalidateShaders()
 
 bool NzMaterial::Initialize()
 {
+	if (!NzMaterialLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	s_defaultMaterial = NzMaterial::New();
+	s_defaultMaterial->Enable(nzRendererParameter_FaceCulling, false);
+	s_defaultMaterial->SetFaceFilling(nzFaceFilling_Line);
+	NzMaterialLibrary::Register("Default", s_defaultMaterial);
+
 	bool glsl140 = (NzOpenGL::GetGLSLVersion() >= 140);
 
 	// Basic shader
@@ -769,10 +780,6 @@ bool NzMaterial::Initialize()
 		NzUberShaderLibrary::Register("PhongLighting", uberShader);
 	}
 
-	s_defaultMaterial = NzMaterial::New();
-	s_defaultMaterial->Enable(nzRendererParameter_FaceCulling, false);
-	s_defaultMaterial->SetFaceFilling(nzFaceFilling_Line);
-
 	return true;
 }
 
@@ -781,7 +788,9 @@ void NzMaterial::Uninitialize()
 	s_defaultMaterial.Reset();
 	NzUberShaderLibrary::Unregister("PhongLighting");
 	NzUberShaderLibrary::Unregister("Basic");
+	NzMaterialLibrary::Uninitialize();
 }
 
-NzMaterialRef NzMaterial::s_defaultMaterial = nullptr;
+NzMaterialLibrary::LibraryMap NzMaterial::s_library;
 NzMaterialLoader::LoaderList NzMaterial::s_loaders;
+NzMaterialRef NzMaterial::s_defaultMaterial = nullptr;

src/Nazara/Graphics/ParticleController.cpp

@@ -12,3 +12,21 @@ NzRefCounted()
 }
 
 NzParticleController::~NzParticleController() = default;
+
+bool NzParticleController::Initialize()
+{
+	if (!NzParticleControllerLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzParticleController::Uninitialize()
+{
+	NzParticleControllerLibrary::Uninitialize();
+}
+
+NzParticleControllerLibrary::LibraryMap NzParticleController::s_library;

src/Nazara/Graphics/ParticleDeclaration.cpp

@@ -177,6 +177,12 @@ bool NzParticleDeclaration::IsTypeSupported(nzComponentType type)
 
 bool NzParticleDeclaration::Initialize()
 {
+	if (!NzParticleDeclarationLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
 	try
 	{
 		NzErrorFlags flags(nzErrorFlag_Silent | nzErrorFlag_ThrowException);
@@ -225,7 +231,8 @@ bool NzParticleDeclaration::Initialize()
 
 void NzParticleDeclaration::Uninitialize()
 {
-	// Rien à faire
+	NzParticleDeclarationLibrary::Uninitialize();
 }
 
 NzParticleDeclaration NzParticleDeclaration::s_declarations[nzParticleLayout_Max+1];
+NzParticleDeclarationLibrary::LibraryMap NzParticleDeclaration::s_library;

src/Nazara/Graphics/ParticleGenerator.cpp

@@ -12,3 +12,21 @@ NzRefCounted()
 }
 
 NzParticleGenerator::~NzParticleGenerator() = default;
+
+bool NzParticleGenerator::Initialize()
+{
+	if (!NzParticleGeneratorLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzParticleGenerator::Uninitialize()
+{
+	NzParticleGeneratorLibrary::Uninitialize();
+}
+
+NzParticleGeneratorLibrary::LibraryMap NzParticleGenerator::s_library;

src/Nazara/Graphics/ParticleRenderer.cpp

@@ -12,3 +12,21 @@ NzRefCounted()
 }
 
 NzParticleRenderer::~NzParticleRenderer() = default;
+
+bool NzParticleRenderer::Initialize()
+{
+	if (!NzParticleRendererLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzParticleRenderer::Uninitialize()
+{
+	NzParticleRendererLibrary::Uninitialize();
+}
+
+NzParticleRendererLibrary::LibraryMap NzParticleRenderer::s_library;

src/Nazara/Renderer/Context.cpp

@@ -317,6 +317,12 @@ const NzContext* NzContext::GetThreadContext()
 
 bool NzContext::Initialize()
 {
+	if (!NzContextLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
 	NzContextParameters parameters;
 	parameters.shared = false; // Difficile de partager le contexte de référence avec lui-même
 
@@ -343,9 +349,11 @@ bool NzContext::Initialize()
 
 void NzContext::Uninitialize()
 {
+	NzContextLibrary::Uninitialize();
 	s_contexts.clear(); // On supprime tous les contextes créés
 	s_reference.reset();
 }
 
 std::unique_ptr<NzContext> NzContext::s_reference;
 std::vector<std::unique_ptr<NzContext>> NzContext::s_contexts;
+NzContextLibrary::LibraryMap NzContext::s_library;

src/Nazara/Renderer/RenderBuffer.cpp

@@ -114,3 +114,21 @@ bool NzRenderBuffer::IsSupported()
 {
 	return NzOpenGL::IsSupported(nzOpenGLExtension_FrameBufferObject);
 }
+
+bool NzRenderBuffer::Initialize()
+{
+	if (!NzRenderBufferLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzRenderBuffer::Uninitialize()
+{
+	NzRenderBufferLibrary::Uninitialize();
+}
+
+NzRenderBufferLibrary::LibraryMap NzRenderBuffer::s_library;

src/Nazara/Renderer/Renderer.cpp

@@ -14,6 +14,7 @@
 #include <Nazara/Renderer/DebugDrawer.hpp>
 #include <Nazara/Renderer/HardwareBuffer.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
+#include <Nazara/Renderer/RenderBuffer.hpp>
 #include <Nazara/Renderer/RenderTarget.hpp>
 #include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
@@ -736,7 +737,7 @@ bool NzRenderer::Initialize()
 	NzCallOnExit onExit(NzRenderer::Uninitialize);
 
 	// Initialisation d'OpenGL
-	if (!NzOpenGL::Initialize())
+	if (!NzOpenGL::Initialize()) // Initialise également Context
 	{
 		NazaraError("Failed to initialize OpenGL");
 		return false;
@@ -864,15 +865,27 @@ bool NzRenderer::Initialize()
 		}
 	}
 
+	if (!NzRenderBuffer::Initialize())
+	{
+		NazaraError("Failed to initialize render buffers");
+		return false;
+	}
+
 	if (!NzShader::Initialize())
 	{
 		NazaraError("Failed to initialize shaders");
 		return false;
 	}
 
+	if (!NzTexture::Initialize())
+	{
+		NazaraError("Failed to initialize textures");
+		return false;
+	}
+
 	if (!NzTextureSampler::Initialize())
 	{
-		NazaraError("Failed to initialize texture sampler");
+		NazaraError("Failed to initialize texture samplers");
 		return false;
 	}
 
@@ -1545,7 +1558,9 @@ void NzRenderer::Uninitialize()
 
 	NzUberShader::Uninitialize();
 	NzTextureSampler::Uninitialize();
+	NzTexture::Uninitialize();
 	NzShader::Uninitialize();
+	NzRenderBuffer::Uninitialize();
 	NzDebugDrawer::Uninitialize();
 
 	s_textureUnits.clear();

src/Nazara/Renderer/Texture.cpp

@@ -1274,3 +1274,21 @@ bool NzTexture::CreateTexture(bool proxy)
 
 	return true;
 }
+
+bool NzTexture::Initialize()
+{
+	if (!NzTextureLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzTexture::Uninitialize()
+{
+	NzTextureLibrary::Uninitialize();
+}
+
+NzTextureLibrary::LibraryMap NzTexture::s_library;

src/Nazara/Utility/Animation.cpp

@@ -511,4 +511,21 @@ void NzAnimation::RemoveSequence(unsigned int index)
 	m_impl->sequences.erase(it);
 }
 
+bool NzAnimation::Initialize()
+{
+	if (!NzAnimationLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzAnimation::Uninitialize()
+{
+	NzAnimationLibrary::Uninitialize();
+}
+
+NzAnimationLibrary::LibraryMap NzAnimation::s_library;
 NzAnimationLoader::LoaderList NzAnimation::s_loaders;

src/Nazara/Utility/Font.cpp

@@ -363,15 +363,6 @@ unsigned int NzFont::GetDefaultMinimumStepSize()
 	return s_defaultMinimumStepSize;
 }
 
-bool NzFont::Initialize()
-{
-	s_defaultAtlas.reset(new NzGuillotineImageAtlas);
-	s_defaultGlyphBorder = 1;
-	s_defaultMinimumStepSize = 1;
-
-	return true;
-}
-
 void NzFont::SetDefaultAtlas(const std::shared_ptr<NzAbstractAtlas>& atlas)
 {
 	s_defaultAtlas = atlas;
@@ -395,12 +386,6 @@ void NzFont::SetDefaultMinimumStepSize(unsigned int minimumStepSize)
 	s_defaultMinimumStepSize = minimumStepSize;
 }
 
-void NzFont::Uninitialize()
-{
-	s_defaultAtlas.reset();
-	s_defaultFont.Reset();
-}
-
 nzUInt64 NzFont::ComputeKey(unsigned int characterSize, nzUInt32 style) const
 {
 	// On prend le pas en compte
@@ -573,8 +558,31 @@ const NzFont::Glyph& NzFont::PrecacheGlyph(GlyphMap& glyphMap, unsigned int char
 	return glyph;
 }
 
+bool NzFont::Initialize()
+{
+	if (!NzFontLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	s_defaultAtlas.reset(new NzGuillotineImageAtlas);
+	s_defaultGlyphBorder = 1;
+	s_defaultMinimumStepSize = 1;
+
+	return true;
+}
+
+void NzFont::Uninitialize()
+{
+	s_defaultAtlas.reset();
+	s_defaultFont.Reset();
+	NzFontLibrary::Uninitialize();
+}
+
 std::shared_ptr<NzAbstractAtlas> NzFont::s_defaultAtlas;
 NzFontRef NzFont::s_defaultFont;
+NzFontLibrary::LibraryMap NzFont::s_library;
 NzFontLoader::LoaderList NzFont::s_loaders;
 unsigned int NzFont::s_defaultGlyphBorder;
 unsigned int NzFont::s_defaultMinimumStepSize;

src/Nazara/Utility/Image.cpp

@@ -1392,5 +1392,22 @@ void NzImage::ReleaseImage()
 	m_sharedImage = &emptyImage;
 }
 
+bool NzImage::Initialize()
+{
+	if (!NzImageLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzImage::Uninitialize()
+{
+	NzImageLibrary::Uninitialize();
+}
+
 NzImage::SharedImage NzImage::emptyImage(0, nzImageType_2D, nzPixelFormat_Undefined, 1, nullptr, 0, 0, 0);
+NzImageLibrary::LibraryMap NzImage::s_library;
 NzImageLoader::LoaderList NzImage::s_loaders;

src/Nazara/Utility/Mesh.cpp

@@ -1002,4 +1002,21 @@ void NzMesh::Transform(const NzMatrix4f& matrix)
 	m_impl->aabbUpdated = false;
 }
 
+bool NzMesh::Initialize()
+{
+	if (!NzMeshLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzMesh::Uninitialize()
+{
+	NzMeshLibrary::Uninitialize();
+}
+
+NzMeshLibrary::LibraryMap NzMesh::s_library;
 NzMeshLoader::LoaderList NzMesh::s_loaders;

src/Nazara/Utility/Skeleton.cpp

@@ -416,3 +416,21 @@ void NzSkeleton::UpdateJointMap() const
 
 	m_impl->jointMapUpdated = true;
 }
+
+bool NzSkeleton::Initialize()
+{
+	if (!NzSkeletonLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
+	return true;
+}
+
+void NzSkeleton::Uninitialize()
+{
+	NzSkeletonLibrary::Uninitialize();
+}
+
+NzSkeletonLibrary::LibraryMap NzSkeleton::s_library;

src/Nazara/Utility/Utility.cpp

@@ -10,16 +10,20 @@
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Core/TaskScheduler.hpp>
 #include <Nazara/Core/Thread.hpp>
+#include <Nazara/Utility/Animation.hpp>
 #include <Nazara/Utility/Buffer.hpp>
 #include <Nazara/Utility/Config.hpp>
 #include <Nazara/Utility/Font.hpp>
+#include <Nazara/Utility/Image.hpp>
 #include <Nazara/Utility/Loaders/FreeType.hpp>
 #include <Nazara/Utility/Loaders/MD2.hpp>
 #include <Nazara/Utility/Loaders/MD5Anim.hpp>
 #include <Nazara/Utility/Loaders/MD5Mesh.hpp>
 #include <Nazara/Utility/Loaders/PCX.hpp>
 #include <Nazara/Utility/Loaders/STB.hpp>
+#include <Nazara/Utility/Mesh.hpp>
 #include <Nazara/Utility/PixelFormat.hpp>
+#include <Nazara/Utility/Skeleton.hpp>
 #include <Nazara/Utility/VertexDeclaration.hpp>
 #include <Nazara/Utility/Window.hpp>
 #include <Nazara/Utility/Debug.hpp>
@@ -44,6 +48,12 @@ bool NzUtility::Initialize()
 	// Initialisation du module
 	NzCallOnExit onExit(NzUtility::Uninitialize);
 
+	if (!NzAnimation::Initialize())
+	{
+		NazaraError("Failed to initialize animations");
+		return false;
+	}
+
 	if (!NzBuffer::Initialize())
 	{
 		NazaraError("Failed to initialize buffers");
@@ -56,12 +66,30 @@ bool NzUtility::Initialize()
 		return false;
 	}
 
+	if (!NzImage::Initialize())
+	{
+		NazaraError("Failed to initialize images");
+		return false;
+	}
+
+	if (!NzMesh::Initialize())
+	{
+		NazaraError("Failed to initialize meshes");
+		return false;
+	}
+
 	if (!NzPixelFormat::Initialize())
 	{
 		NazaraError("Failed to initialize pixel formats");
 		return false;
 	}
 
+	if (!NzSkeleton::Initialize())
+	{
+		NazaraError("Failed to initialize skeletons");
+		return false;
+	}
+
 	if (!NzVertexDeclaration::Initialize())
 	{
 		NazaraError("Failed to initialize vertex declarations");
@@ -129,9 +157,13 @@ void NzUtility::Uninitialize()
 
 	NzWindow::Uninitialize();
 	NzVertexDeclaration::Uninitialize();
+	NzSkeleton::Uninitialize();
 	NzPixelFormat::Uninitialize();
+	NzMesh::Uninitialize();
+	NzImage::Uninitialize();
 	NzFont::Uninitialize();
 	NzBuffer::Uninitialize();
+	NzAnimation::Uninitialize();
 
 	NazaraNotice("Uninitialized: Utility module");
 

src/Nazara/Utility/VertexDeclaration.cpp

@@ -179,6 +179,12 @@ bool NzVertexDeclaration::IsTypeSupported(nzComponentType type)
 
 bool NzVertexDeclaration::Initialize()
 {
+	if (!NzVertexDeclarationLibrary::Initialize())
+	{
+		NazaraError("Failed to initialise library");
+		return false;
+	}
+
 	try
 	{
 		NzErrorFlags flags(nzErrorFlag_Silent | nzErrorFlag_ThrowException);
@@ -290,7 +296,8 @@ bool NzVertexDeclaration::Initialize()
 
 void NzVertexDeclaration::Uninitialize()
 {
-	// Rien à faire
+	NzVertexDeclarationLibrary::Uninitialize();
 }
 
 NzVertexDeclaration NzVertexDeclaration::s_declarations[nzVertexLayout_Max+1];
+NzVertexDeclarationLibrary::LibraryMap NzVertexDeclaration::s_library;