Renderer/RenderStates: Update RenderStates structure (preparing for renderer update)

Former-commit-id: 8839ceda70dfa0384e8da43205a208c89f1eb7bf [formerly f5434c9c44a52e02fdc6970e443cd7d3e9e99e6b]
Former-commit-id: 6a4846a2e2c8b60160598812ebd02da17a2f6947

include/Nazara/Graphics/Material.inl

@@ -53,7 +53,36 @@ namespace Nz
 	{
 		NazaraAssert(renderParameter <= RendererParameter_Max, "Renderer parameter out of enum");
 
-		m_states.parameters[renderParameter] = enable;
+		switch (renderParameter)
+		{
+			case RendererParameter_Blend:
+				m_states.blending = enable;
+				return;
+
+			case RendererParameter_ColorWrite:
+				m_states.colorWrite = enable;
+				return;
+
+			case RendererParameter_DepthBuffer:
+				m_states.depthBuffer = enable;
+				return;
+
+			case RendererParameter_DepthWrite:
+				m_states.depthWrite = enable;
+				return;
+
+			case RendererParameter_FaceCulling:
+				m_states.faceCulling = enable;
+				return;
+
+			case RendererParameter_ScissorTest:
+				m_states.scissorTest = enable;
+				return;
+
+			case RendererParameter_StencilTest:
+				m_states.stencilTest = enable;
+				return;
+		}
 	}
 
 	/*!
@@ -257,7 +286,7 @@ namespace Nz
 
 	inline FaceSide Material::GetFaceCulling() const
 	{
-		return m_states.faceCulling;
+		return m_states.cullingSide;
 	}
 
 	/*!
@@ -489,7 +518,32 @@ namespace Nz
 	{
 		NazaraAssert(parameter <= RendererParameter_Max, "Renderer parameter out of enum");
 
-		return m_states.parameters[parameter];
+		switch (parameter)
+		{
+			case RendererParameter_Blend:
+				return m_states.blending;
+
+			case RendererParameter_ColorWrite:
+				return m_states.colorWrite;
+
+			case RendererParameter_DepthBuffer:
+				return m_states.depthBuffer;
+
+			case RendererParameter_DepthWrite:
+				return m_states.depthWrite;
+
+			case RendererParameter_FaceCulling:
+				return m_states.faceCulling;
+
+			case RendererParameter_ScissorTest:
+				return m_states.scissorTest;
+
+			case RendererParameter_StencilTest:
+				return m_states.stencilTest;
+		}
+
+		NazaraInternalError("Unhandled renderer parameter: 0x" + String::Number(parameter, 16));
+		return false;
 	}
 
 	/*!
@@ -778,7 +832,7 @@ namespace Nz
 
 	inline void Material::SetFaceCulling(FaceSide faceSide)
 	{
-		m_states.faceCulling = faceSide;
+		m_states.cullingSide = faceSide;
 	}
 
 	/*!

include/Nazara/Renderer/RenderStates.hpp

@@ -8,37 +8,75 @@
 #define NAZARA_RENDERSTATES_HPP
 
 #include <Nazara/Utility/Enums.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 
 namespace Nz
 {
 	struct RenderStates
 	{
-		RenderStates();
+		BlendFunc dstBlend = BlendFunc_Zero;
-		RenderStates(const RenderStates& states);
+		BlendFunc srcBlend = BlendFunc_One;
-		~RenderStates() = default;
+		FaceFilling faceFilling = FaceFilling_Fill;
+		FaceSide cullingSide = FaceSide_Back;
+		RendererComparison depthFunc = RendererComparison_Less;
 
-		RenderStates& operator=(const RenderStates& states);
+		struct
-
-		struct Face
 		{
-			RendererComparison stencilCompare;
+			RendererComparison back  = RendererComparison_Always;
-			StencilOperation stencilFail;
+			RendererComparison front = RendererComparison_Always;
-			StencilOperation stencilPass;
+		} stencilCompare;
-			StencilOperation stencilZFail;
-			UInt32 stencilMask;
-			unsigned int stencilReference;
-		};
 
-		Face backFace;
+		struct
-		Face frontFace;
+		{
-		BlendFunc dstBlend;
+			UInt32 back  = 0xFFFFFFFF;
-		BlendFunc srcBlend;
+			UInt32 front = 0xFFFFFFFF;
-		FaceFilling faceFilling;
+		} stencilCompareMask;
-		FaceSide faceCulling;
+
-		RendererComparison depthFunc;
+		struct
-		bool parameters[RendererParameter_Max+1];
+		{
-		float lineWidth;
+			StencilOperation back  = StencilOperation_Keep;
-		float pointSize;
+			StencilOperation front = StencilOperation_Keep;
+		} stencilDepthFail;
+
+		struct
+		{
+			StencilOperation back  = StencilOperation_Keep;
+			StencilOperation front = StencilOperation_Keep;
+		} stencilFail;
+
+		struct
+		{
+			StencilOperation back  = StencilOperation_Keep;
+			StencilOperation front = StencilOperation_Keep;
+		} stencilPass;
+
+		struct
+		{
+			UInt32 back  = 0U;
+			UInt32 front = 0U;
+		} stencilReference;
+
+		struct
+		{
+			UInt32 back  = 0xFFFFFFFF;
+			UInt32 front = 0xFFFFFFFF;
+		} stencilWriteMask;
+
+		bool blending    = false;
+		bool colorWrite  = true;
+		bool depthBuffer = false;
+		bool depthWrite  = true;
+		bool faceCulling = false;
+		bool scissorTest = false;
+		bool stencilTest = false;
+
+		float lineWidth = 1.f;
+		float pointSize = 1.f;
+	};
+
+	struct RenderPipeline : RenderStates
+	{
+		ShaderConstRef shader;
 	};
 }
 

include/Nazara/Renderer/RenderStates.inl

@@ -2,52 +2,12 @@
 // This file is part of the "Nazara Engine - Renderer module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
+#include <Nazara/Renderer/RenderStates.hpp>
 #include <cstring>
 #include <Nazara/Renderer/Debug.hpp>
 
 namespace Nz
 {
-	inline RenderStates::RenderStates() :
-	dstBlend(BlendFunc_Zero),
-	srcBlend(BlendFunc_One),
-	faceFilling(FaceFilling_Fill),
-	faceCulling(FaceSide_Back),
-	depthFunc(RendererComparison_Less),
-	lineWidth(1.f),
-	pointSize(1.f)
-	{
-		parameters[RendererParameter_Blend] = false;
-		parameters[RendererParameter_ColorWrite] = true;
-		parameters[RendererParameter_DepthBuffer] = false;
-		parameters[RendererParameter_DepthWrite] = true;
-		parameters[RendererParameter_FaceCulling] = false;
-		parameters[RendererParameter_ScissorTest] = false;
-		parameters[RendererParameter_StencilTest] = false;
-
-		for (unsigned int i = 0; i < 2; ++i)
-		{
-			Face& face = (i == 0) ? backFace : frontFace;
-
-			face.stencilCompare = RendererComparison_Always;
-			face.stencilFail = StencilOperation_Keep;
-			face.stencilMask = 0xFFFFFFFF;
-			face.stencilPass = StencilOperation_Keep;
-			face.stencilReference = 0;
-			face.stencilZFail = StencilOperation_Keep;
-		}
-	}
-
-	inline RenderStates::RenderStates(const RenderStates& states)
-	{
-		std::memcpy(this, &states, sizeof(RenderStates));
-	}
-
-	inline RenderStates& RenderStates::operator=(const RenderStates& states)
-	{
-		std::memcpy(this, &states, sizeof(RenderStates));
-
-		return *this;
-	}
 }
 
 #include <Nazara/Renderer/DebugOff.hpp>

src/Nazara/Graphics/ColorBackground.cpp

@@ -19,11 +19,11 @@ namespace Nz
 		RenderStates BuildRenderStates()
 		{
 			RenderStates states;
+			states.cullingSide = FaceSide_Back;
 			states.depthFunc = RendererComparison_Equal;
-			states.faceCulling = FaceSide_Back;
+			states.depthBuffer = true;
-			states.parameters[RendererParameter_DepthBuffer] = true;
+			states.depthWrite = false;
-			states.parameters[RendererParameter_DepthWrite] = false;
+			states.faceCulling = true;
-			states.parameters[RendererParameter_FaceCulling] = true;
 
 			return states;
 		}

src/Nazara/Graphics/DeferredBloomPass.cpp

@@ -32,7 +32,7 @@ namespace Nz
 
 		m_bloomBrightShader = ShaderLibrary::Get("DeferredBloomBright");
 		m_bloomFinalShader = ShaderLibrary::Get("DeferredBloomFinal");
-		m_bloomStates.parameters[RendererParameter_DepthBuffer] = false;
+		m_bloomStates.depthBuffer = false;
 		m_gaussianBlurShader = ShaderLibrary::Get("DeferredGaussianBlur");
 		m_gaussianBlurShaderFilterLocation = m_gaussianBlurShader->GetUniformLocation("Filter");
 

src/Nazara/Graphics/DeferredDOFPass.cpp

@@ -127,7 +127,7 @@ namespace Nz
 		m_pointSampler.SetFilterMode(SamplerFilter_Nearest);
 		m_pointSampler.SetWrapMode(SamplerWrap_Clamp);
 
-		m_states.parameters[RendererParameter_DepthBuffer] = false;
+		m_states.depthBuffer = false;
 	}
 
 	DeferredDOFPass::~DeferredDOFPass() = default;

src/Nazara/Graphics/DeferredFXAAPass.cpp

@@ -28,7 +28,7 @@ namespace Nz
 		m_pointSampler.SetFilterMode(SamplerFilter_Nearest);
 		m_pointSampler.SetWrapMode(SamplerWrap_Clamp);
 
-		m_states.parameters[RendererParameter_DepthBuffer] = false;
+		m_states.depthBuffer = false;
 	}
 
 	DeferredFXAAPass::~DeferredFXAAPass() = default;

src/Nazara/Graphics/DeferredFinalPass.cpp

@@ -26,7 +26,7 @@ namespace Nz
 		m_pointSampler.SetFilterMode(SamplerFilter_Nearest);
 		m_pointSampler.SetWrapMode(SamplerWrap_Clamp);
 
-		m_states.parameters[RendererParameter_DepthBuffer] = false;
+		m_states.depthBuffer = false;
 
 		m_uberShader = UberShaderLibrary::Get("Basic");
 

src/Nazara/Graphics/DeferredFogPass.cpp

@@ -141,7 +141,7 @@ namespace Nz
 		m_shader = BuildFogShader();
 		m_shaderEyePositionLocation = m_shader->GetUniformLocation("EyePosition");
 
-		m_states.parameters[RendererParameter_DepthBuffer] = false;
+		m_states.depthBuffer = false;
 	}
 
 	DeferredFogPass::~DeferredFogPass() = default;

src/Nazara/Graphics/DeferredGeometryPass.cpp

@@ -31,12 +31,12 @@ namespace Nz
 	DeferredGeometryPass::DeferredGeometryPass()
 	{
 		m_clearShader = ShaderLibrary::Get("DeferredGBufferClear");
-		m_clearStates.parameters[RendererParameter_DepthBuffer] = true;
+		m_clearStates.depthBuffer = true;
-		m_clearStates.parameters[RendererParameter_FaceCulling] = true;
+		m_clearStates.faceCulling = true;
-		m_clearStates.parameters[RendererParameter_StencilTest] = true;
+		m_clearStates.stencilTest = true;
 		m_clearStates.depthFunc = RendererComparison_Always;
-		m_clearStates.frontFace.stencilCompare = RendererComparison_Always;
+		m_clearStates.stencilCompare.front = RendererComparison_Always;
-		m_clearStates.frontFace.stencilPass = StencilOperation_Zero;
+		m_clearStates.stencilPass.front = StencilOperation_Zero;
 	}
 
 	DeferredGeometryPass::~DeferredGeometryPass() = default;

src/Nazara/Graphics/DeferredPhongLightingPass.cpp

@@ -120,9 +120,9 @@ namespace Nz
 		RenderStates lightStates;
 		lightStates.dstBlend = BlendFunc_One;
 		lightStates.srcBlend = BlendFunc_One;
-		lightStates.parameters[RendererParameter_Blend] = true;
+		lightStates.blending = true;
-		lightStates.parameters[RendererParameter_DepthBuffer] = false;
+		lightStates.depthBuffer = false;
-		lightStates.parameters[RendererParameter_DepthWrite] = false;
+		lightStates.depthWrite = false;
 
 		// Directional lights
 		if (!m_renderQueue->directionalLights.empty())
@@ -146,18 +146,18 @@ namespace Nz
 		if (!m_renderQueue->pointLights.empty() || !m_renderQueue->spotLights.empty())
 		{
 			// http://www.altdevblogaday.com/2011/08/08/stencil-buffer-optimisation-for-deferred-lights/
-			lightStates.parameters[RendererParameter_StencilTest] = true;
+			lightStates.cullingSide = FaceSide_Front;
-			lightStates.faceCulling = FaceSide_Front;
+			lightStates.stencilTest = true;
-			lightStates.backFace.stencilMask = 0xFF;
+			lightStates.stencilDepthFail.back = StencilOperation_Invert;
-			lightStates.backFace.stencilReference = 0;
+			lightStates.stencilDepthFail.front = StencilOperation_Invert;
-			lightStates.backFace.stencilFail = StencilOperation_Keep;
+			lightStates.stencilFail.back = StencilOperation_Keep;
-			lightStates.backFace.stencilPass = StencilOperation_Keep;
+			lightStates.stencilFail.front = StencilOperation_Keep;
-			lightStates.backFace.stencilZFail = StencilOperation_Invert;
+			lightStates.stencilPass.back = StencilOperation_Keep;
-			lightStates.frontFace.stencilMask = 0xFF;
+			lightStates.stencilPass.front = StencilOperation_Keep;
-			lightStates.frontFace.stencilReference = 0;
+			lightStates.stencilReference.back = 0;
-			lightStates.frontFace.stencilFail = StencilOperation_Keep;
+			lightStates.stencilReference.front = 0;
-			lightStates.frontFace.stencilPass = StencilOperation_Keep;
+			lightStates.stencilWriteMask.back = 0xFF;
-			lightStates.frontFace.stencilZFail = StencilOperation_Invert;
+			lightStates.stencilWriteMask.front = 0xFF;
 
 			Renderer::SetRenderStates(lightStates);
 

src/Nazara/Graphics/Material.cpp

@@ -252,41 +252,41 @@ namespace Nz
 
 		// Stencil
 		if (matData.GetIntegerParameter(MaterialData::StencilCompare, &iValue))
-			m_states.frontFace.stencilCompare = static_cast<RendererComparison>(iValue);
+			m_states.stencilCompare.front = static_cast<RendererComparison>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::StencilFail, &iValue))
-			m_states.frontFace.stencilFail = static_cast<StencilOperation>(iValue);
+			m_states.stencilFail.front = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::StencilPass, &iValue))
-			m_states.frontFace.stencilPass = static_cast<StencilOperation>(iValue);
+			m_states.stencilPass.front = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::StencilZFail, &iValue))
-			m_states.frontFace.stencilZFail = static_cast<StencilOperation>(iValue);
+			m_states.stencilDepthFail.front = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::StencilMask, &iValue))
-			m_states.frontFace.stencilMask = static_cast<UInt32>(iValue);
+			m_states.stencilWriteMask.front = static_cast<UInt32>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::StencilReference, &iValue))
-			m_states.frontFace.stencilReference = static_cast<unsigned int>(iValue);
+			m_states.stencilReference.front = static_cast<unsigned int>(iValue);
 
 		// Stencil (back)
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilCompare, &iValue))
-			m_states.backFace.stencilCompare = static_cast<RendererComparison>(iValue);
+			m_states.stencilCompare.back = static_cast<RendererComparison>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilFail, &iValue))
-			m_states.backFace.stencilFail = static_cast<StencilOperation>(iValue);
+			m_states.stencilFail.back = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilPass, &iValue))
-			m_states.backFace.stencilPass = static_cast<StencilOperation>(iValue);
+			m_states.stencilPass.back = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilZFail, &iValue))
-			m_states.backFace.stencilZFail = static_cast<StencilOperation>(iValue);
+			m_states.stencilDepthFail.back = static_cast<StencilOperation>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilMask, &iValue))
-			m_states.backFace.stencilMask = static_cast<UInt32>(iValue);
+			m_states.stencilWriteMask.back = static_cast<UInt32>(iValue);
 
 		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilReference, &iValue))
-			m_states.backFace.stencilReference = static_cast<unsigned int>(iValue);
+			m_states.stencilReference.back = static_cast<unsigned int>(iValue);
 
 		// Textures
 		if (matParams.loadAlphaMap && matData.GetStringParameter(MaterialData::AlphaTexturePath, &path))
@@ -332,13 +332,13 @@ namespace Nz
 		matData->SetParameter(MaterialData::Transform, IsTransformEnabled());
 
 		// RendererParameter
-		matData->SetParameter(MaterialData::Blending, GetRenderStates().parameters[RendererParameter_Blend]);
+		matData->SetParameter(MaterialData::Blending, GetRenderStates().blending);
-		matData->SetParameter(MaterialData::ColorWrite, GetRenderStates().parameters[RendererParameter_ColorWrite]);
+		matData->SetParameter(MaterialData::ColorWrite, GetRenderStates().colorWrite);
-		matData->SetParameter(MaterialData::DepthBuffer, GetRenderStates().parameters[RendererParameter_DepthBuffer]);
+		matData->SetParameter(MaterialData::DepthBuffer, GetRenderStates().depthBuffer);
-		matData->SetParameter(MaterialData::DepthWrite, GetRenderStates().parameters[RendererParameter_DepthWrite]);
+		matData->SetParameter(MaterialData::DepthWrite, GetRenderStates().depthWrite);
-		matData->SetParameter(MaterialData::FaceCulling, GetRenderStates().parameters[RendererParameter_FaceCulling]);
+		matData->SetParameter(MaterialData::FaceCulling, GetRenderStates().faceCulling);
-		matData->SetParameter(MaterialData::ScissorTest, GetRenderStates().parameters[RendererParameter_ScissorTest]);
+		matData->SetParameter(MaterialData::ScissorTest, GetRenderStates().scissorTest);
-		matData->SetParameter(MaterialData::StencilTest, GetRenderStates().parameters[RendererParameter_StencilTest]);
+		matData->SetParameter(MaterialData::StencilTest, GetRenderStates().stencilTest);
 
 		// Samplers
 		matData->SetParameter(MaterialData::DiffuseAnisotropyLevel, int(GetDiffuseSampler().GetAnisotropicLevel()));
@@ -350,20 +350,20 @@ namespace Nz
 		matData->SetParameter(MaterialData::SpecularWrap, int(GetSpecularSampler().GetWrapMode()));
 
 		// Stencil
-		matData->SetParameter(MaterialData::StencilCompare, int(GetRenderStates().frontFace.stencilCompare));
+		matData->SetParameter(MaterialData::StencilCompare, int(GetRenderStates().stencilCompare.front));
-		matData->SetParameter(MaterialData::StencilFail, int(GetRenderStates().frontFace.stencilFail));
+		matData->SetParameter(MaterialData::StencilFail, int(GetRenderStates().stencilFail.front));
-		matData->SetParameter(MaterialData::StencilPass, int(GetRenderStates().frontFace.stencilPass));
+		matData->SetParameter(MaterialData::StencilPass, int(GetRenderStates().stencilPass.front));
-		matData->SetParameter(MaterialData::StencilZFail, int(GetRenderStates().frontFace.stencilZFail));
+		matData->SetParameter(MaterialData::StencilZFail, int(GetRenderStates().stencilDepthFail.front));
-		matData->SetParameter(MaterialData::StencilMask, int(GetRenderStates().frontFace.stencilMask));
+		matData->SetParameter(MaterialData::StencilMask, int(GetRenderStates().stencilWriteMask.front));
-		matData->SetParameter(MaterialData::StencilReference, int(GetRenderStates().frontFace.stencilReference));
+		matData->SetParameter(MaterialData::StencilReference, int(GetRenderStates().stencilReference.front));
 
 		// Stencil (back)
-		matData->SetParameter(MaterialData::BackFaceStencilCompare, int(GetRenderStates().backFace.stencilCompare));
+		matData->SetParameter(MaterialData::BackFaceStencilCompare, int(GetRenderStates().stencilCompare.back));
-		matData->SetParameter(MaterialData::BackFaceStencilFail, int(GetRenderStates().backFace.stencilFail));
+		matData->SetParameter(MaterialData::BackFaceStencilFail, int(GetRenderStates().stencilFail.back));
-		matData->SetParameter(MaterialData::BackFaceStencilPass, int(GetRenderStates().backFace.stencilPass));
+		matData->SetParameter(MaterialData::BackFaceStencilPass, int(GetRenderStates().stencilPass.back));
-		matData->SetParameter(MaterialData::BackFaceStencilZFail, int(GetRenderStates().backFace.stencilZFail));
+		matData->SetParameter(MaterialData::BackFaceStencilZFail, int(GetRenderStates().stencilDepthFail.back));
-		matData->SetParameter(MaterialData::BackFaceStencilMask, int(GetRenderStates().backFace.stencilMask));
+		matData->SetParameter(MaterialData::BackFaceStencilMask, int(GetRenderStates().stencilWriteMask.back));
-		matData->SetParameter(MaterialData::BackFaceStencilReference, int(GetRenderStates().backFace.stencilReference));
+		matData->SetParameter(MaterialData::BackFaceStencilReference, int(GetRenderStates().stencilReference.back));
 
 		// Textures
 		if (HasAlphaMap())
@@ -441,8 +441,8 @@ namespace Nz
 		m_specularColor = Color::White;
 		m_specularSampler = TextureSampler();
 		m_states = RenderStates();
-		m_states.parameters[RendererParameter_DepthBuffer] = true;
+		m_states.depthBuffer = true;
-		m_states.parameters[RendererParameter_FaceCulling] = true;
+		m_states.faceCulling = true;
 		m_transformEnabled = true;
 
 		SetShader("Basic");

src/Nazara/Graphics/SkyboxBackground.cpp

@@ -181,10 +181,10 @@ namespace Nz
 
 			// Renderstates
 			s_renderStates.depthFunc = RendererComparison_Equal;
-			s_renderStates.faceCulling = FaceSide_Front;
+			s_renderStates.cullingSide = FaceSide_Front;
-			s_renderStates.parameters[RendererParameter_DepthBuffer] = true;
+			s_renderStates.depthBuffer = true;
-			s_renderStates.parameters[RendererParameter_DepthWrite] = false;
+			s_renderStates.depthWrite = false;
-			s_renderStates.parameters[RendererParameter_FaceCulling] = true;
+			s_renderStates.faceCulling = true;
 
 			// Exception-free zone
 			s_indexBuffer = std::move(indexBuffer);

src/Nazara/Graphics/TextureBackground.cpp

@@ -20,10 +20,10 @@ namespace Nz
 		{
 			RenderStates states;
 			states.depthFunc = RendererComparison_Equal;
-			states.faceCulling = FaceSide_Back;
+			states.cullingSide = FaceSide_Back;
-			states.parameters[RendererParameter_DepthBuffer] = true;
+			states.depthBuffer = true;
-			states.parameters[RendererParameter_DepthWrite] = false;
+			states.depthWrite = false;
-			states.parameters[RendererParameter_FaceCulling] = true;
+			states.faceCulling = true;
 
 			return states;
 		}

src/Nazara/Renderer/DebugDrawer.cpp

@@ -652,7 +652,7 @@ namespace Nz
 
 	void DebugDrawer::EnableDepthBuffer(bool depthBuffer)
 	{
-		s_renderStates.parameters[RendererParameter_DepthBuffer] = depthBuffer;
+		s_renderStates.depthBuffer = depthBuffer;
 	}
 
 	float DebugDrawer::GetLineWidth()
@@ -698,7 +698,7 @@ namespace Nz
 			}
 
 			s_primaryColor = Color::Red;
-			s_renderStates.parameters[RendererParameter_DepthBuffer] = true;
+			s_renderStates.depthBuffer = true;
 			s_secondaryColor = Color::Green;
 
 			s_initialized = true;
@@ -709,7 +709,7 @@ namespace Nz
 
 	bool DebugDrawer::IsDepthBufferEnabled()
 	{
-		return s_renderStates.parameters[RendererParameter_DepthBuffer];
+		return s_renderStates.depthBuffer;
 	}
 
 	void DebugDrawer::SetLineWidth(float width)

src/Nazara/Renderer/OpenGL.cpp

@@ -158,7 +158,7 @@ namespace Nz
 		RenderStates& currentRenderStates = s_contextStates->renderStates;
 
 		// Les fonctions de blend n'a aucun intérêt sans blending
-		if (states.parameters[RendererParameter_Blend])
+		if (states.blending)
 		{
 			if (currentRenderStates.dstBlend != states.dstBlend ||
 				currentRenderStates.srcBlend != states.srcBlend)
@@ -169,7 +169,7 @@ namespace Nz
 			}
 		}
 
-		if (states.parameters[RendererParameter_DepthBuffer])
+		if (states.depthBuffer)
 		{
 			// La comparaison de profondeur n'a aucun intérêt sans depth buffer
 			if (currentRenderStates.depthFunc != states.depthFunc)
@@ -179,20 +179,20 @@ namespace Nz
 			}
 
 			// Le DepthWrite n'a aucune importance si le DepthBuffer est désactivé
-			if (currentRenderStates.parameters[RendererParameter_DepthWrite] != states.parameters[RendererParameter_DepthWrite])
+			if (currentRenderStates.depthWrite != states.depthWrite)
 			{
-				glDepthMask((states.parameters[RendererParameter_DepthWrite]) ? GL_TRUE : GL_FALSE);
+				glDepthMask((states.depthWrite) ? GL_TRUE : GL_FALSE);
-				currentRenderStates.parameters[RendererParameter_DepthWrite] = states.parameters[RendererParameter_DepthWrite];
+				currentRenderStates.depthWrite = states.depthWrite;
 			}
 		}
 
 		// Inutile de changer le mode de face culling s'il n'est pas actif
-		if (states.parameters[RendererParameter_FaceCulling])
+		if (states.faceCulling)
 		{
-			if (currentRenderStates.faceCulling != states.faceCulling)
+			if (currentRenderStates.cullingSide != states.cullingSide)
 			{
-				glCullFace(FaceSide[states.faceCulling]);
+				glCullFace(FaceSide[states.cullingSide]);
-				currentRenderStates.faceCulling = states.faceCulling;
+				currentRenderStates.cullingSide = states.cullingSide;
 			}
 		}
 
@@ -203,33 +203,46 @@ namespace Nz
 		}
 
 		// Ici encore, ça ne sert à rien de se soucier des fonctions de stencil sans qu'il soit activé
-		if (states.parameters[RendererParameter_StencilTest])
+		if (states.stencilTest)
 		{
-			for (unsigned int i = 0; i < 2; ++i)
+			if (currentRenderStates.stencilCompare.back != states.stencilCompare.back ||
+				currentRenderStates.stencilReference.back != states.stencilReference.back ||
+				currentRenderStates.stencilWriteMask.back != states.stencilWriteMask.back)
 			{
-				GLenum face = (i == 0) ? GL_BACK : GL_FRONT;
+				glStencilFuncSeparate(GL_BACK, RendererComparison[states.stencilCompare.back], states.stencilReference.back, states.stencilWriteMask.back);
-				const RenderStates::Face& srcStates = (i == 0) ? states.backFace : states.frontFace;
+				currentRenderStates.stencilCompare.back = states.stencilCompare.back;
-				RenderStates::Face& dstStates = (i == 0) ? currentRenderStates.backFace : currentRenderStates.frontFace;
+				currentRenderStates.stencilReference.back = states.stencilReference.back;
+				currentRenderStates.stencilWriteMask.back = states.stencilWriteMask.back;
+			}
 
-				if (dstStates.stencilCompare != srcStates.stencilCompare ||
+			if (currentRenderStates.stencilDepthFail.back != states.stencilDepthFail.back ||
-					dstStates.stencilMask != srcStates.stencilMask ||
+				currentRenderStates.stencilFail.back != states.stencilFail.back ||
-					dstStates.stencilReference != srcStates.stencilReference)
+				currentRenderStates.stencilPass.back != states.stencilPass.back)
-				{
+			{
-					glStencilFuncSeparate(face, RendererComparison[srcStates.stencilCompare], srcStates.stencilReference, srcStates.stencilMask);
+				glStencilOpSeparate(GL_BACK, StencilOperation[states.stencilFail.back], StencilOperation[states.stencilDepthFail.back], StencilOperation[states.stencilPass.back]);
-					dstStates.stencilCompare = srcStates.stencilCompare;
+				currentRenderStates.stencilDepthFail.back = states.stencilDepthFail.back;
-					dstStates.stencilMask = srcStates.stencilMask;
+				currentRenderStates.stencilFail.back = states.stencilFail.back;
-					dstStates.stencilReference = srcStates.stencilReference;
+				currentRenderStates.stencilPass.back = states.stencilPass.back;
-				}
+			}
 
-				if (dstStates.stencilFail != srcStates.stencilFail ||
+			if (currentRenderStates.stencilCompare.front != states.stencilCompare.front ||
-					dstStates.stencilPass != srcStates.stencilPass ||
+				currentRenderStates.stencilReference.front != states.stencilReference.front ||
-					dstStates.stencilZFail != srcStates.stencilZFail)
+				currentRenderStates.stencilWriteMask.front != states.stencilWriteMask.front)
-				{
+			{
-					glStencilOpSeparate(face, StencilOperation[srcStates.stencilFail], StencilOperation[srcStates.stencilZFail], StencilOperation[srcStates.stencilPass]);
+				glStencilFuncSeparate(GL_FRONT, RendererComparison[states.stencilCompare.front], states.stencilReference.front, states.stencilWriteMask.front);
-					dstStates.stencilFail = srcStates.stencilFail;
+				currentRenderStates.stencilCompare.front = states.stencilCompare.front;
-					dstStates.stencilPass = srcStates.stencilPass;
+				currentRenderStates.stencilReference.front = states.stencilReference.front;
-					dstStates.stencilZFail = srcStates.stencilZFail;
+				currentRenderStates.stencilWriteMask.front = states.stencilWriteMask.front;
-				}
+			}
+
+			if (currentRenderStates.stencilDepthFail.front != states.stencilDepthFail.front ||
+				currentRenderStates.stencilFail.front != states.stencilFail.front ||
+				currentRenderStates.stencilPass.front != states.stencilPass.front)
+			{
+				glStencilOpSeparate(GL_FRONT, StencilOperation[states.stencilFail.front], StencilOperation[states.stencilDepthFail.front], StencilOperation[states.stencilPass.front]);
+				currentRenderStates.stencilDepthFail.front = states.stencilDepthFail.front;
+				currentRenderStates.stencilFail.front = states.stencilFail.front;
+				currentRenderStates.stencilPass.front = states.stencilPass.front;
 			}
 		}
 
@@ -246,62 +259,62 @@ namespace Nz
 		}
 
 		// Paramètres de rendu
-		if (currentRenderStates.parameters[RendererParameter_Blend] != states.parameters[RendererParameter_Blend])
+		if (currentRenderStates.blending != states.blending)
 		{
-			if (states.parameters[RendererParameter_Blend])
+			if (states.blending)
 				glEnable(GL_BLEND);
 			else
 				glDisable(GL_BLEND);
 
-			currentRenderStates.parameters[RendererParameter_Blend] = states.parameters[RendererParameter_Blend];
+			currentRenderStates.blending = states.blending;
 		}
 
-		if (currentRenderStates.parameters[RendererParameter_ColorWrite] != states.parameters[RendererParameter_ColorWrite])
+		if (currentRenderStates.colorWrite != states.colorWrite)
 		{
-			GLboolean param = (states.parameters[RendererParameter_ColorWrite]) ? GL_TRUE : GL_FALSE;
+			GLboolean param = (states.colorWrite) ? GL_TRUE : GL_FALSE;
 			glColorMask(param, param, param, param);
 
-			currentRenderStates.parameters[RendererParameter_ColorWrite] = states.parameters[RendererParameter_ColorWrite];
+			currentRenderStates.colorWrite = states.colorWrite;
 		}
 
-		if (currentRenderStates.parameters[RendererParameter_DepthBuffer] != states.parameters[RendererParameter_DepthBuffer])
+		if (currentRenderStates.depthBuffer != states.depthBuffer)
 		{
-			if (states.parameters[RendererParameter_DepthBuffer])
+			if (states.depthBuffer)
 				glEnable(GL_DEPTH_TEST);
 			else
 				glDisable(GL_DEPTH_TEST);
 
-			currentRenderStates.parameters[RendererParameter_DepthBuffer] = states.parameters[RendererParameter_DepthBuffer];
+			currentRenderStates.depthBuffer = states.depthBuffer;
 		}
 
-		if (currentRenderStates.parameters[RendererParameter_FaceCulling] != states.parameters[RendererParameter_FaceCulling])
+		if (currentRenderStates.faceCulling != states.faceCulling)
 		{
-			if (states.parameters[RendererParameter_FaceCulling])
+			if (states.faceCulling)
 				glEnable(GL_CULL_FACE);
 			else
 				glDisable(GL_CULL_FACE);
 
-			currentRenderStates.parameters[RendererParameter_FaceCulling] = states.parameters[RendererParameter_FaceCulling];
+			currentRenderStates.faceCulling = states.faceCulling;
 		}
 
-		if (currentRenderStates.parameters[RendererParameter_ScissorTest] != states.parameters[RendererParameter_ScissorTest])
+		if (currentRenderStates.scissorTest != states.scissorTest)
 		{
-			if (states.parameters[RendererParameter_ScissorTest])
+			if (states.scissorTest)
 				glEnable(GL_SCISSOR_TEST);
 			else
 				glDisable(GL_SCISSOR_TEST);
 
-			currentRenderStates.parameters[RendererParameter_ScissorTest] = states.parameters[RendererParameter_ScissorTest];
+			currentRenderStates.scissorTest = states.scissorTest;
 		}
 
-		if (currentRenderStates.parameters[RendererParameter_StencilTest] != states.parameters[RendererParameter_StencilTest])
+		if (currentRenderStates.stencilTest != states.stencilTest)
 		{
-			if (states.parameters[RendererParameter_StencilTest])
+			if (states.stencilTest)
 				glEnable(GL_STENCIL_TEST);
 			else
 				glDisable(GL_STENCIL_TEST);
 
-			currentRenderStates.parameters[RendererParameter_StencilTest] = states.parameters[RendererParameter_StencilTest];
+			currentRenderStates.stencilTest = states.stencilTest;
 		}
 	}
 

src/Nazara/Renderer/Renderer.cpp

@@ -396,7 +396,38 @@ namespace Nz
 		}
 		#endif
 
-		s_states.parameters[parameter] = enable;
+		switch (parameter)
+		{
+			case RendererParameter_Blend:
+				s_states.blending = enable;
+				return;
+
+			case RendererParameter_ColorWrite:
+				s_states.colorWrite = enable;
+				return;
+
+			case RendererParameter_DepthBuffer:
+				s_states.depthBuffer = enable;
+				return;
+
+			case RendererParameter_DepthWrite:
+				s_states.depthWrite = enable;
+				return;
+
+			case RendererParameter_FaceCulling:
+				s_states.faceCulling = enable;
+				return;
+
+			case RendererParameter_ScissorTest:
+				s_states.scissorTest = enable;
+				return;
+
+			case RendererParameter_StencilTest:
+				s_states.stencilTest = enable;
+				return;
+		}
+
+		NazaraInternalError("Unhandled renderer parameter: 0x" + String::Number(parameter, 16));
 	}
 
 	void Renderer::EndCondition()
@@ -762,7 +793,32 @@ namespace Nz
 		}
 		#endif
 
-		return s_states.parameters[parameter];
+		switch (parameter)
+		{
+			case RendererParameter_Blend:
+				return s_states.blending;
+
+			case RendererParameter_ColorWrite:
+				return s_states.colorWrite;
+
+			case RendererParameter_DepthBuffer:
+				return s_states.depthBuffer;
+
+			case RendererParameter_DepthWrite:
+				return s_states.depthWrite;
+
+			case RendererParameter_FaceCulling:
+				return s_states.faceCulling;
+
+			case RendererParameter_ScissorTest:
+				return s_states.scissorTest;
+
+			case RendererParameter_StencilTest:
+				return s_states.stencilTest;
+		}
+
+		NazaraInternalError("Unhandled renderer parameter: 0x" + String::Number(parameter, 16));
+		return false;
 	}
 
 	bool Renderer::IsInitialized()
@@ -865,7 +921,7 @@ namespace Nz
 		}
 		#endif
 
-		s_states.faceCulling = faceSide;
+		s_states.cullingSide = faceSide;
 	}
 
 	void Renderer::SetFaceFilling(FaceFilling fillingMode)
@@ -1042,16 +1098,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilCompare = compareFunc;
+				s_states.stencilCompare.back = compareFunc;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilCompare = compareFunc;
+				s_states.stencilCompare.front = compareFunc;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilCompare = compareFunc;
+				s_states.stencilCompare.back = compareFunc;
-				s_states.frontFace.stencilCompare = compareFunc;
+				s_states.stencilCompare.front = compareFunc;
 				break;
 		}
 	}
@@ -1075,16 +1131,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilFail = failOperation;
+				s_states.stencilFail.back = failOperation;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilFail = failOperation;
+				s_states.stencilFail.front = failOperation;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilFail = failOperation;
+				s_states.stencilFail.back = failOperation;
-				s_states.frontFace.stencilFail = failOperation;
+				s_states.stencilFail.front = failOperation;
 				break;
 		}
 	}
@@ -1102,16 +1158,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilMask = mask;
+				s_states.stencilWriteMask.back = mask;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilMask = mask;
+				s_states.stencilWriteMask.front = mask;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilMask = mask;
+				s_states.stencilWriteMask.back = mask;
-				s_states.frontFace.stencilMask = mask;
+				s_states.stencilWriteMask.front = mask;
 				break;
 		}
 	}
@@ -1135,16 +1191,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilPass = passOperation;
+				s_states.stencilPass.back = passOperation;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilPass = passOperation;
+				s_states.stencilPass.front = passOperation;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilPass = passOperation;
+				s_states.stencilPass.back = passOperation;
-				s_states.frontFace.stencilPass = passOperation;
+				s_states.stencilPass.front = passOperation;
 				break;
 		}
 	}
@@ -1162,16 +1218,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilReference = refValue;
+				s_states.stencilReference.back = refValue;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilReference = refValue;
+				s_states.stencilReference.front = refValue;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilReference = refValue;
+				s_states.stencilReference.back = refValue;
-				s_states.frontFace.stencilReference = refValue;
+				s_states.stencilReference.front = refValue;
 				break;
 		}
 	}
@@ -1195,16 +1251,16 @@ namespace Nz
 		switch (faceSide)
 		{
 			case FaceSide_Back:
-				s_states.backFace.stencilZFail = zfailOperation;
+				s_states.stencilDepthFail.back = zfailOperation;
 				break;
 
 			case FaceSide_Front:
-				s_states.frontFace.stencilZFail = zfailOperation;
+				s_states.stencilDepthFail.front = zfailOperation;
 				break;
 
 			case FaceSide_FrontAndBack:
-				s_states.backFace.stencilZFail = zfailOperation;
+				s_states.stencilDepthFail.back = zfailOperation;
-				s_states.frontFace.stencilZFail = zfailOperation;
+				s_states.stencilDepthFail.front = zfailOperation;
 				break;
 		}
 	}