Merge remote-tracking branch 'origin/NDK' into NDK-ShadowMapping

Conflicts: SDK/include/NDK/Systems/RenderSystem.hpp SDK/src/NDK/Systems/RenderSystem.cpp Former-commit-id: f62e9a27427d96893acd2381bb06ae928a1d3741
2015-06-29 21:05:09 +02:00
parent 7dd4965f9a 9c1441cc82
commit 0cb4726bf5
61 changed files with 434 additions and 2573 deletions
--- a/src/Nazara/Graphics/AbstractBackground.cpp
+++ b/src/Nazara/Graphics/AbstractBackground.cpp
@@ -6,3 +6,5 @@
 #include <Nazara/Graphics/Debug.hpp>

 NzAbstractBackground::~NzAbstractBackground() = default;
+
+NzBackgroundLibrary::LibraryMap NzAbstractBackground::s_library;
--- a/src/Nazara/Graphics/AbstractRenderQueue.cpp
+++ b/src/Nazara/Graphics/AbstractRenderQueue.cpp
@@ -24,6 +24,8 @@ void NzAbstractRenderQueue::AddSpotLight(const SpotLight& light)

 void NzAbstractRenderQueue::Clear(bool fully)
 {
+	NazaraUnused(fully);
+
 	directionalLights.clear();
 	pointLights.clear();
 	spotLights.clear();
--- a/src/Nazara/Graphics/Camera.cpp
+++ b/src/Nazara/Graphics/Camera.cpp
@@ -1,354 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Graphics/Camera.hpp>
-#include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/RenderTarget.hpp>
-#include <Nazara/Graphics/Debug.hpp>
-
-NzCamera::NzCamera() :
-m_targetRegion(0.f, 0.f, 1.f, 1.f),
-m_target(nullptr),
-m_frustumUpdated(false),
-m_projectionMatrixUpdated(false),
-m_viewMatrixUpdated(false),
-m_viewportUpdated(false),
-m_aspectRatio(0.f),
-m_fov(70.f),
-m_zFar(100.f),
-m_zNear(1.f)
-{
-}
-
-void NzCamera::EnsureFrustumUpdate() const
-{
-	if (!m_frustumUpdated)
-		UpdateFrustum();
-}
-
-void NzCamera::EnsureProjectionMatrixUpdate() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-}
-
-void NzCamera::EnsureViewMatrixUpdate() const
-{
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-}
-
-void NzCamera::EnsureViewportUpdate() const
-{
-	if (!m_viewportUpdated)
-		UpdateViewport();
-}
-
-float NzCamera::GetAspectRatio() const
-{
-	return m_aspectRatio;
-}
-
-NzVector3f NzCamera::GetEyePosition() const
-{
-	return GetPosition(nzCoordSys_Global);
-}
-
-NzVector3f NzCamera::GetForward() const
-{
-	return NzNode::GetForward();
-}
-
-float NzCamera::GetFOV() const
-{
-	return m_fov;
-}
-
-const NzFrustumf& NzCamera::GetFrustum() const
-{
-	if (!m_frustumUpdated)
-		UpdateFrustum();
-
-	return m_frustum;
-}
-
-NzVector3f NzCamera::GetGlobalForward() const
-{
-	return NzVector3f::Forward();
-}
-
-NzVector3f NzCamera::GetGlobalRight() const
-{
-	return NzVector3f::Right();
-}
-
-NzVector3f NzCamera::GetGlobalUp() const
-{
-	return NzVector3f::Up();
-}
-
-const NzMatrix4f& NzCamera::GetProjectionMatrix() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	return m_projectionMatrix;
-}
-
-const NzRenderTarget* NzCamera::GetTarget() const
-{
-	return m_target;
-}
-
-const NzRectf& NzCamera::GetTargetRegion() const
-{
-	return m_targetRegion;
-}
-
-const NzMatrix4f& NzCamera::GetViewMatrix() const
-{
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	return m_viewMatrix;
-}
-
-const NzRecti& NzCamera::GetViewport() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return m_viewport;
-	}
-	#endif
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	return m_viewport;
-}
-
-float NzCamera::GetZFar() const
-{
-	return m_zFar;
-}
-
-float NzCamera::GetZNear() const
-{
-	return m_zNear;
-}
-
-void NzCamera::SetFOV(float fov)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (NzNumberEquals(fov, 0.f))
-	{
-		NazaraError("FOV must be different from zero");
-		return;
-	}
-	#endif
-
-	m_fov = fov;
-
-	m_frustumUpdated = false;
-	m_projectionMatrixUpdated = false;
-}
-
-void NzCamera::SetTarget(const NzRenderTarget* renderTarget)
-{
-	m_target = renderTarget;
-
-	if (m_target)
-	{
-		m_targetReleaseSlot.Connect(m_target->OnRenderTargetRelease, this, &NzCamera::OnRenderTargetRelease);
-		m_targetResizeSlot.Connect(m_target->OnRenderTargetSizeChange, this, &NzCamera::OnRenderTargetSizeChange);
-	}
-	else
-	{
-		m_targetReleaseSlot.Disconnect();
-		m_targetResizeSlot.Disconnect();
-	}
-
-	m_frustumUpdated = false;
-	m_projectionMatrixUpdated = false;
-	m_viewportUpdated = false;
-}
-
-void NzCamera::SetTarget(const NzRenderTarget& renderTarget)
-{
-	SetTarget(&renderTarget);
-}
-
-void NzCamera::SetTargetRegion(const NzRectf& region)
-{
-	m_targetRegion = region;
-
-	m_frustumUpdated = false;
-	m_projectionMatrixUpdated = false;
-	m_viewportUpdated = false;
-}
-
-void NzCamera::SetViewport(const NzRecti& viewport)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return;
-	}
-	#endif
-
-	// On calcule la région nécessaire pour produire ce viewport avec la taille actuelle de la cible
-	float invWidth = 1.f/m_target->GetWidth();
-	float invHeight = 1.f/m_target->GetHeight();
-
-	SetTargetRegion(NzRectf(invWidth * viewport.x, invHeight * viewport.y, invWidth * viewport.width, invHeight * viewport.height));
-}
-
-void NzCamera::SetZFar(float zFar)
-{
-	m_zFar = zFar;
-
-	m_frustumUpdated = false;
-	m_projectionMatrixUpdated = false;
-}
-
-void NzCamera::SetZNear(float zNear)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (zNear < 0.f || NzNumberEquals(zNear, 0.f))
-	{
-		NazaraError("ZNear shall be a strictly positive number");
-		return;
-	}
-	#endif
-
-	m_zNear = zNear;
-
-	m_frustumUpdated = false;
-	m_projectionMatrixUpdated = false;
-}
-
-void NzCamera::ApplyView() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return;
-	}
-	#endif
-
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	NzRenderer::SetMatrix(nzMatrixType_Projection, m_projectionMatrix);
-	NzRenderer::SetMatrix(nzMatrixType_View, m_viewMatrix);
-	NzRenderer::SetTarget(m_target);
-	NzRenderer::SetViewport(m_viewport);
-}
-
-void NzCamera::InvalidateNode()
-{
-	NzNode::InvalidateNode();
-
-	// Le frustum et la view matrix dépendent des paramètres du node, invalidons-les
-	m_frustumUpdated = false;
-	m_viewMatrixUpdated = false;
-}
-
-void NzCamera::OnRenderTargetRelease(const NzRenderTarget* renderTarget)
-{
-	if (renderTarget == m_target)
-		m_target = nullptr;
-	else
-		NazaraInternalError("Not listening to " + NzString::Pointer(renderTarget));
-}
-
-void NzCamera::OnRenderTargetSizeChange(const NzRenderTarget* renderTarget)
-{
-	if (renderTarget == m_target)
-	{
-		m_frustumUpdated = false;
-		m_projectionMatrixUpdated = false;
-		m_viewportUpdated = false;
-	}
-	else
-		NazaraInternalError("Not listening to " + NzString::Pointer(renderTarget));
-}
-
-void NzCamera::UpdateFrustum() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	m_frustum.Extract(m_viewMatrix, m_projectionMatrix);
-	m_frustumUpdated = true;
-}
-
-void NzCamera::UpdateProjectionMatrix() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	// Il n'y a pas grand chose à faire d'autre qu'un avertissement à ce stade
-	if (m_zNear >= m_zFar)
-		NazaraWarning("ZNear is greater or equal to ZFar (" + NzString::Number(m_zNear) + " >= " + NzString::Number(m_zFar) + ").");
-	#endif
-
-	if (!m_viewportUpdated)
-		UpdateViewport(); // Peut affecter l'aspect ratio
-
-	m_projectionMatrix.MakePerspective(m_fov, m_aspectRatio, m_zNear, m_zFar);
-	m_projectionMatrixUpdated = true;
-}
-
-void NzCamera::UpdateViewMatrix() const
-{
-	if (!m_derivedUpdated)
-		UpdateDerived();
-
-	m_viewMatrix.MakeViewMatrix(m_derivedPosition, m_derivedRotation);
-	m_viewMatrixUpdated = true;
-}
-
-void NzCamera::UpdateViewport() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return;
-	}
-	#endif
-
-	unsigned int width = m_target->GetWidth();
-	unsigned int height = std::max(m_target->GetHeight(), 1U);
-
-	float vWidth = width * m_targetRegion.width;
-	float vHeight = height * m_targetRegion.height;
-	float aspectRatio = vWidth/vHeight;
-
-	if (!NzNumberEquals(m_aspectRatio, aspectRatio, 0.001f))
-	{
-		m_aspectRatio = aspectRatio;
-		m_frustumUpdated = false;
-		m_projectionMatrixUpdated = false;
-	}
-
-	m_viewport.x = static_cast<int>(width * m_targetRegion.x);
-	m_viewport.y = static_cast<int>(height * m_targetRegion.y);
-	m_viewport.width = static_cast<int>(vWidth);
-	m_viewport.height = static_cast<int>(vHeight);
-	m_viewportUpdated = true;
-}
--- a/src/Nazara/Graphics/DeferredDOFPass.cpp
+++ b/src/Nazara/Graphics/DeferredDOFPass.cpp
@@ -4,7 +4,6 @@

 #include <Nazara/Graphics/DeferredDOFPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <memory>
--- a/src/Nazara/Graphics/DeferredFinalPass.cpp
+++ b/src/Nazara/Graphics/DeferredFinalPass.cpp
@@ -4,7 +4,6 @@

 #include <Nazara/Graphics/DeferredFinalPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
--- a/src/Nazara/Graphics/DeferredFogPass.cpp
+++ b/src/Nazara/Graphics/DeferredFogPass.cpp
@@ -4,7 +4,6 @@

 #include <Nazara/Graphics/DeferredFogPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <memory>
--- a/src/Nazara/Graphics/DeferredForwardPass.cpp
+++ b/src/Nazara/Graphics/DeferredForwardPass.cpp
@@ -8,7 +8,6 @@
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderTechnique.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Graphics/Debug.hpp>

--- a/src/Nazara/Graphics/DeferredGeometryPass.cpp
+++ b/src/Nazara/Graphics/DeferredGeometryPass.cpp
@@ -8,7 +8,6 @@
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
--- a/src/Nazara/Graphics/DeferredPhongLightingPass.cpp
+++ b/src/Nazara/Graphics/DeferredPhongLightingPass.cpp
@@ -5,7 +5,6 @@
 #include <Nazara/Graphics/DeferredPhongLightingPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderQueue.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
--- a/src/Nazara/Graphics/DeferredRenderTechnique.cpp
+++ b/src/Nazara/Graphics/DeferredRenderTechnique.cpp
@@ -9,7 +9,7 @@
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Graphics/Camera.hpp>
+#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredBloomPass.hpp>
 #include <Nazara/Graphics/DeferredDOFPass.hpp>
 #include <Nazara/Graphics/DeferredFinalPass.hpp>
@@ -21,7 +21,6 @@
 #include <Nazara/Graphics/Drawable.hpp>
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Renderer/Config.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
--- a/src/Nazara/Graphics/ForwardRenderTechnique.cpp
+++ b/src/Nazara/Graphics/ForwardRenderTechnique.cpp
@@ -6,7 +6,7 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/OffsetOf.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Graphics/Camera.hpp>
+#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/Drawable.hpp>
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Material.hpp>
--- a/src/Nazara/Graphics/Graphics.cpp
+++ b/src/Nazara/Graphics/Graphics.cpp
@@ -18,6 +18,7 @@
 #include <Nazara/Graphics/ParticleRenderer.hpp>
 #include <Nazara/Graphics/RenderTechniques.hpp>
 #include <Nazara/Graphics/SkinningManager.hpp>
+#include <Nazara/Graphics/SkyboxBackground.hpp>
 #include <Nazara/Graphics/Formats/MeshLoader.hpp>
 #include <Nazara/Graphics/Formats/OBJLoader.hpp>
 #include <Nazara/Graphics/Formats/TextureLoader.hpp>
@@ -81,6 +82,12 @@ bool NzGraphics::Initialize()
 		return false;
 	}

+	if (!NzSkyboxBackground::Initialize())
+	{
+		NazaraError("Failed to initialize skybox backgrounds");
+		return false;
+	}
+
 	// Loaders
 	NzLoaders_OBJ_Register();

@@ -179,6 +186,7 @@ void NzGraphics::Uninitialize()
 	NzParticleDeclaration::Uninitialize();
 	NzParticleController::Uninitialize();
 	NzMaterial::Uninitialize();
+	NzSkyboxBackground::Uninitialize();

 	NazaraNotice("Uninitialized: Graphics module");

--- a/src/Nazara/Graphics/Light.cpp
+++ b/src/Nazara/Graphics/Light.cpp
@@ -5,7 +5,6 @@
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Math/Sphere.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
--- a/src/Nazara/Graphics/Model.cpp
+++ b/src/Nazara/Graphics/Model.cpp
@@ -4,7 +4,6 @@

 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Utility/MeshData.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
--- a/src/Nazara/Graphics/ParticleEmitter.cpp
+++ b/src/Nazara/Graphics/ParticleEmitter.cpp
@@ -52,10 +52,9 @@ void NzParticleEmitter::Emit(NzParticleSystem& system, float elapsedTime) const
 			if (m_lagCompensationEnabled)
 			{
 				// On va maintenant appliquer les contrôleurs
-				float accumulator = 0.f;
 				float invEmissionRate = 1.f/m_emissionRate;
 				for (unsigned int i = 1; i <= emissionCountInt; ++i)
-					system.ApplyControllers(mapper, std::min(m_emissionCount*i, particleCount), 20*invEmissionRate, accumulator);
+					system.ApplyControllers(mapper, std::min(m_emissionCount*i, particleCount), invEmissionRate);
 			}
 		}
 	}
--- a/src/Nazara/Graphics/ParticleSystem.cpp
+++ b/src/Nazara/Graphics/ParticleSystem.cpp
@@ -7,7 +7,6 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Core/StringStream.hpp>
 #include <Nazara/Graphics/ParticleMapper.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <cstdlib>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
@@ -17,12 +16,9 @@ NzParticleSystem(maxParticleCount, NzParticleDeclaration::Get(layout))
 {
 }

-NzParticleSystem::NzParticleSystem(unsigned int maxParticleCount, const NzParticleDeclaration* declaration) :
-m_declaration(declaration),
-m_fixedStepEnabled(false),
+NzParticleSystem::NzParticleSystem(unsigned int maxParticleCount, NzParticleDeclarationConstRef declaration) :
+m_declaration(std::move(declaration)),
 m_processing(false),
-m_stepAccumulator(0.f),
-m_stepSize(1.f/60.f),
 m_maxParticleCount(maxParticleCount),
 m_particleCount(0)
 {
@@ -35,15 +31,12 @@ m_particleCount(0)
 }

 NzParticleSystem::NzParticleSystem(const NzParticleSystem& system) :
-NzSceneNode(system),
+NzRenderable(system),
 m_controllers(system.m_controllers),
 m_generators(system.m_generators),
 m_declaration(system.m_declaration),
 m_renderer(system.m_renderer),
-m_fixedStepEnabled(system.m_fixedStepEnabled),
 m_processing(false),
-m_stepAccumulator(0.f),
-m_stepSize(system.m_stepSize),
 m_maxParticleCount(system.m_maxParticleCount),
 m_particleCount(system.m_particleCount),
 m_particleSize(system.m_particleSize)
@@ -58,24 +51,33 @@ m_particleSize(system.m_particleSize)

 NzParticleSystem::~NzParticleSystem() = default;

-void NzParticleSystem::AddController(NzParticleController* controller)
+void NzParticleSystem::AddController(NzParticleControllerRef controller)
 {
-	m_controllers.emplace_back(controller);
+	NazaraAssert(controller, "Invalid particle controller");
+
+	m_controllers.emplace_back(std::move(controller));
 }

 void NzParticleSystem::AddEmitter(NzParticleEmitter* emitter)
 {
+	NazaraAssert(emitter, "Invalid particle emitter");
+
 	m_emitters.emplace_back(emitter);
 }

-void NzParticleSystem::AddGenerator(NzParticleGenerator* generator)
+void NzParticleSystem::AddGenerator(NzParticleGeneratorRef generator)
 {
-	m_generators.emplace_back(generator);
+	NazaraAssert(generator, "Invalid particle generator");
+
+	m_generators.emplace_back(std::move(generator));
 }

-void NzParticleSystem::AddToRenderQueue(NzAbstractRenderQueue* renderQueue) const
+void NzParticleSystem::AddToRenderQueue(NzAbstractRenderQueue* renderQueue, const NzMatrix4f& transformMatrix) const
 {
-	///FIXME: Vérifier le renderer
+	NazaraAssert(m_renderer, "Invalid particle renderer");
+	NazaraAssert(renderQueue, "Invalid renderqueue");
+	NazaraUnused(transformMatrix);
+
 	if (m_particleCount > 0)
 	{
 		NzParticleMapper mapper(m_buffer.data(), m_declaration);
@@ -83,6 +85,36 @@ void NzParticleSystem::AddToRenderQueue(NzAbstractRenderQueue* renderQueue) cons
 	}
 }

+void NzParticleSystem::ApplyControllers(NzParticleMapper& mapper, unsigned int particleCount, float elapsedTime)
+{
+	m_processing = true;
+
+	// Pour éviter un verrouillage en cas d'exception
+	NzCallOnExit onExit([this]()
+	{
+		m_processing = false;
+	});
+
+	for (NzParticleController* controller : m_controllers)
+		controller->Apply(*this, mapper, 0, particleCount-1, elapsedTime);
+
+	onExit.CallAndReset();
+
+	// On tue maintenant les particules mortes durant la mise à jour
+	if (m_dyingParticles.size() < m_particleCount)
+	{
+		// On tue les particules depuis la dernière vers la première (en terme de place), le std::set étant trié via std::greater
+		// La raison est simple, étant donné que la mort d'une particule signifie le déplacement de la dernière particule du buffer,
+		// sans cette solution certaines particules pourraient échapper à la mort
+		for (unsigned int index : m_dyingParticles)
+			KillParticle(index);
+	}
+	else
+		KillParticles(); // Toutes les particules sont mortes, ceci est beaucoup plus rapide
+
+	m_dyingParticles.clear();
+}
+
 void* NzParticleSystem::CreateParticle()
 {
 	return CreateParticles(1);
@@ -93,7 +125,7 @@ void* NzParticleSystem::CreateParticles(unsigned int count)
 	if (count == 0)
 		return nullptr;

-	if (m_particleCount+count > m_maxParticleCount)
+	if (m_particleCount + count > m_maxParticleCount)
 		return nullptr;

 	unsigned int particlesIndex = m_particleCount;
@@ -102,16 +134,6 @@ void* NzParticleSystem::CreateParticles(unsigned int count)
 	return &m_buffer[particlesIndex*m_particleSize];
 }

-void NzParticleSystem::EnableFixedStep(bool fixedStep)
-{
-	// On teste pour empêcher que cette méthode ne remette systématiquement le step accumulator à zéro
-	if (m_fixedStepEnabled != fixedStep)
-	{
-		m_fixedStepEnabled = fixedStep;
-		m_stepAccumulator = 0.f;
-	}
-}
-
 void* NzParticleSystem::GenerateParticle()
 {
 	return GenerateParticles(1);
@@ -130,7 +152,7 @@ void* NzParticleSystem::GenerateParticles(unsigned int count)
 	return ptr;
 }

-const NzParticleDeclaration* NzParticleSystem::GetDeclaration() const
+const NzParticleDeclarationConstRef& NzParticleSystem::GetDeclaration() const
 {
 	return m_declaration;
 }
@@ -155,21 +177,6 @@ unsigned int NzParticleSystem::GetParticleSize() const
 	return m_particleSize;
 }

-nzSceneNodeType NzParticleSystem::GetSceneNodeType() const
-{
-	return nzSceneNodeType_ParticleEmitter;
-}
-
-bool NzParticleSystem::IsDrawable() const
-{
-	return true;
-}
-
-bool NzParticleSystem::IsFixedStepEnabled() const
-{
-	return m_fixedStepEnabled;
-}
-
 void NzParticleSystem::KillParticle(unsigned int index)
 {
 	///FIXME: Vérifier index
@@ -222,15 +229,36 @@ void NzParticleSystem::SetRenderer(NzParticleRenderer* renderer)
 	m_renderer = renderer;
 }

+void NzParticleSystem::Update(float elapsedTime)
+{
+	// Émission
+	for (NzParticleEmitter* emitter : m_emitters)
+		emitter->Emit(*this, elapsedTime);
+
+	// Mise à jour
+	if (m_particleCount > 0)
+	{
+		///TODO: Mettre à jour en utilisant des threads
+		NzParticleMapper mapper(m_buffer.data(), m_declaration);
+		ApplyControllers(mapper, m_particleCount, elapsedTime);
+	}
+}
+
+void NzParticleSystem::UpdateBoundingVolume(const NzMatrix4f& transformMatrix)
+{
+	NazaraUnused(transformMatrix);
+
+	// Nothing to do here (our bounding volume is global)
+}
+
 NzParticleSystem& NzParticleSystem::operator=(const NzParticleSystem& system)
 {
 	NzErrorFlags flags(nzErrorFlag_ThrowException, true);

-	NzSceneNode::operator=(system);
+	NzRenderable::operator=(system);

 	m_controllers = system.m_controllers;
 	m_declaration = system.m_declaration;
-	m_fixedStepEnabled = system.m_fixedStepEnabled;
 	m_generators = system.m_generators;
 	m_maxParticleCount = system.m_maxParticleCount;
 	m_particleCount = system.m_particleCount;
@@ -252,61 +280,12 @@ NzParticleSystem& NzParticleSystem::operator=(const NzParticleSystem& system)
 	return *this;
 }

-void NzParticleSystem::ApplyControllers(NzParticleMapper& mapper, unsigned int particleCount, float elapsedTime, float& stepAccumulator)
-{
-	m_processing = true;
-
-	// Pour éviter un verrouillage en cas d'exception
-	NzCallOnExit onExit([this]()
-	{
-		m_processing = false;
-	});
-
-	if (m_fixedStepEnabled)
-	{
-		stepAccumulator += elapsedTime;
-		while (stepAccumulator >= m_stepSize)
-		{
-			for (NzParticleController* controller : m_controllers)
-				controller->Apply(*this, mapper, 0, particleCount-1, m_stepSize);
-
-			stepAccumulator -= m_stepSize;
-		}
-	}
-	else
-	{
-		for (NzParticleController* controller : m_controllers)
-			controller->Apply(*this, mapper, 0, particleCount-1, elapsedTime);
-	}
-
-	onExit.CallAndReset();
-
-	// On tue maintenant les particules mortes durant la mise à jour
-	if (m_dyingParticles.size() < m_particleCount)
-	{
-		// On tue les particules depuis la dernière vers la première (en terme de place), le std::set étant trié via std::greater
-		// La raison est simple, étant donné que la mort d'une particule signifie le déplacement de la dernière particule du buffer,
-		// sans cette solution certaines particules pourraient échapper à la mort
-		for (unsigned int index : m_dyingParticles)
-			KillParticle(index);
-	}
-	else
-		KillParticles(); // Toutes les particules sont mortes, ceci est beaucoup plus rapide
-
-	m_dyingParticles.clear();
-}
-
 void NzParticleSystem::MakeBoundingVolume() const
 {
 	///TODO: Calculer l'AABB (prendre la taille des particules en compte s'il y a)
 	m_boundingVolume.MakeInfinite();
 }

-void NzParticleSystem::Register()
-{
-	m_scene->RegisterForUpdate(this);
-}
-
 void NzParticleSystem::ResizeBuffer()
 {
 	// Histoire de décrire un peu mieux l'erreur en cas d'échec
@@ -323,24 +302,3 @@ void NzParticleSystem::ResizeBuffer()
 	}
 }

-void NzParticleSystem::Unregister()
-{
-	m_scene->UnregisterForUpdate(this);
-}
-
-void NzParticleSystem::Update()
-{
-	float elapsedTime = m_scene->GetUpdateTime();
-
-	// Émission
-	for (NzParticleEmitter* emitter : m_emitters)
-		emitter->Emit(*this, elapsedTime);
-
-	// Mise à jour
-	if (m_particleCount > 0)
-	{
-		///TODO: Mettre à jour en utilisant des threads
-		NzParticleMapper mapper(m_buffer.data(), m_declaration);
-		ApplyControllers(mapper, m_particleCount, elapsedTime, m_stepAccumulator);
-	}
-}
--- a/src/Nazara/Graphics/Scene.cpp
+++ b/src/Nazara/Graphics/Scene.cpp
@@ -1,465 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Core/Clock.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Core/ErrorFlags.hpp>
-#include <Nazara/Graphics/Camera.hpp>
-#include <Nazara/Graphics/ColorBackground.hpp>
-#include <Nazara/Graphics/RenderTechniques.hpp>
-#include <Nazara/Graphics/SkinningManager.hpp>
-#include <Nazara/Renderer/Config.hpp>
-#include <functional>
-#include <Nazara/Graphics/Debug.hpp>
-
-NzScene::NzScene() :
-m_ambientColor(25, 25, 25),
-m_root(this),
-m_viewer(nullptr),
-m_backgroundEnabled(true),
-m_update(false),
-m_updatePerSecond(60)
-{
-}
-
-void NzScene::AddToVisibilityList(NzUpdatable* object)
-{
-	m_visibleUpdateList.push_back(object);
-}
-
-void NzScene::Clear()
-{
-	m_nodeMap.clear();
-	m_nodes.clear();
-}
-
-void NzScene::Cull()
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return;
-	}
-	#endif
-
-	NzAbstractRenderQueue* renderQueue = GetRenderTechnique()->GetRenderQueue();
-	renderQueue->Clear(false);
-
-	m_visibleUpdateList.clear();
-
-	// Frustum culling
-	RecursiveFrustumCull(renderQueue, m_viewer->GetFrustum(), &m_root);
-
-	///TODO: Occlusion culling
-}
-
-void NzScene::Draw()
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return;
-	}
-	#endif
-
-	m_viewer->ApplyView();
-
-	try
-	{
-		NzSceneData sceneData;
-		sceneData.ambientColor = m_ambientColor;
-		sceneData.background = (m_backgroundEnabled) ? m_background.get() : nullptr;
-		sceneData.viewer = m_viewer;
-
-		NzErrorFlags errFlags(nzErrorFlag_ThrowException, true);
-		m_renderTechnique->Draw(sceneData);
-	}
-	catch (const std::exception& e)
-	{
-		NzString oldName = m_renderTechnique->GetName();
-
-		if (m_renderTechniqueRanking > 0)
-		{
-			m_renderTechnique.reset(NzRenderTechniques::GetByRanking(m_renderTechniqueRanking-1, &m_renderTechniqueRanking));
-			NazaraError("Render technique \"" + oldName + "\" failed (" + NzString(e.what()) + "), falling back to \"" + m_renderTechnique->GetName() + '"');
-		}
-		else
-		{
-			NzErrorFlags errFlags(nzErrorFlag_ThrowException);
-			NazaraError("Render technique \"" + oldName + "\" failed (" + NzString(e.what()) + ") and no fallback is available");
-		}
-
-		return;
-	}
-}
-
-void NzScene::EnableBackground(bool enable)
-{
-	m_backgroundEnabled = enable;
-}
-
-NzSceneNode* NzScene::FindNode(const NzString& name)
-{
-	auto it = m_nodeMap.find(name);
-	if (it == m_nodeMap.end())
-		return nullptr;
-
-	return it->second;
-}
-
-const NzSceneNode* NzScene::FindNode(const NzString& name) const
-{
-	auto it = m_nodeMap.find(name);
-	if (it == m_nodeMap.end())
-		return nullptr;
-
-	return it->second;
-}
-
-NzColor NzScene::GetAmbientColor() const
-{
-	return m_ambientColor;
-}
-
-NzAbstractBackground* NzScene::GetBackground() const
-{
-	if (!m_background)
-		m_background.reset(new NzColorBackground);
-
-	return m_background.get();
-}
-
-NzVector3f NzScene::GetBackward() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Backward();
-	}
-	#endif
-
-	//return -m_viewer->GetGlobalForward();
-	return NzVector3f::Backward();
-}
-
-NzVector3f NzScene::GetDown() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Down();
-	}
-	#endif
-
-	//return -m_viewer->GetGlobalUp();
-	return NzVector3f::Down();
-}
-
-NzVector3f NzScene::GetForward() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Forward();
-	}
-	#endif
-
-	//return m_viewer->GetGlobalForward();
-	return NzVector3f::Forward();
-}
-
-NzVector3f NzScene::GetLeft() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Left();
-	}
-	#endif
-
-	//return -m_viewer->GetGlobalRight();
-	return NzVector3f::Left();
-}
-
-NzAbstractRenderTechnique* NzScene::GetRenderTechnique() const
-{
-	if (!m_renderTechnique)
-		m_renderTechnique.reset(NzRenderTechniques::GetByRanking(-1, &m_renderTechniqueRanking));
-
-	return m_renderTechnique.get();
-}
-
-NzVector3f NzScene::GetRight() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Right();
-	}
-	#endif
-
-	//return m_viewer->GetGlobalRight();
-	return NzVector3f::Right();
-}
-
-NzSceneNode& NzScene::GetRoot()
-{
-	return m_root;
-}
-
-const NzSceneNode& NzScene::GetRoot() const
-{
-	return m_root;
-}
-
-NzAbstractViewer* NzScene::GetViewer() const
-{
-	return m_viewer;
-}
-
-NzVector3f NzScene::GetUp() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_viewer)
-	{
-		NazaraError("No viewer");
-		return NzVector3f::Up();
-	}
-	#endif
-
-	//return m_viewer->GetGlobalUp();
-	return NzVector3f::Up();
-}
-
-float NzScene::GetUpdateTime() const
-{
-	return m_updateTime;
-}
-
-unsigned int NzScene::GetUpdatePerSecond() const
-{
-	return m_updatePerSecond;
-}
-
-bool NzScene::IsBackgroundEnabled() const
-{
-	return m_backgroundEnabled;
-}
-
-void NzScene::RegisterForUpdate(NzUpdatable* object)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!object)
-	{
-		NazaraError("Invalid object");
-		return;
-	}
-	#endif
-
-	m_updateList.push_back(object);
-}
-
-void NzScene::RemoveNode(NzSceneNode* node)
-{
-	if (!node)
-		return;
-
-	// C'est moche mais je n'ai pas d'autre choix que d'utiliser un std::unique_ptr pour utiliser std::find
-	std::unique_ptr<NzSceneNode> ptr(node);
-	auto it = std::find(m_nodes.begin(), m_nodes.end(), ptr);
-	ptr.release();
-
-	if (it == m_nodes.end())
-	{
-		NazaraError("This scene node doesn't belong to this scene");
-		return;
-	}
-
-	NzString nodeName = node->GetName();
-	if (!nodeName.IsEmpty())
-		m_nodeMap.erase(nodeName);
-
-	m_nodes.erase(it);
-}
-
-void NzScene::RemoveNode(const NzString& name)
-{
-	RemoveNode(FindNode(name));
-}
-
-void NzScene::RenderFrame()
-{
-	try
-	{
-		NzErrorFlags errFlags(nzErrorFlag_ThrowException, true);
-		Update();
-		Cull();
-		UpdateVisible();
-		Draw();
-	}
-	catch (const std::exception& e)
-	{
-		NazaraError("Failed to render frame: " + NzString(e.what()));
-	}
-}
-
-void NzScene::SetAmbientColor(const NzColor& color)
-{
-	m_ambientColor = color;
-}
-
-void NzScene::SetBackground(NzAbstractBackground* background)
-{
-	m_background.reset(background);
-}
-
-void NzScene::SetRenderTechnique(NzAbstractRenderTechnique* renderTechnique)
-{
-	m_renderTechnique.reset(renderTechnique);
-}
-
-void NzScene::SetViewer(NzAbstractViewer* viewer)
-{
-	if (m_viewer != viewer)
-	{
-		m_viewer = viewer;
-
-		// Invalidation de tous les nodes de la scène (utile pour la régénération des sommets dépendant du viewer)
-		m_root.InvalidateNode();
-	}
-}
-
-void NzScene::SetViewer(NzAbstractViewer& viewer)
-{
-	SetViewer(&viewer);
-}
-
-void NzScene::SetUpdatePerSecond(unsigned int updatePerSecond)
-{
-	m_updatePerSecond = updatePerSecond;
-}
-
-void NzScene::UnregisterForUpdate(NzUpdatable* object)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!object)
-	{
-		NazaraError("Invalid object");
-		return;
-	}
-	#endif
-
-	auto it = std::find(m_updateList.begin(), m_updateList.end(), object);
-	if (it != m_updateList.end())
-		m_updateList.erase(it);
-}
-
-void NzScene::Update()
-{
-	m_update = (m_updatePerSecond == 0 || m_updateClock.GetMilliseconds() > 1000/m_updatePerSecond);
-	if (m_update)
-	{
-		m_updateTime = m_updateClock.GetSeconds();
-		m_updateClock.Restart();
-
-		for (NzUpdatable* updatable : m_updateList)
-			///TODO: Multihreading
-			updatable->Update();
-	}
-}
-
-void NzScene::UpdateVisible()
-{
-	NzSkinningManager::Skin();
-
-	if (m_update)
-	{
-		for (NzUpdatable* node : m_visibleUpdateList)
-			node->Update();
-	}
-}
-
-NzScene::operator const NzSceneNode&() const
-{
-	return m_root;
-}
-
-bool NzScene::ChangeNodeName(NzSceneNode* node, const NzString& newName)
-{
-	#ifdef NAZARA_DEBUG
-	std::unique_ptr<NzSceneNode> ptr(node);
-	auto it = std::find(m_nodes.begin(), m_nodes.end(), ptr);
-	ptr.release();
-
-	if (it == m_nodes.end())
-	{
-		NazaraInternalError("Node isn't part of the scene");
-		return false;
-	}
-	#endif
-
-	if (!newName.IsEmpty())
-	{
-		auto pair = m_nodeMap.insert(std::make_pair(newName, node));
-		if (!pair.second)
-		{
-			NazaraError("Name \"" + newName + "\" is already in use");
-			return false;
-		}
-	}
-
-	NzString oldName = node->GetName();
-	if (!oldName.IsEmpty())
-		m_nodeMap.erase(oldName);
-
-	node->SetNameInternal(newName);
-	return true;
-}
-
-bool NzScene::RegisterSceneNode(const NzString& name, NzSceneNode* node)
-{
-	if (!name.IsEmpty())
-	{
-		if (m_nodeMap.find(name) != m_nodeMap.end())
-		{
-			NazaraError("Node " + name + " is already registred");
-			return false;
-		}
-
-		m_nodeMap[name] = node;
-	}
-
-	node->SetNameInternal(name);
-	node->SetParent(m_root, true);
-
-	m_nodes.emplace_back(node);
-	return true;
-}
-
-void NzScene::RecursiveFrustumCull(NzAbstractRenderQueue* renderQueue, const NzFrustumf& frustum, NzNode* node)
-{
-	for (NzNode* child : node->GetChilds())
-	{
-		if (child->GetNodeType() == nzNodeType_Scene)
-		{
-			NzSceneNode* sceneNode = static_cast<NzSceneNode*>(child);
-
-			///TODO: Empêcher le rendu des enfants si le parent est cullé selon un flag
-			sceneNode->UpdateVisibility(frustum);
-			if (sceneNode->IsVisible())
-				sceneNode->AddToRenderQueue(renderQueue);
-		}
-
-		if (child->HasChilds())
-			RecursiveFrustumCull(renderQueue, frustum, child);
-	}
-}
--- a/src/Nazara/Graphics/SceneNode.cpp
+++ b/src/Nazara/Graphics/SceneNode.cpp
@@ -1,293 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Graphics/SceneNode.hpp>
-#include <Nazara/Graphics/Config.hpp>
-#include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Graphics/Debug.hpp>
-
-///FIXME: Constructeur de copie
-
-NzSceneNode::NzSceneNode() :
-m_scene(nullptr),
-m_boundingVolumeUpdated(false),
-m_drawingEnabled(true),
-m_visible(false)
-{
-}
-
-NzSceneNode::NzSceneNode(const NzSceneNode& sceneNode) :
-NzNode(sceneNode),
-m_scene(nullptr),
-m_boundingVolumeUpdated(false),
-m_drawingEnabled(sceneNode.m_drawingEnabled),
-m_visible(false)
-{
-}
-
-NzSceneNode::~NzSceneNode() = default;
-
-void NzSceneNode::EnableDrawing(bool drawingEnabled)
-{
-	m_drawingEnabled = drawingEnabled;
-}
-
-NzVector3f NzSceneNode::GetBackward() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetBackward();
-	}
-	else
-		return NzNode::GetBackward();
-}
-
-const NzBoundingVolumef& NzSceneNode::GetBoundingVolume() const
-{
-	if (!m_boundingVolumeUpdated)
-		UpdateBoundingVolume();
-
-	return m_boundingVolume;
-}
-
-NzVector3f NzSceneNode::GetDown() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetDown();
-	}
-	else
-		return NzNode::GetDown();
-}
-
-NzVector3f NzSceneNode::GetForward() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetForward();
-	}
-	else
-		return NzNode::GetForward();
-}
-
-NzVector3f NzSceneNode::GetLeft() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetLeft();
-	}
-	else
-		return NzNode::GetLeft();
-}
-
-const NzString& NzSceneNode::GetName() const
-{
-	return m_name;
-}
-
-nzNodeType NzSceneNode::GetNodeType() const
-{
-	return nzNodeType_Scene;
-}
-
-NzVector3f NzSceneNode::GetRight() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetRight();
-	}
-	else
-		return NzNode::GetRight();
-}
-
-NzScene* NzSceneNode::GetScene() const
-{
-	return m_scene;
-}
-
-NzVector3f NzSceneNode::GetUp() const
-{
-	if (m_scene)
-	{
-		if (!m_derivedUpdated)
-			UpdateDerived();
-
-		return m_derivedRotation * m_scene->GetUp();
-	}
-	else
-		return NzNode::GetUp();
-}
-
-bool NzSceneNode::IsDrawingEnabled() const
-{
-	return m_drawingEnabled;
-}
-
-bool NzSceneNode::IsVisible() const
-{
-	return m_visible;
-}
-
-void NzSceneNode::Remove()
-{
-	if (m_scene)
-		m_scene->RemoveNode(this);
-	else
-		NazaraError("SceneNode::Remove() called on a template node");
-}
-
-bool NzSceneNode::SetName(const NzString& name)
-{
-	if (m_scene)
-		// On demande à la scène de changer notre nom
-		return m_scene->ChangeNodeName(this, name);
-	else
-	{
-		// Pas de scène ? Changeons notre nom nous-même
-		SetNameInternal(name);
-		return true;
-	}
-}
-
-NzSceneNode& NzSceneNode::operator=(const NzSceneNode& sceneNode)
-{
-	NzNode::operator=(sceneNode);
-
-	// La scène est affectée via le parenting du node
-	m_drawingEnabled = sceneNode.m_drawingEnabled;
-	m_visible = false;
-
-	return *this;
-}
-
-bool NzSceneNode::FrustumCull(const NzFrustumf& frustum) const
-{
-	return frustum.Contains(GetBoundingVolume());
-}
-
-void NzSceneNode::InvalidateNode()
-{
-	NzNode::InvalidateNode();
-
-	m_boundingVolumeUpdated = false;
-}
-
-void NzSceneNode::OnParenting(const NzNode* parent)
-{
-	NzNode::OnParenting(parent);
-
-	if (parent)
-	{
-		///FIXME: Remonter jusqu'au premier parent de type SceneNode plutôt que de s'arrêter au premier venu
-		if (parent->GetNodeType() == nzNodeType_Scene)
-			SetScene(static_cast<const NzSceneNode*>(parent)->m_scene);
-	}
-	else
-		SetScene(nullptr);
-}
-
-void NzSceneNode::OnVisibilityChange(bool visibility)
-{
-	NazaraUnused(visibility);
-
-	///TODO: Envoyer l'évènements aux listeners
-}
-
-void NzSceneNode::RecursiveSetScene(NzScene* scene, NzNode* node)
-{
-	const std::vector<NzNode*>& childs = node->GetChilds();
-	for (NzNode* child : childs)
-	{
-		if (child->GetNodeType() == nzNodeType_Scene)
-		{
-			NzSceneNode* sceneNode = static_cast<NzSceneNode*>(child);
-			sceneNode->SetScene(scene);
-		}
-
-		if (node->HasChilds())
-			RecursiveSetScene(scene, node);
-	}
-}
-
-void NzSceneNode::Register()
-{
-}
-
-void NzSceneNode::SetNameInternal(const NzString& name)
-{
-	m_name = name;
-}
-
-void NzSceneNode::SetScene(NzScene* scene)
-{
-	if (m_scene != scene)
-	{
-		if (m_scene)
-			Unregister();
-
-		m_scene = scene;
-		if (m_scene)
-			Register();
-
-		RecursiveSetScene(scene, this);
-	}
-}
-
-void NzSceneNode::Unregister()
-{
-}
-
-void NzSceneNode::Update()
-{
-}
-
-void NzSceneNode::UpdateBoundingVolume() const
-{
-	if (m_boundingVolume.IsNull())
-		MakeBoundingVolume();
-
-	if (!m_transformMatrixUpdated)
-		UpdateTransformMatrix();
-
-	m_boundingVolume.Update(m_transformMatrix);
-	m_boundingVolumeUpdated = true;
-}
-
-void NzSceneNode::UpdateVisibility(const NzFrustumf& frustum)
-{
-	bool wasVisible = m_visible;
-
-	if (m_drawingEnabled)
-	{
-		#if NAZARA_GRAPHICS_SAFE
-		if (!IsDrawable())
-		{
-			NazaraError("SceneNode is not drawable");
-			return;
-		}
-		#endif
-
-		m_visible = FrustumCull(frustum);
-	}
-	else
-		m_visible = false;
-
-	if (m_visible != wasVisible)
-		OnVisibilityChange(m_visible);
-}
--- a/src/Nazara/Graphics/SceneRoot.cpp
+++ b/src/Nazara/Graphics/SceneRoot.cpp
@@ -1,58 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Graphics/SceneRoot.hpp>
-#include <Nazara/Core/Error.hpp>
-#include <Nazara/Graphics/Debug.hpp>
-
-NzSceneRoot::NzSceneRoot(NzScene* scene)
-{
-	m_scene = scene;
-}
-
-NzSceneRoot::~NzSceneRoot() = default;
-
-void NzSceneRoot::AddToRenderQueue(NzAbstractRenderQueue* renderQueue) const
-{
-	NazaraUnused(renderQueue);
-
-	NazaraInternalError("SceneNode::AddToRenderQueue() called on SceneRoot");
-}
-
-nzSceneNodeType NzSceneRoot::GetSceneNodeType() const
-{
-	return nzSceneNodeType_Root;
-}
-
-bool NzSceneRoot::IsDrawable() const
-{
-	return true;
-}
-
-NzSceneRoot* NzSceneRoot::Clone() const
-{
-	NazaraInternalError("SceneNode::Clone() called on SceneRoot");
-	return nullptr;
-}
-
-NzSceneRoot* NzSceneRoot::Create() const
-{
-	NazaraInternalError("SceneNode::Create() called on SceneRoot");
-	return nullptr;
-}
-
-void NzSceneRoot::MakeBoundingVolume() const
-{
-	m_boundingVolume.MakeInfinite();
-}
-
-void NzSceneRoot::Register()
-{
-	NazaraInternalError("SceneNode::Register() called on SceneRoot");
-}
-
-void NzSceneRoot::Unregister()
-{
-	NazaraInternalError("SceneNode::Unregister() called on SceneRoot");
-}
--- a/src/Nazara/Graphics/SkeletalModel.cpp
+++ b/src/Nazara/Graphics/SkeletalModel.cpp
@@ -4,10 +4,8 @@

 #include <Nazara/Graphics/SkeletalModel.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
-#include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Graphics/SkinningManager.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/MeshData.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
--- a/src/Nazara/Graphics/SkyboxBackground.cpp
+++ b/src/Nazara/Graphics/SkyboxBackground.cpp
@@ -2,14 +2,9 @@
 // This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp

-#ifndef NAZARA_RENDERER_OPENGL
-#define NAZARA_RENDERER_OPENGL // Nécessaire pour inclure les headers OpenGL
-#endif
-
 #include <Nazara/Graphics/SkyboxBackground.hpp>
-#include <Nazara/Graphics/Camera.hpp>
-#include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Renderer/OpenGL.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
+#include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
@@ -19,221 +14,32 @@

 namespace
 {
-	NzIndexBuffer* BuildIndexBuffer()
-	{
-		std::unique_ptr<NzIndexBuffer> indexBuffer(new NzIndexBuffer(false, 36, nzDataStorage_Hardware, nzBufferUsage_Static));
-		indexBuffer->SetPersistent(false);
-
-		nzUInt16 indices[6*6] =
-		{
-			0, 1, 2, 0, 2, 3,
-			3, 2, 6, 3, 6, 7,
-			7, 6, 5, 7, 5, 4,
-			4, 5, 1, 4, 1, 0,
-			0, 3, 7, 0, 7, 4,
-			1, 6, 2, 1, 5, 6
-		};
-
-		if (!indexBuffer->Fill(indices, 0, 36))
-		{
-			NazaraError("Failed to create index buffer");
-			return nullptr;
-		}
-
-		return indexBuffer.release();
-	}
-
-	NzShader* BuildShader()
-	{
-		const char* fragmentSource110 =
-		"#version 110\n"
-
-		"varying vec3 vTexCoord;\n"
-
-		"uniform samplerCube Skybox;\n"
-		"uniform float VertexDepth;\n"
-
-		"void main()\n"
-		"{\n"
-		"	gl_FragColor = textureCube(Skybox, vTexCoord);\n"
-		"	gl_FragDepth = VertexDepth;\n"
-		"}\n";
-
-		const char* fragmentSource140 =
-		"#version 140\n"
-
-		"in vec3 vTexCoord;\n"
-
-		"out vec4 RenderTarget0;\n"
-
-		"uniform samplerCube Skybox;\n"
-		"uniform float VertexDepth;\n"
-
-		"void main()\n"
-		"{\n"
-		"	RenderTarget0 = texture(Skybox, vTexCoord);\n"
-		"	gl_FragDepth = VertexDepth;\n"
-		"}\n";
-
-		const char* vertexSource110 =
-		"#version 110\n"
-
-		"attribute vec3 VertexPosition;\n"
-
-		"varying vec3 vTexCoord;\n"
-
-		"uniform mat4 WorldViewProjMatrix;\n"
-
-		"void main()\n"
-		"{\n"
-		"    gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0);\n"
-		"    vTexCoord = vec3(VertexPosition.x, VertexPosition.y, -VertexPosition.z);\n"
-		"}\n";
-
-		const char* vertexSource140 =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"out vec3 vTexCoord;\n"
-
-		"uniform mat4 WorldViewProjMatrix;\n"
-
-		"void main()\n"
-		"{\n"
-		"    gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0);\n"
-		"    vTexCoord = vec3(VertexPosition.x, VertexPosition.y, -VertexPosition.z);\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShader> shader(new NzShader);
-		shader->SetPersistent(false);
-
-		if (!shader->Create())
-		{
-			NazaraError("Failed to create shader");
-			return nullptr;
-		}
-
-		bool useGLSL140 = (NzOpenGL::GetVersion() >= 310);
-
-		if (!shader->AttachStageFromSource(nzShaderStage_Fragment, (useGLSL140) ? fragmentSource140 : fragmentSource110))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!shader->AttachStageFromSource(nzShaderStage_Vertex, (useGLSL140) ? vertexSource140 : vertexSource110))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!shader->Link())
-		{
-			NazaraError("Failed to link shader");
-			return nullptr;
-		}
-
-		shader->SendInteger(shader->GetUniformLocation("Skybox"), 0);
-		shader->SendFloat(shader->GetUniformLocation("VertexDepth"), 1.f);
-
-		return shader.release();
-	}
-
-	NzRenderStates BuildRenderStates()
-	{
-		NzRenderStates states;
-		states.depthFunc = nzRendererComparison_Equal;
-		states.faceCulling = nzFaceSide_Front;
-		states.parameters[nzRendererParameter_DepthBuffer] = true;
-		states.parameters[nzRendererParameter_DepthWrite] = false;
-		states.parameters[nzRendererParameter_FaceCulling] = true;
-
-		return states;
-	}
-
-	NzVertexBuffer* BuildVertexBuffer()
-	{
-		std::unique_ptr<NzVertexBuffer> vertexBuffer(new NzVertexBuffer(NzVertexDeclaration::Get(nzVertexLayout_XYZ), 8, nzDataStorage_Hardware, nzBufferUsage_Static));
-		vertexBuffer->SetPersistent(false);
-
-		float vertices[8*(sizeof(float)*3)] =
-		{
-			-1.0,  1.0,  1.0,
-			-1.0, -1.0,  1.0,
-			 1.0, -1.0,  1.0,
-			 1.0,  1.0,  1.0,
-			-1.0,  1.0, -1.0,
-			-1.0, -1.0, -1.0,
-			 1.0, -1.0, -1.0,
-			 1.0,  1.0, -1.0,
-		};
-
-		if (!vertexBuffer->Fill(vertices, 0, 8))
-		{
-			NazaraError("Failed to create vertex buffer");
-			return nullptr;
-		}
-
-		return vertexBuffer.release();
-	}
-
-	static NzIndexBuffer* s_indexBuffer = nullptr;
-	static NzShader* s_shader = nullptr;
-	static NzVertexBuffer* s_vertexBuffer = nullptr;
+	static NzIndexBufferRef s_indexBuffer;
+	static NzRenderStates s_renderStates;
+	static NzShaderRef s_shader;
+	static NzVertexBufferRef s_vertexBuffer;
 }

-NzSkyboxBackground::NzSkyboxBackground()
+NzSkyboxBackground::NzSkyboxBackground(NzTextureRef cubemapTexture)
 {
-	if (!s_indexBuffer)
-		s_indexBuffer = BuildIndexBuffer();
-
-	if (!s_shader)
-		s_shader = BuildShader();
-
-	if (!s_vertexBuffer)
-		s_vertexBuffer = BuildVertexBuffer();
-
-	m_indexBuffer = s_indexBuffer;
 	m_sampler.SetWrapMode(nzSamplerWrap_Clamp); // Nécessaire pour ne pas voir les côtés
-	m_shader = s_shader;
-	m_vertexBuffer = s_vertexBuffer;
-}

-NzSkyboxBackground::NzSkyboxBackground(NzTexture* cubemapTexture) :
-NzSkyboxBackground()
-{
-	SetTexture(cubemapTexture);
-}
-
-NzSkyboxBackground::~NzSkyboxBackground()
-{
-	if (m_indexBuffer.Reset())
-		s_indexBuffer = nullptr;
-
-	if (m_shader.Reset())
-		s_shader = nullptr;
-
-	if (m_vertexBuffer.Reset())
-		s_vertexBuffer = nullptr;
+	SetTexture(std::move(cubemapTexture));
 }

 void NzSkyboxBackground::Draw(const NzAbstractViewer* viewer) const
 {
-	static NzRenderStates states(BuildRenderStates());
-
 	NzMatrix4f skyboxMatrix(viewer->GetViewMatrix());
 	skyboxMatrix.SetTranslation(NzVector3f::Zero());

-	NzRenderer::SetIndexBuffer(m_indexBuffer);
+	NzRenderer::SetIndexBuffer(s_indexBuffer);
 	NzRenderer::SetMatrix(nzMatrixType_View, skyboxMatrix);
 	NzRenderer::SetMatrix(nzMatrixType_World, NzMatrix4f::Scale(NzVector3f(viewer->GetZNear())));
-	NzRenderer::SetRenderStates(states);
-	NzRenderer::SetShader(m_shader);
+	NzRenderer::SetRenderStates(s_renderStates);
+	NzRenderer::SetShader(s_shader);
 	NzRenderer::SetTexture(0, m_texture);
 	NzRenderer::SetTextureSampler(0, m_sampler);
-	NzRenderer::SetVertexBuffer(m_vertexBuffer);
+	NzRenderer::SetVertexBuffer(s_vertexBuffer);

 	NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, 36);

@@ -245,29 +51,108 @@ nzBackgroundType NzSkyboxBackground::GetBackgroundType() const
 	return nzBackgroundType_Skybox;
 }

-NzTexture* NzSkyboxBackground::GetTexture() const
+bool NzSkyboxBackground::Initialize()
 {
-	return m_texture;
-}
-
-void NzSkyboxBackground::SetTexture(NzTexture* cubemapTexture)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (cubemapTexture)
+	const nzUInt16 indices[6*6] =
 	{
-		if (!cubemapTexture->IsValid())
-		{
-			NazaraError("Texture must be valid");
-			return;
-		}
+		0, 1, 2, 0, 2, 3,
+		3, 2, 6, 3, 6, 7,
+		7, 6, 5, 7, 5, 4,
+		4, 5, 1, 4, 1, 0,
+		0, 3, 7, 0, 7, 4,
+		1, 6, 2, 1, 5, 6
+	};

-		if (!cubemapTexture->IsCubemap())
-		{
-			NazaraError("Texture must be a cubemap");
-			return;
-		}
+	const float vertices[8 * 3 * sizeof(float)] =
+	{
+		-1.0,  1.0,  1.0,
+		-1.0, -1.0,  1.0,
+		 1.0, -1.0,  1.0,
+		 1.0,  1.0,  1.0,
+		-1.0,  1.0, -1.0,
+		-1.0, -1.0, -1.0,
+		 1.0, -1.0, -1.0,
+		 1.0,  1.0, -1.0,
+	};
+
+	///TODO: Replace by ShaderNode (probably after Vulkan)
+	const char* fragmentShaderSource =
+	"#version 140\n"
+
+	"in vec3 vTexCoord;\n"
+
+	"out vec4 RenderTarget0;\n"
+
+	"uniform samplerCube Skybox;\n"
+	"uniform float VertexDepth;\n"
+
+	"void main()\n"
+	"{\n"
+	"	RenderTarget0 = texture(Skybox, vTexCoord);\n"
+	"	gl_FragDepth = VertexDepth;\n"
+	"}\n";
+
+	const char* vertexShaderSource =
+	"#version 140\n"
+
+	"in vec3 VertexPosition;\n"
+
+	"out vec3 vTexCoord;\n"
+
+	"uniform mat4 WorldViewProjMatrix;\n"
+
+	"void main()\n"
+	"{\n"
+	"    gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0);\n"
+	"    vTexCoord = vec3(VertexPosition.x, VertexPosition.y, -VertexPosition.z);\n"
+	"}\n";
+
+	try
+	{
+		NzErrorFlags flags(nzErrorFlag_ThrowException, true);
+
+		// Index buffer
+		NzIndexBufferRef indexBuffer = NzIndexBuffer::New(false, 36, nzDataStorage_Hardware, nzBufferUsage_Static);
+		indexBuffer->Fill(indices, 0, 36);
+
+		// Vertex buffer
+		NzVertexBufferRef vertexBuffer = NzVertexBuffer::New(NzVertexDeclaration::Get(nzVertexLayout_XYZ), 8, nzDataStorage_Hardware, nzBufferUsage_Static);
+		vertexBuffer->Fill(vertices, 0, 8);
+
+		// Shader
+		NzShaderRef shader = NzShader::New();
+		shader->Create();
+		shader->AttachStageFromSource(nzShaderStage_Fragment, fragmentShaderSource);
+		shader->AttachStageFromSource(nzShaderStage_Vertex, vertexShaderSource);
+		shader->Link();
+
+		shader->SendInteger(shader->GetUniformLocation("Skybox"), 0);
+		shader->SendFloat(shader->GetUniformLocation("VertexDepth"), 1.f);
+
+		// Renderstates
+		s_renderStates.depthFunc = nzRendererComparison_Equal;
+		s_renderStates.faceCulling = nzFaceSide_Front;
+		s_renderStates.parameters[nzRendererParameter_DepthBuffer] = true;
+		s_renderStates.parameters[nzRendererParameter_DepthWrite] = false;
+		s_renderStates.parameters[nzRendererParameter_FaceCulling] = true;
+
+		// Exception-free zone
+		s_indexBuffer = std::move(indexBuffer);
+		s_shader = std::move(shader);
+		s_vertexBuffer = std::move(vertexBuffer);
+	}
+	catch (const std::exception& e)
+	{
+		NazaraError("Failed to initialise: " + NzString(e.what()));
+		return false;
 	}
-	#endif

-	m_texture = cubemapTexture;
+	return true;
+}
+
+void NzSkyboxBackground::Uninitialize()
+{
+	s_indexBuffer.Reset();
+	s_shader.Reset();
+	s_vertexBuffer.Reset();
 }
--- a/src/Nazara/Graphics/Sprite.cpp
+++ b/src/Nazara/Graphics/Sprite.cpp
@@ -5,7 +5,6 @@
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
-#include <Nazara/Graphics/Scene.hpp>
 #include <cstring>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
--- a/src/Nazara/Graphics/TextureBackground.cpp
+++ b/src/Nazara/Graphics/TextureBackground.cpp
@@ -22,7 +22,7 @@ namespace
 	}
 }

-NzTextureBackground::NzTextureBackground()
+NzTextureBackground::NzTextureBackground(NzTextureRef texture)
 {
 	m_uberShader = NzUberShaderLibrary::Get("Basic");

@@ -37,12 +37,8 @@ NzTextureBackground::NzTextureBackground()
 	m_materialDiffuseUniform = shader->GetUniformLocation("MaterialDiffuse");
 	m_materialDiffuseMapUniform = shader->GetUniformLocation("MaterialDiffuseMap");
 	m_vertexDepthUniform = shader->GetUniformLocation("VertexDepth");
-}

-NzTextureBackground::NzTextureBackground(NzTexture* texture) :
-NzTextureBackground()
-{
-	m_texture = texture;
+	SetTexture(std::move(texture));
 }

 void NzTextureBackground::Draw(const NzAbstractViewer* viewer) const
@@ -68,13 +64,3 @@ nzBackgroundType NzTextureBackground::GetBackgroundType() const
 {
 	return nzBackgroundType_Texture;
 }
-
-NzTexture* NzTextureBackground::GetTexture() const
-{
-	return m_texture;
-}
-
-void NzTextureBackground::SetTexture(NzTexture* texture)
-{
-	m_texture = texture;
-}
--- a/src/Nazara/Graphics/View.cpp
+++ b/src/Nazara/Graphics/View.cpp
@@ -1,408 +0,0 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#include <Nazara/Graphics/View.hpp>
-#include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/RenderTarget.hpp>
-#include <Nazara/Graphics/Debug.hpp>
-
-NzView::NzView() :
-m_targetRegion(0.f, 0.f, 1.f, 1.f),
-m_size(0.f),
-m_target(nullptr),
-m_frustumUpdated(false),
-m_invViewProjMatrixUpdated(false),
-m_projectionMatrixUpdated(false),
-m_viewMatrixUpdated(false),
-m_viewProjMatrixUpdated(false),
-m_viewportUpdated(false),
-m_zFar(1.f),
-m_zNear(-1.f)
-{
-}
-
-NzView::NzView(const NzVector2f& size) :
-NzView() // On délègue
-{
-	SetSize(size);
-}
-
-void NzView::EnsureFrustumUpdate() const
-{
-	if (!m_frustumUpdated)
-		UpdateFrustum();
-}
-
-void NzView::EnsureProjectionMatrixUpdate() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-}
-
-void NzView::EnsureViewMatrixUpdate() const
-{
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-}
-
-void NzView::EnsureViewportUpdate() const
-{
-	if (!m_viewportUpdated)
-		UpdateViewport();
-}
-
-float NzView::GetAspectRatio() const
-{
-	return 1.f;
-}
-
-NzVector3f NzView::GetEyePosition() const
-{
-	return GetPosition(nzCoordSys_Global);
-}
-
-NzVector3f NzView::GetForward() const
-{
-	return NzNode::GetForward();
-}
-
-const NzFrustumf& NzView::GetFrustum() const
-{
-	if (!m_frustumUpdated)
-		UpdateFrustum();
-
-	return m_frustum;
-}
-
-NzVector3f NzView::GetGlobalForward() const
-{
-	return NzVector3f::UnitZ();
-}
-
-NzVector3f NzView::GetGlobalRight() const
-{
-	return NzVector3f::UnitX();
-}
-
-NzVector3f NzView::GetGlobalUp() const
-{
-	return -NzVector3f::UnitY();
-}
-
-const NzMatrix4f& NzView::GetInvViewProjMatrix() const
-{
-	if (!m_invViewProjMatrixUpdated)
-		UpdateInvViewProjMatrix();
-
-	return m_invViewProjMatrix;
-}
-
-const NzMatrix4f& NzView::GetProjectionMatrix() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	return m_projectionMatrix;
-}
-
-const NzVector2f& NzView::GetSize() const
-{
-	return m_size;
-}
-
-const NzRenderTarget* NzView::GetTarget() const
-{
-	return m_target;
-}
-
-const NzRectf& NzView::GetTargetRegion() const
-{
-	return m_targetRegion;
-}
-
-const NzMatrix4f& NzView::GetViewMatrix() const
-{
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	return m_viewMatrix;
-}
-
-const NzMatrix4f& NzView::GetViewProjMatrix() const
-{
-	if (!m_viewProjMatrixUpdated)
-		UpdateViewProjMatrix();
-
-	return m_viewProjMatrix;
-}
-
-const NzRecti& NzView::GetViewport() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return m_viewport;
-	}
-	#endif
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	return m_viewport;
-}
-
-float NzView::GetZFar() const
-{
-	return m_zFar;
-}
-
-float NzView::GetZNear() const
-{
-	return m_zNear;
-}
-
-NzVector2f NzView::MapPixelToWorld(const NzVector2i& pixel)
-{
-	if (!m_invViewProjMatrixUpdated)
-		UpdateInvViewProjMatrix();
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	// Conversion du viewport en flottant
-	NzRectf viewport(m_viewport);
-
-	NzVector2f normalized;
-	normalized.x = -1.f + 2.f * (pixel.x - viewport.x) / viewport.width;
-	normalized.y =  1.f - 2.f * (pixel.y - viewport.y) / viewport.height;
-
-	return m_invViewProjMatrix.Transform(normalized);
-}
-
-NzVector2i NzView::MapWorldToPixel(const NzVector2f& coords)
-{
-	if (!m_viewProjMatrixUpdated)
-		UpdateViewProjMatrix();
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	// Conversion du viewport en flottant
-	NzRectf viewport(m_viewport);
-
-	NzVector2f normalized = m_viewProjMatrix.Transform(coords);
-
-	NzVector2i pixel;
-	pixel.x = static_cast<int>(( normalized.x + 1.f) * viewport.width / 2.f + viewport.x);
-	pixel.y = static_cast<int>((-normalized.y + 1.f) * viewport.width / 2.f + viewport.y);
-
-	return pixel;
-}
-
-void NzView::SetSize(const NzVector2f& size)
-{
-	SetSize(size.x, size.y);
-}
-
-void NzView::SetSize(float width, float height)
-{
-	m_size.Set(width, height);
-	m_projectionMatrixUpdated = false;
-}
-
-void NzView::SetTarget(const NzRenderTarget* renderTarget)
-{
-	m_target = renderTarget;
-	if (m_target)
-	{
-		m_targetReleaseSlot.Connect(m_target->OnRenderTargetRelease, this, &NzView::OnRenderTargetRelease);
-		m_targetResizeSlot.Connect(m_target->OnRenderTargetSizeChange, this, &NzView::OnRenderTargetSizeChange);
-	}
-	else
-	{
-		m_targetReleaseSlot.Disconnect();
-		m_targetResizeSlot.Disconnect();
-	}
-}
-
-void NzView::SetTarget(const NzRenderTarget& renderTarget)
-{
-	SetTarget(&renderTarget);
-}
-
-void NzView::SetTargetRegion(const NzRectf& region)
-{
-	m_targetRegion = region;
-
-	m_frustumUpdated = false;
-	m_invViewProjMatrixUpdated = false;
-	m_projectionMatrixUpdated = false;
-	m_viewProjMatrixUpdated = false;
-	m_viewportUpdated = false;
-}
-
-void NzView::SetViewport(const NzRecti& viewport)
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return;
-	}
-	#endif
-
-	// On calcule la région nécessaire pour produire ce viewport avec la taille actuelle de la cible
-	float invWidth = 1.f/m_target->GetWidth();
-	float invHeight = 1.f/m_target->GetHeight();
-
-	SetTargetRegion(NzRectf(invWidth * viewport.x, invHeight * viewport.y, invWidth * viewport.width, invHeight * viewport.height));
-}
-
-void NzView::SetZFar(float zFar)
-{
-	m_zFar = zFar;
-
-	m_frustumUpdated = false;
-	m_invViewProjMatrixUpdated = false;
-	m_projectionMatrixUpdated = false;
-	m_viewProjMatrixUpdated = false;
-}
-
-void NzView::SetZNear(float zNear)
-{
-	m_zNear = zNear;
-
-	m_frustumUpdated = false;
-	m_invViewProjMatrixUpdated = false;
-	m_projectionMatrixUpdated = false;
-	m_viewProjMatrixUpdated = false;
-}
-
-void NzView::ApplyView() const
-{
-	#if NAZARA_GRAPHICS_SAFE
-	if (!m_target)
-	{
-		NazaraError("Camera has no render target");
-		return;
-	}
-	#endif
-
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	if (!m_viewportUpdated)
-		UpdateViewport();
-
-	NzRenderer::SetMatrix(nzMatrixType_Projection, m_projectionMatrix);
-	NzRenderer::SetMatrix(nzMatrixType_View, m_viewMatrix);
-	NzRenderer::SetTarget(m_target);
-	NzRenderer::SetViewport(m_viewport);
-}
-
-void NzView::InvalidateNode()
-{
-	NzNode::InvalidateNode();
-
-	// Le frustum et la view matrix dépendent des paramètres du node, invalidons-les
-	m_frustumUpdated = false;
-	m_invViewProjMatrixUpdated = false;
-	m_viewMatrixUpdated = false;
-	m_viewProjMatrixUpdated = false;
-}
-
-void NzView::OnRenderTargetRelease(const NzRenderTarget* renderTarget)
-{
-	if (renderTarget == m_target)
-		m_target = nullptr;
-	else
-		NazaraInternalError("Not listening to " + NzString::Pointer(renderTarget));
-}
-
-void NzView::OnRenderTargetSizeChange(const NzRenderTarget* renderTarget)
-{
-	if (renderTarget == m_target)
-	{
-		m_frustumUpdated = false;
-		m_projectionMatrixUpdated = false;
-		m_viewportUpdated = false;
-	}
-	else
-		NazaraInternalError("Not listening to " + NzString::Pointer(renderTarget));
-}
-
-void NzView::UpdateFrustum() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	m_frustum.Extract(m_viewMatrix, m_projectionMatrix);
-	m_frustumUpdated = true;
-}
-
-void NzView::UpdateInvViewProjMatrix() const
-{
-	if (!m_viewProjMatrixUpdated)
-		UpdateViewProjMatrix();
-
-	m_viewProjMatrix.GetInverseAffine(&m_invViewProjMatrix);
-	m_invViewProjMatrixUpdated = true;
-}
-
-void NzView::UpdateProjectionMatrix() const
-{
-	if (m_size.x <= 0.f || m_size.y <= 0.f) // Si la taille est nulle, on prendra la taille du viewport
-	{
-		if (!m_viewportUpdated)
-			UpdateViewport();
-
-		m_projectionMatrix.MakeOrtho(0.f, static_cast<float>(m_viewport.width), 0.f, static_cast<float>(m_viewport.height), m_zNear, m_zFar);
-	}
-	else
-		m_projectionMatrix.MakeOrtho(0.f, m_size.x, 0.f, m_size.y, m_zNear, m_zFar);
-
-	m_projectionMatrixUpdated = true;
-}
-
-void NzView::UpdateViewMatrix() const
-{
-	if (!m_derivedUpdated)
-		UpdateDerived();
-
-	m_viewMatrix.MakeViewMatrix(m_derivedPosition, m_derivedRotation);
-	m_viewMatrixUpdated = true;
-}
-
-void NzView::UpdateViewProjMatrix() const
-{
-	if (!m_projectionMatrixUpdated)
-		UpdateProjectionMatrix();
-
-	if (!m_viewMatrixUpdated)
-		UpdateViewMatrix();
-
-	// La matrice de projection orthogonale est affine
-	m_viewProjMatrix = NzMatrix4f::ConcatenateAffine(m_viewMatrix, m_projectionMatrix);
-	m_viewProjMatrixUpdated = true;
-}
-
-void NzView::UpdateViewport() const
-{
-	unsigned int width = m_target->GetWidth();
-	unsigned int height = std::max(m_target->GetHeight(), 1U);
-
-	m_viewport.x = static_cast<int>(width * m_targetRegion.x);
-	m_viewport.y = static_cast<int>(height * m_targetRegion.y);
-	m_viewport.width = static_cast<int>(width * m_targetRegion.width);
-	m_viewport.height = static_cast<int>(height * m_targetRegion.height);
-	m_viewportUpdated = true;
-}