diff --git a/include/Nazara/Renderer/Material.hpp b/include/Nazara/Renderer/Material.hpp
index 3595a1aa4..e72750e92 100644
--- a/include/Nazara/Renderer/Material.hpp
+++ b/include/Nazara/Renderer/Material.hpp
@@ -14,6 +14,7 @@
 #include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
@@ -44,16 +45,16 @@ class NAZARA_API NzMaterial : public NzResource
 
 		void Apply(const NzShader* shader) const;
 
-		void EnableAlphaBlending(bool alphaBlending);
+		void EnableAlphaBlending(bool blending);
 		void EnableFaceCulling(bool faceCulling);
 		void EnableLighting(bool lighting);
 		void EnableZBuffer(bool zBuffer);
 		void EnableZWrite(bool zWrite);
 
 		NzColor GetAmbientColor() const;
+		NzTexture* GetAlphaMap() const;
 		const NzShader* GetCustomShader() const;
 		NzColor GetDiffuseColor() const;
-		NzTexture* GetAlphaMap() const;
 		NzTexture* GetDiffuseMap() const;
 		NzTextureSampler& GetDiffuseSampler();
 		const NzTextureSampler& GetDiffuseSampler() const;
@@ -119,15 +120,11 @@ class NAZARA_API NzMaterial : public NzResource
 	private:
 		void Copy(const NzMaterial& material);
 
-		nzBlendFunc m_dstBlend;
-		nzBlendFunc m_srcBlend;
-		nzFaceCulling m_faceCulling;
-		nzFaceFilling m_faceFilling;
-		nzRendererComparison m_zTestCompareFunc;
 		nzUInt32 m_shaderFlags;
 		NzColor m_ambientColor;
 		NzColor m_diffuseColor;
 		NzColor m_specularColor;
+		NzRenderStates m_states;
 		NzTextureSampler m_diffuseSampler;
 		NzTextureSampler m_specularSampler;
 		mutable NzShaderConstRef m_customShader;
@@ -137,11 +134,7 @@ class NAZARA_API NzMaterial : public NzResource
 		NzTextureRef m_heightMap;
 		NzTextureRef m_normalMap;
 		NzTextureRef m_specularMap;
-		bool m_alphaBlendingEnabled;
-		bool m_faceCullingEnabled;
 		bool m_lightingEnabled;
-		bool m_zBufferEnabled;
-		bool m_zWriteEnabled;
 		float m_shininess;
 
 		static NzMaterialLoader::LoaderList s_loaders;
diff --git a/include/Nazara/Renderer/OpenGL.hpp b/include/Nazara/Renderer/OpenGL.hpp
index b84617fbe..2ba8cee17 100644
--- a/include/Nazara/Renderer/OpenGL.hpp
+++ b/include/Nazara/Renderer/OpenGL.hpp
@@ -15,6 +15,7 @@
 #include <Nazara/Core/String.hpp>
 #include <Nazara/Utility/Enums.hpp>
 #include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Renderer/RenderStates.hpp>
 
 // Inclusion des extensions
 #include <GL3/glext.h>
@@ -65,6 +66,8 @@ class NAZARA_API NzOpenGL
 		NzOpenGL() = delete;
 		~NzOpenGL() = delete;
 
+		static void ApplyStates(const NzRenderStates& states);
+
 		static void BindBuffer(nzBufferType type, GLuint id);
 		static void BindProgram(GLuint id);
 		static void BindTexture(nzImageType type, GLuint id);
diff --git a/include/Nazara/Renderer/RenderStates.hpp b/include/Nazara/Renderer/RenderStates.hpp
new file mode 100644
index 000000000..d95d6dfb9
--- /dev/null
+++ b/include/Nazara/Renderer/RenderStates.hpp
@@ -0,0 +1,38 @@
+// Copyright (C) 2013 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_RENDERSTATES_HPP
+#define NAZARA_RENDERSTATES_HPP
+
+#include <Nazara/Renderer/Enums.hpp>
+
+struct NzRenderStates
+{
+	NzRenderStates();
+	NzRenderStates(const NzRenderStates& states);
+	~NzRenderStates() = default;
+
+	NzRenderStates& operator=(const NzRenderStates& states);
+
+	nzBlendFunc dstBlend;
+	nzBlendFunc srcBlend;
+	nzFaceCulling faceCulling;
+	nzFaceFilling faceFilling;
+	nzRendererComparison depthFunc;
+	nzRendererComparison stencilCompare;
+	nzStencilOperation stencilFail;
+	nzStencilOperation stencilPass;
+	nzStencilOperation stencilZFail;
+	nzUInt32 stencilMask;
+	bool parameters[nzRendererParameter_Max+1];
+	float lineWidth;
+	float pointSize;
+	unsigned int stencilReference;
+};
+
+#include <Nazara/Renderer/RenderStates.inl>
+
+#endif // NAZARA_RENDERSTATES_HPP
diff --git a/include/Nazara/Renderer/RenderStates.inl b/include/Nazara/Renderer/RenderStates.inl
new file mode 100644
index 000000000..a7cdcf3c1
--- /dev/null
+++ b/include/Nazara/Renderer/RenderStates.inl
@@ -0,0 +1,44 @@
+// Copyright (C) 2013 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <cstring>
+#include <Nazara/Renderer/Debug.hpp>
+
+inline NzRenderStates::NzRenderStates() :
+dstBlend(nzBlendFunc_Zero),
+srcBlend(nzBlendFunc_One),
+faceCulling(nzFaceCulling_Back),
+faceFilling(nzFaceFilling_Fill),
+depthFunc(nzRendererComparison_Less),
+stencilCompare(nzRendererComparison_Always),
+stencilFail(nzStencilOperation_Keep),
+stencilPass(nzStencilOperation_Keep),
+stencilZFail(nzStencilOperation_Keep),
+stencilMask(0xFFFFFFFF),
+lineWidth(1.f),
+pointSize(1.f),
+stencilReference(0)
+{
+	parameters[nzRendererParameter_Blend] = false;
+	parameters[nzRendererParameter_ColorWrite] = true;
+	parameters[nzRendererParameter_DepthBuffer] = false;
+	parameters[nzRendererParameter_DepthWrite] = true;
+	parameters[nzRendererParameter_FaceCulling] = false;
+	parameters[nzRendererParameter_ScissorTest] = false;
+	parameters[nzRendererParameter_StencilTest] = false;
+}
+
+inline NzRenderStates::NzRenderStates(const NzRenderStates& states)
+{
+	std::memcpy(this, &states, sizeof(NzRenderStates));
+}
+
+inline NzRenderStates& NzRenderStates::operator=(const NzRenderStates& states)
+{
+	std::memcpy(this, &states, sizeof(NzRenderStates));
+
+	return *this;
+}
+
+#include <Nazara/Renderer/DebugOff.hpp>
diff --git a/include/Nazara/Renderer/Renderer.hpp b/include/Nazara/Renderer/Renderer.hpp
index fee2806a7..b3a4dae6e 100644
--- a/include/Nazara/Renderer/Renderer.hpp
+++ b/include/Nazara/Renderer/Renderer.hpp
@@ -12,6 +12,7 @@
 #include <Nazara/Math/Matrix4.hpp>
 #include <Nazara/Math/Rect.hpp>
 #include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 #include <Nazara/Utility/Enums.hpp>
 
@@ -53,6 +54,7 @@ class NAZARA_API NzRenderer
 		static unsigned int GetMaxRenderTargets();
 		static unsigned int GetMaxTextureUnits();
 		static float GetPointSize();
+		static const NzRenderStates& GetRenderStates();
 		static NzRectui GetScissorRect();
 		static const NzShader* GetShader();
 		static const NzRenderTarget* GetTarget();
@@ -65,7 +67,7 @@ class NAZARA_API NzRenderer
 		static bool IsEnabled(nzRendererParameter parameter);
 		static bool IsInitialized();
 
-		static void SetBlendFunc(nzBlendFunc srcBlend, nzBlendFunc destBlend);
+		static void SetBlendFunc(nzBlendFunc srcBlend, nzBlendFunc dstBlend);
 		static void SetClearColor(const NzColor& color);
 		static void SetClearColor(nzUInt8 r, nzUInt8 g, nzUInt8 b, nzUInt8 a = 255);
 		static void SetClearDepth(double depth);
@@ -78,6 +80,7 @@ class NAZARA_API NzRenderer
 		static void SetLineWidth(float size);
 		static void SetMatrix(nzMatrixType type, const NzMatrix4f& matrix);
 		static void SetPointSize(float size);
+		static void SetRenderStates(const NzRenderStates& states);
 		static void SetScissorRect(const NzRectui& viewport);
 		static void SetShader(const NzShader* shader);
 		static void SetStencilCompareFunction(nzRendererComparison compareFunc);
diff --git a/src/Nazara/Renderer/Material.cpp b/src/Nazara/Renderer/Material.cpp
index 237478977..9da4416e9 100644
--- a/src/Nazara/Renderer/Material.cpp
+++ b/src/Nazara/Renderer/Material.cpp
@@ -137,42 +137,17 @@ void NzMaterial::Apply(const NzShader* shader) const
 		}
 	}
 
-	if (m_alphaBlendingEnabled)
-	{
-		NzRenderer::Enable(nzRendererParameter_Blend, true);
-		NzRenderer::SetBlendFunc(m_srcBlend, m_dstBlend);
-	}
-	else
-		NzRenderer::Enable(nzRendererParameter_Blend, false);
-
-	if (m_faceCullingEnabled)
-	{
-		NzRenderer::Enable(nzRendererParameter_FaceCulling, true);
-		NzRenderer::SetFaceCulling(m_faceCulling);
-	}
-	else
-		NzRenderer::Enable(nzRendererParameter_FaceCulling, false);
-
-	NzRenderer::SetFaceFilling(m_faceFilling);
-
-	if (m_zBufferEnabled)
-	{
-		NzRenderer::Enable(nzRendererParameter_DepthBuffer, true);
-		NzRenderer::Enable(nzRendererParameter_DepthWrite, m_zWriteEnabled);
-		NzRenderer::SetDepthFunc(m_zTestCompareFunc);
-	}
-	else
-		NzRenderer::Enable(nzRendererParameter_DepthBuffer, false);
+	NzRenderer::SetRenderStates(m_states);
 }
 
-void NzMaterial::EnableAlphaBlending(bool alphaBlending)
+void NzMaterial::EnableAlphaBlending(bool blending)
 {
-	m_alphaBlendingEnabled = alphaBlending;
+	m_states.parameters[nzRendererParameter_Blend] = blending;
 }
 
 void NzMaterial::EnableFaceCulling(bool faceCulling)
 {
-	m_faceCullingEnabled = faceCulling;
+	m_states.parameters[nzRendererParameter_FaceCulling] = faceCulling;
 }
 
 void NzMaterial::EnableLighting(bool lighting)
@@ -186,12 +161,12 @@ void NzMaterial::EnableLighting(bool lighting)
 
 void NzMaterial::EnableZBuffer(bool zBuffer)
 {
-	m_zBufferEnabled = zBuffer;
+	m_states.parameters[nzRendererParameter_DepthBuffer] = zBuffer;
 }
 
 void NzMaterial::EnableZWrite(bool zWrite)
 {
-	m_zWriteEnabled = zWrite;
+	m_states.parameters[nzRendererParameter_DepthWrite] = zWrite;
 }
 
 NzColor NzMaterial::GetAmbientColor() const
@@ -199,6 +174,16 @@ NzColor NzMaterial::GetAmbientColor() const
 	return m_ambientColor;
 }
 
+NzTexture* NzMaterial::GetAlphaMap() const
+{
+	return m_alphaMap;
+}
+
+const NzShader* NzMaterial::GetCustomShader() const
+{
+	return m_customShader;
+}
+
 NzColor NzMaterial::GetDiffuseColor() const
 {
 	return m_diffuseColor;
@@ -221,7 +206,7 @@ NzTexture* NzMaterial::GetDiffuseMap() const
 
 nzBlendFunc NzMaterial::GetDstBlend() const
 {
-	return m_dstBlend;
+	return m_states.dstBlend;
 }
 
 NzTexture* NzMaterial::GetEmissiveMap() const
@@ -231,12 +216,12 @@ NzTexture* NzMaterial::GetEmissiveMap() const
 
 nzFaceCulling NzMaterial::GetFaceCulling() const
 {
-	return m_faceCulling;
+	return m_states.faceCulling;
 }
 
 nzFaceFilling NzMaterial::GetFaceFilling() const
 {
-	return m_faceFilling;
+	return m_states.faceFilling;
 }
 
 NzTexture* NzMaterial::GetHeightMap() const
@@ -249,11 +234,6 @@ NzTexture* NzMaterial::GetNormalMap() const
 	return m_normalMap;
 }
 
-const NzShader* NzMaterial::GetCustomShader() const
-{
-	return m_customShader;
-}
-
 nzUInt32 NzMaterial::GetShaderFlags() const
 {
 	return m_shaderFlags;
@@ -286,12 +266,12 @@ const NzTextureSampler& NzMaterial::GetSpecularSampler() const
 
 nzBlendFunc NzMaterial::GetSrcBlend() const
 {
-	return m_srcBlend;
+	return m_states.srcBlend;
 }
 
 nzRendererComparison NzMaterial::GetZTestCompare() const
 {
-	return m_zTestCompareFunc;
+	return m_states.depthFunc;
 }
 
 bool NzMaterial::HasCustomShader() const
@@ -301,12 +281,12 @@ bool NzMaterial::HasCustomShader() const
 
 bool NzMaterial::IsAlphaBlendingEnabled() const
 {
-	return m_alphaBlendingEnabled;
+	return m_states.parameters[nzRendererParameter_Blend];
 }
 
 bool NzMaterial::IsFaceCullingEnabled() const
 {
-	return m_faceCullingEnabled;
+	return m_states.parameters[nzRendererParameter_FaceCulling];
 }
 
 bool NzMaterial::IsLightingEnabled() const
@@ -316,12 +296,12 @@ bool NzMaterial::IsLightingEnabled() const
 
 bool NzMaterial::IsZBufferEnabled() const
 {
-	return m_zBufferEnabled;
+	return m_states.parameters[nzRendererParameter_DepthBuffer];
 }
 
 bool NzMaterial::IsZWriteEnabled() const
 {
-	return m_zWriteEnabled;
+	return m_states.parameters[nzRendererParameter_DepthWrite];
 }
 
 bool NzMaterial::LoadFromFile(const NzString& filePath, const NzMaterialParams& params)
@@ -349,23 +329,17 @@ void NzMaterial::Reset()
 	m_normalMap.Reset();
 	m_specularMap.Reset();
 
-	m_alphaBlendingEnabled = false;
 	m_ambientColor = NzColor(128, 128, 128);
 	m_diffuseColor = NzColor::White;
 	m_diffuseSampler = NzTextureSampler();
-	m_dstBlend = nzBlendFunc_Zero;
-	m_faceCulling = nzFaceCulling_Back;
-	m_faceCullingEnabled = true;
-	m_faceFilling = nzFaceFilling_Fill;
 	m_lightingEnabled = true;
 	m_shaderFlags = nzShaderFlags_Lighting;
 	m_shininess = 50.f;
 	m_specularColor = NzColor::White;
 	m_specularSampler = NzTextureSampler();
-	m_srcBlend = nzBlendFunc_One;
-	m_zBufferEnabled = true;
-	m_zTestCompareFunc = nzRendererComparison_LessOrEqual;
-	m_zWriteEnabled = true;
+	m_states = NzRenderStates();
+	m_states.parameters[nzRendererParameter_DepthBuffer] = true;
+	m_states.parameters[nzRendererParameter_FaceCulling] = true;
 }
 
 bool NzMaterial::SetAlphaMap(const NzString& texturePath)
@@ -442,7 +416,7 @@ void NzMaterial::SetDiffuseSampler(const NzTextureSampler& sampler)
 
 void NzMaterial::SetDstBlend(nzBlendFunc func)
 {
-	m_dstBlend = func;
+	m_states.dstBlend = func;
 }
 
 bool NzMaterial::SetEmissiveMap(const NzString& texturePath)
@@ -473,12 +447,12 @@ void NzMaterial::SetEmissiveMap(NzTexture* map)
 
 void NzMaterial::SetFaceCulling(nzFaceCulling culling)
 {
-	m_faceCulling = culling;
+	m_states.faceCulling = culling;
 }
 
 void NzMaterial::SetFaceFilling(nzFaceFilling filling)
 {
-	m_faceFilling = filling;
+	m_states.faceFilling = filling;
 }
 
 bool NzMaterial::SetHeightMap(const NzString& texturePath)
@@ -572,12 +546,12 @@ void NzMaterial::SetSpecularSampler(const NzTextureSampler& sampler)
 
 void NzMaterial::SetSrcBlend(nzBlendFunc func)
 {
-	m_srcBlend = func;
+	m_states.srcBlend = func;
 }
 
 void NzMaterial::SetZTestCompare(nzRendererComparison compareFunc)
 {
-	m_zTestCompareFunc = compareFunc;
+	m_states.depthFunc = compareFunc;
 }
 
 NzMaterial& NzMaterial::operator=(const NzMaterial& material)
diff --git a/src/Nazara/Renderer/OpenGL.cpp b/src/Nazara/Renderer/OpenGL.cpp
index f4007de9f..09856edd9 100644
--- a/src/Nazara/Renderer/OpenGL.cpp
+++ b/src/Nazara/Renderer/OpenGL.cpp
@@ -4,6 +4,7 @@
 
 #include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Core/Error.hpp>
+#include <Nazara/Math/Basic.hpp>
 #include <Nazara/Renderer/Context.hpp>
 #include <cstring>
 #include <set>
@@ -62,6 +63,7 @@ namespace
 	GLuint s_buffersBinding[nzBufferType_Max+1];
 	GLuint s_currentProgram;
 	GLuint s_texturesBinding[32]; // 32 est pour l'instant la plus haute limite (GL_TEXTURE31)
+	NzRenderStates s_states; // Toujours synchronisé avec OpenGL
 	const char* s_rendererName = nullptr;
 	const char* s_vendorName = nullptr;
 	bool s_initialized = false;
@@ -114,6 +116,126 @@ namespace
 	}
 }
 
+void NzOpenGL::ApplyStates(const NzRenderStates& states)
+{
+	if (states.dstBlend != states.dstBlend || s_states.srcBlend != states.srcBlend)
+	{
+		glBlendFunc(BlendFunc[states.srcBlend], BlendFunc[states.dstBlend]);
+		s_states.dstBlend = states.dstBlend;
+	}
+
+	if (s_states.depthFunc != states.depthFunc)
+	{
+		glDepthFunc(RendererComparison[states.depthFunc]);
+		s_states.depthFunc = states.depthFunc;
+	}
+
+	if (s_states.faceCulling != states.faceCulling)
+	{
+		glCullFace(FaceCulling[states.faceCulling]);
+		s_states.faceCulling = states.faceCulling;
+	}
+
+	if (s_states.faceFilling != states.faceFilling)
+	{
+		glPolygonMode(GL_FRONT_AND_BACK, FaceFilling[states.faceFilling]);
+		s_states.faceFilling = states.faceFilling;
+	}
+
+	if (s_states.stencilCompare != states.stencilCompare || s_states.stencilMask != states.stencilMask || s_states.stencilReference != states.stencilReference)
+	{
+		glStencilFunc(RendererComparison[states.stencilCompare], states.stencilReference, states.stencilMask);
+		s_states.stencilCompare = states.stencilCompare;
+		s_states.stencilMask = states.stencilMask;
+		s_states.stencilReference = states.stencilReference;
+	}
+
+	if (s_states.stencilFail != states.stencilFail || s_states.stencilPass != states.stencilPass || s_states.stencilZFail != states.stencilZFail)
+	{
+		glStencilOp(StencilOperation[states.stencilFail], StencilOperation[states.stencilZFail], StencilOperation[states.stencilPass]);
+		s_states.stencilFail = states.stencilFail;
+		s_states.stencilPass = states.stencilPass;
+		s_states.stencilZFail = states.stencilZFail;
+	}
+
+	if (NzNumberEquals(s_states.lineWidth, states.lineWidth, 0.001f))
+	{
+		glLineWidth(states.lineWidth);
+		s_states.lineWidth = states.lineWidth;
+	}
+
+	if (NzNumberEquals(s_states.pointSize, states.pointSize, 0.001f))
+	{
+		glPointSize(states.pointSize);
+		s_states.pointSize = states.pointSize;
+	}
+
+	// Paramètres de rendu
+	if (s_states.parameters[nzRendererParameter_Blend] != states.parameters[nzRendererParameter_Blend])
+	{
+		if (states.parameters[nzRendererParameter_Blend])
+			glEnable(GL_BLEND);
+		else
+			glDisable(GL_BLEND);
+
+		s_states.parameters[nzRendererParameter_Blend] = states.parameters[nzRendererParameter_Blend];
+	}
+
+	if (s_states.parameters[nzRendererParameter_ColorWrite] != states.parameters[nzRendererParameter_ColorWrite])
+	{
+		GLboolean param = (states.parameters[nzRendererParameter_ColorWrite]) ? GL_TRUE : GL_FALSE;
+		glColorMask(param, param, param, param);
+
+		s_states.parameters[nzRendererParameter_ColorWrite] = states.parameters[nzRendererParameter_ColorWrite];
+	}
+
+	if (s_states.parameters[nzRendererParameter_DepthBuffer] != states.parameters[nzRendererParameter_DepthBuffer])
+	{
+		if (states.parameters[nzRendererParameter_DepthBuffer])
+			glEnable(GL_DEPTH_TEST);
+		else
+			glDisable(GL_DEPTH_TEST);
+
+		s_states.parameters[nzRendererParameter_DepthBuffer] = states.parameters[nzRendererParameter_DepthBuffer];
+	}
+
+	if (s_states.parameters[nzRendererParameter_DepthWrite] != states.parameters[nzRendererParameter_DepthWrite])
+	{
+		glDepthMask((states.parameters[nzRendererParameter_DepthWrite]) ? GL_TRUE : GL_FALSE);
+		s_states.parameters[nzRendererParameter_DepthWrite] = states.parameters[nzRendererParameter_DepthWrite];
+	}
+
+	if (s_states.parameters[nzRendererParameter_FaceCulling] != states.parameters[nzRendererParameter_FaceCulling])
+	{
+		if (states.parameters[nzRendererParameter_FaceCulling])
+			glEnable(GL_CULL_FACE);
+		else
+			glDisable(GL_CULL_FACE);
+
+		s_states.parameters[nzRendererParameter_FaceCulling] = states.parameters[nzRendererParameter_FaceCulling];
+	}
+
+	if (s_states.parameters[nzRendererParameter_ScissorTest] != states.parameters[nzRendererParameter_ScissorTest])
+	{
+		if (states.parameters[nzRendererParameter_ScissorTest])
+			glEnable(GL_SCISSOR_TEST);
+		else
+			glDisable(GL_SCISSOR_TEST);
+
+		s_states.parameters[nzRendererParameter_ScissorTest] = states.parameters[nzRendererParameter_ScissorTest];
+	}
+
+	if (s_states.parameters[nzRendererParameter_StencilTest] != states.parameters[nzRendererParameter_StencilTest])
+	{
+		if (states.parameters[nzRendererParameter_StencilTest])
+			glEnable(GL_STENCIL_TEST);
+		else
+			glDisable(GL_STENCIL_TEST);
+
+		s_states.parameters[nzRendererParameter_StencilTest] = states.parameters[nzRendererParameter_StencilTest];
+	}
+}
+
 void NzOpenGL::BindBuffer(nzBufferType type, GLuint id)
 {
 	if (s_buffersBinding[type] != id)
diff --git a/src/Nazara/Renderer/Renderer.cpp b/src/Nazara/Renderer/Renderer.cpp
index 79a6b9153..fb259f836 100644
--- a/src/Nazara/Renderer/Renderer.cpp
+++ b/src/Nazara/Renderer/Renderer.cpp
@@ -48,10 +48,8 @@ namespace
 
 		Update_Matrices     = 0x01,
 		Update_Shader       = 0x02,
-		Update_StencilFunc  = 0x04,
-		Update_StencilOp    = 0x08,
-		Update_Textures     = 0x10,
-		Update_VAO          = 0x20,
+		Update_Textures     = 0x04,
+		Update_VAO          = 0x08,
 	};
 
 	struct TextureUnit
@@ -77,18 +75,9 @@ namespace
 	NzBuffer* s_instancingBuffer = nullptr;
 	NzVertexBuffer* s_quadBuffer = nullptr;
 	NzMatrix4f s_matrix[totalMatrixCount];
+	NzRenderStates s_states;
 	NzVector2ui s_targetSize;
-	nzBlendFunc s_srcBlend;
-	nzBlendFunc s_dstBlend;
-	nzFaceCulling s_faceCulling;
-	nzFaceFilling s_faceFilling;
-	nzRendererComparison s_depthFunc;
-	nzRendererComparison s_stencilCompare;
-	nzStencilOperation s_stencilFail;
-	nzStencilOperation s_stencilPass;
-	nzStencilOperation s_stencilZFail;
 	nzUInt8 s_maxAnisotropyLevel;
-	nzUInt32 s_stencilMask;
 	nzUInt32 s_updateFlags;
 	const NzIndexBuffer* s_indexBuffer;
 	const NzRenderTarget* s_target;
@@ -102,7 +91,6 @@ namespace
 	int s_matrixLocation[totalMatrixCount];
 	unsigned int s_maxRenderTarget;
 	unsigned int s_maxTextureUnit;
-	unsigned int s_stencilReference;
 }
 
 void NzRenderer::Clear(unsigned long flags)
@@ -468,7 +456,8 @@ void NzRenderer::Enable(nzRendererParameter parameter, bool enable)
 	}
 	#endif
 
-	switch (parameter)
+	s_states.parameters[parameter] = enable;
+	/*switch (parameter)
 	{
 		case nzRendererParameter_ColorWrite:
 			glColorMask(enable, enable, enable, enable);
@@ -485,7 +474,7 @@ void NzRenderer::Enable(nzRendererParameter parameter, bool enable)
 				glDisable(NzOpenGL::RendererParameter[parameter]);
 
 			break;
-	}
+	}*/
 }
 
 void NzRenderer::Flush()
@@ -511,10 +500,7 @@ float NzRenderer::GetLineWidth()
 	}
 	#endif
 
-	float lineWidth;
-	glGetFloatv(GL_LINE_WIDTH, &lineWidth);
-
-	return lineWidth;
+	return s_states.lineWidth;
 }
 /*
 NzMatrix4f NzRenderer::GetMatrix(nzMatrixCombination combination)
@@ -588,10 +574,12 @@ float NzRenderer::GetPointSize()
 	}
 	#endif
 
-	float pointSize;
-	glGetFloatv(GL_POINT_SIZE, &pointSize);
+	return s_states.pointSize;
+}
 
-	return pointSize;
+const NzRenderStates& NzRenderer::GetRenderStates()
+{
+	return s_states;
 }
 
 NzRectui NzRenderer::GetScissorRect()
@@ -744,18 +732,10 @@ bool NzRenderer::Initialize()
 	else
 		s_maxTextureUnit = 1;
 
-	s_dstBlend = nzBlendFunc_Zero;
-	s_faceCulling = nzFaceCulling_Back;
-	s_faceFilling = nzFaceFilling_Fill;
+	s_states = NzRenderStates();
+
 	s_indexBuffer = nullptr;
 	s_shader = nullptr;
-	s_srcBlend = nzBlendFunc_One;
-	s_stencilCompare = nzRendererComparison_Always;
-	s_stencilFail = nzStencilOperation_Keep;
-	s_stencilMask = 0xFFFFFFFF;
-	s_stencilPass = nzStencilOperation_Keep;
-	s_stencilReference = 0;
-	s_stencilZFail = nzStencilOperation_Keep;
 	s_target = nullptr;
 	s_textureUnits.resize(s_maxTextureUnit);
 	s_useSamplerObjects = NzOpenGL::IsSupported(nzOpenGLExtension_SamplerObjects);
@@ -826,27 +806,7 @@ bool NzRenderer::IsEnabled(nzRendererParameter parameter)
 	}
 	#endif
 
-	switch (parameter)
-	{
-		case nzRendererParameter_ColorWrite:
-		{
-			GLboolean enabled;
-			glGetBooleanv(GL_COLOR_WRITEMASK, &enabled);
-
-			return enabled;
-		}
-
-		case nzRendererParameter_DepthWrite:
-		{
-			GLboolean enabled;
-			glGetBooleanv(GL_DEPTH_WRITEMASK, &enabled);
-
-			return enabled;
-		}
-
-		default:
-			return glIsEnabled(NzOpenGL::RendererParameter[parameter]);
-	}
+	return s_states.parameters[parameter];
 }
 
 bool NzRenderer::IsInitialized()
@@ -854,7 +814,7 @@ bool NzRenderer::IsInitialized()
 	return s_moduleReferenceCounter != 0;
 }
 
-void NzRenderer::SetBlendFunc(nzBlendFunc srcBlend, nzBlendFunc destBlend)
+void NzRenderer::SetBlendFunc(nzBlendFunc srcBlend, nzBlendFunc dstBlend)
 {
 	#ifdef NAZARA_DEBUG
 	if (NzContext::GetCurrent() == nullptr)
@@ -864,12 +824,8 @@ void NzRenderer::SetBlendFunc(nzBlendFunc srcBlend, nzBlendFunc destBlend)
 	}
 	#endif
 
-	if (s_srcBlend != srcBlend || s_dstBlend != destBlend)
-	{
-		glBlendFunc(NzOpenGL::BlendFunc[srcBlend], NzOpenGL::BlendFunc[destBlend]);
-		s_srcBlend = srcBlend;
-		s_dstBlend = destBlend;
-	}
+	s_states.srcBlend = srcBlend;
+	s_states.dstBlend = dstBlend;
 }
 
 void NzRenderer::SetClearColor(const NzColor& color)
@@ -934,11 +890,7 @@ void NzRenderer::SetDepthFunc(nzRendererComparison compareFunc)
 	}
 	#endif
 
-	if (s_depthFunc != compareFunc)
-	{
-		glDepthFunc(NzOpenGL::RendererComparison[compareFunc]);
-		s_depthFunc = compareFunc;
-	}
+	s_states.depthFunc = compareFunc;
 }
 
 void NzRenderer::SetFaceCulling(nzFaceCulling cullingMode)
@@ -951,11 +903,7 @@ void NzRenderer::SetFaceCulling(nzFaceCulling cullingMode)
 	}
 	#endif
 
-	if (s_faceCulling != cullingMode)
-	{
-		glCullFace(NzOpenGL::FaceCulling[cullingMode]);
-		s_faceCulling = cullingMode;
-	}
+	s_states.faceCulling = cullingMode;
 }
 
 void NzRenderer::SetFaceFilling(nzFaceFilling fillingMode)
@@ -968,11 +916,7 @@ void NzRenderer::SetFaceFilling(nzFaceFilling fillingMode)
 	}
 	#endif
 
-	if (s_faceFilling != fillingMode)
-	{
-		glPolygonMode(GL_FRONT_AND_BACK, NzOpenGL::FaceFilling[fillingMode]);
-		s_faceFilling = fillingMode;
-	}
+	s_states.faceFilling = fillingMode;
 }
 
 void NzRenderer::SetIndexBuffer(const NzIndexBuffer* indexBuffer)
@@ -1042,7 +986,7 @@ void NzRenderer::SetLineWidth(float width)
 	}
 	#endif
 
-	glLineWidth(width);
+	s_states.lineWidth = width;
 }
 
 void NzRenderer::SetMatrix(nzMatrixType type, const NzMatrix4f& matrix)
@@ -1092,7 +1036,12 @@ void NzRenderer::SetPointSize(float size)
 	}
 	#endif
 
-	glPointSize(size);
+	s_states.pointSize = size;
+}
+
+void NzRenderer::SetRenderStates(const NzRenderStates& states)
+{
+	s_states = states;
 }
 
 void NzRenderer::SetScissorRect(const NzRectui& rect)
@@ -1152,11 +1101,7 @@ void NzRenderer::SetStencilCompareFunction(nzRendererComparison compareFunc)
 	}
 	#endif
 
-	if (compareFunc != s_stencilCompare)
-	{
-		s_stencilCompare = compareFunc;
-		s_updateFlags |= Update_StencilFunc;
-	}
+	s_states.stencilCompare = compareFunc;
 }
 
 void NzRenderer::SetStencilFailOperation(nzStencilOperation failOperation)
@@ -1169,20 +1114,12 @@ void NzRenderer::SetStencilFailOperation(nzStencilOperation failOperation)
 	}
 	#endif
 
-	if (failOperation != s_stencilFail)
-	{
-		s_stencilFail = failOperation;
-		s_updateFlags |= Update_StencilOp;
-	}
+	s_states.stencilFail = failOperation;
 }
 
 void NzRenderer::SetStencilMask(nzUInt32 mask)
 {
-	if (mask != s_stencilMask)
-	{
-		s_stencilMask = mask;
-		s_updateFlags |= Update_StencilFunc;
-	}
+	s_states.stencilMask = mask;
 }
 
 void NzRenderer::SetStencilPassOperation(nzStencilOperation passOperation)
@@ -1195,20 +1132,12 @@ void NzRenderer::SetStencilPassOperation(nzStencilOperation passOperation)
 	}
 	#endif
 
-	if (passOperation != s_stencilPass)
-	{
-		s_stencilPass = passOperation;
-		s_updateFlags |= Update_StencilOp;
-	}
+	s_states.stencilPass = passOperation;
 }
 
 void NzRenderer::SetStencilReferenceValue(unsigned int refValue)
 {
-	if (refValue != s_stencilReference)
-	{
-		s_stencilReference = refValue;
-		s_updateFlags |= Update_StencilFunc;
-	}
+	s_states.stencilReference = refValue;
 }
 
 void NzRenderer::SetStencilZFailOperation(nzStencilOperation zfailOperation)
@@ -1221,11 +1150,7 @@ void NzRenderer::SetStencilZFailOperation(nzStencilOperation zfailOperation)
 	}
 	#endif
 
-	if (zfailOperation != s_stencilZFail)
-	{
-		s_stencilZFail = zfailOperation;
-		s_updateFlags |= Update_StencilOp;
-	}
+	s_states.stencilZFail = zfailOperation;
 }
 
 bool NzRenderer::SetTarget(const NzRenderTarget* target)
@@ -1552,18 +1477,6 @@ bool NzRenderer::EnsureStateUpdate()
 			s_updateFlags &= ~Update_Matrices;
 		}
 
-		if (s_updateFlags & Update_StencilFunc)
-		{
-			glStencilFunc(NzOpenGL::RendererComparison[s_stencilCompare], s_stencilReference, s_stencilMask);
-			s_updateFlags &= ~Update_StencilFunc;
-		}
-
-		if (s_updateFlags & Update_StencilOp)
-		{
-			glStencilOp(NzOpenGL::StencilOperation[s_stencilFail], NzOpenGL::StencilOperation[s_stencilZFail], NzOpenGL::StencilOperation[s_stencilPass]);
-			s_updateFlags &= ~Update_StencilOp;
-		}
-
 		if (s_updateFlags & Update_VAO)
 		{
 			#if NAZARA_RENDERER_SAFE
@@ -1691,6 +1604,8 @@ bool NzRenderer::EnsureStateUpdate()
 			NzOpenGL::BindTexture(i, texture->GetType(), texture->GetOpenGLID());
 	}
 
+	NzOpenGL::ApplyStates(s_states);
+
 	return true;
 }