diff --git a/include/Nazara/Graphics/Material.inl b/include/Nazara/Graphics/Material.inl index 1e59e6157..6d5315640 100644 --- a/include/Nazara/Graphics/Material.inl +++ b/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; } /*! diff --git a/include/Nazara/Renderer/RenderStates.hpp b/include/Nazara/Renderer/RenderStates.hpp index 4040bec55..a885b2a7d 100644 --- a/include/Nazara/Renderer/RenderStates.hpp +++ b/include/Nazara/Renderer/RenderStates.hpp @@ -8,37 +8,75 @@ #define NAZARA_RENDERSTATES_HPP #include +#include namespace Nz { struct RenderStates { - RenderStates(); - RenderStates(const RenderStates& states); - ~RenderStates() = default; + BlendFunc dstBlend = BlendFunc_Zero; + BlendFunc srcBlend = BlendFunc_One; + FaceFilling faceFilling = FaceFilling_Fill; + FaceSide cullingSide = FaceSide_Back; + RendererComparison depthFunc = RendererComparison_Less; - RenderStates& operator=(const RenderStates& states); - - struct Face + struct { - RendererComparison stencilCompare; - StencilOperation stencilFail; - StencilOperation stencilPass; - StencilOperation stencilZFail; - UInt32 stencilMask; - unsigned int stencilReference; - }; + RendererComparison back = RendererComparison_Always; + RendererComparison front = RendererComparison_Always; + } stencilCompare; - Face backFace; - Face frontFace; - BlendFunc dstBlend; - BlendFunc srcBlend; - FaceFilling faceFilling; - FaceSide faceCulling; - RendererComparison depthFunc; - bool parameters[RendererParameter_Max+1]; - float lineWidth; - float pointSize; + struct + { + UInt32 back = 0xFFFFFFFF; + UInt32 front = 0xFFFFFFFF; + } stencilCompareMask; + + struct + { + StencilOperation back = StencilOperation_Keep; + 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; }; } diff --git a/include/Nazara/Renderer/RenderStates.inl b/include/Nazara/Renderer/RenderStates.inl index 6840d3b5f..1f7564166 100644 --- a/include/Nazara/Renderer/RenderStates.inl +++ b/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 #include #include 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 diff --git a/src/Nazara/Graphics/ColorBackground.cpp b/src/Nazara/Graphics/ColorBackground.cpp index 33c282390..dcacb1a46 100644 --- a/src/Nazara/Graphics/ColorBackground.cpp +++ b/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.parameters[RendererParameter_DepthBuffer] = true; - states.parameters[RendererParameter_DepthWrite] = false; - states.parameters[RendererParameter_FaceCulling] = true; + states.depthBuffer = true; + states.depthWrite = false; + states.faceCulling = true; return states; } diff --git a/src/Nazara/Graphics/DeferredBloomPass.cpp b/src/Nazara/Graphics/DeferredBloomPass.cpp index c902c7615..9cf39831a 100644 --- a/src/Nazara/Graphics/DeferredBloomPass.cpp +++ b/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"); diff --git a/src/Nazara/Graphics/DeferredDOFPass.cpp b/src/Nazara/Graphics/DeferredDOFPass.cpp index 63df2c400..b39085400 100644 --- a/src/Nazara/Graphics/DeferredDOFPass.cpp +++ b/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; diff --git a/src/Nazara/Graphics/DeferredFXAAPass.cpp b/src/Nazara/Graphics/DeferredFXAAPass.cpp index 3f1e9395a..d4ba72ddf 100644 --- a/src/Nazara/Graphics/DeferredFXAAPass.cpp +++ b/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; diff --git a/src/Nazara/Graphics/DeferredFinalPass.cpp b/src/Nazara/Graphics/DeferredFinalPass.cpp index 091c95af6..c4ab348eb 100644 --- a/src/Nazara/Graphics/DeferredFinalPass.cpp +++ b/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"); diff --git a/src/Nazara/Graphics/DeferredFogPass.cpp b/src/Nazara/Graphics/DeferredFogPass.cpp index f64521daf..f47a4ea56 100644 --- a/src/Nazara/Graphics/DeferredFogPass.cpp +++ b/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; diff --git a/src/Nazara/Graphics/DeferredGeometryPass.cpp b/src/Nazara/Graphics/DeferredGeometryPass.cpp index 08b111a70..86815558c 100644 --- a/src/Nazara/Graphics/DeferredGeometryPass.cpp +++ b/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.parameters[RendererParameter_FaceCulling] = true; - m_clearStates.parameters[RendererParameter_StencilTest] = true; + m_clearStates.depthBuffer = true; + m_clearStates.faceCulling = true; + m_clearStates.stencilTest = true; m_clearStates.depthFunc = RendererComparison_Always; - m_clearStates.frontFace.stencilCompare = RendererComparison_Always; - m_clearStates.frontFace.stencilPass = StencilOperation_Zero; + m_clearStates.stencilCompare.front = RendererComparison_Always; + m_clearStates.stencilPass.front = StencilOperation_Zero; } DeferredGeometryPass::~DeferredGeometryPass() = default; diff --git a/src/Nazara/Graphics/DeferredPhongLightingPass.cpp b/src/Nazara/Graphics/DeferredPhongLightingPass.cpp index efcc88e75..afe17ed13 100644 --- a/src/Nazara/Graphics/DeferredPhongLightingPass.cpp +++ b/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.parameters[RendererParameter_DepthBuffer] = false; - lightStates.parameters[RendererParameter_DepthWrite] = false; + lightStates.blending = true; + lightStates.depthBuffer = 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.faceCulling = FaceSide_Front; - lightStates.backFace.stencilMask = 0xFF; - lightStates.backFace.stencilReference = 0; - lightStates.backFace.stencilFail = StencilOperation_Keep; - lightStates.backFace.stencilPass = StencilOperation_Keep; - lightStates.backFace.stencilZFail = StencilOperation_Invert; - lightStates.frontFace.stencilMask = 0xFF; - lightStates.frontFace.stencilReference = 0; - lightStates.frontFace.stencilFail = StencilOperation_Keep; - lightStates.frontFace.stencilPass = StencilOperation_Keep; - lightStates.frontFace.stencilZFail = StencilOperation_Invert; + lightStates.cullingSide = FaceSide_Front; + lightStates.stencilTest = true; + lightStates.stencilDepthFail.back = StencilOperation_Invert; + lightStates.stencilDepthFail.front = StencilOperation_Invert; + lightStates.stencilFail.back = StencilOperation_Keep; + lightStates.stencilFail.front = StencilOperation_Keep; + lightStates.stencilPass.back = StencilOperation_Keep; + lightStates.stencilPass.front = StencilOperation_Keep; + lightStates.stencilReference.back = 0; + lightStates.stencilReference.front = 0; + lightStates.stencilWriteMask.back = 0xFF; + lightStates.stencilWriteMask.front = 0xFF; Renderer::SetRenderStates(lightStates); diff --git a/src/Nazara/Graphics/Material.cpp b/src/Nazara/Graphics/Material.cpp index 651f2581c..53e0e3e3e 100644 --- a/src/Nazara/Graphics/Material.cpp +++ b/src/Nazara/Graphics/Material.cpp @@ -252,41 +252,41 @@ namespace Nz // Stencil if (matData.GetIntegerParameter(MaterialData::StencilCompare, &iValue)) - m_states.frontFace.stencilCompare = static_cast(iValue); + m_states.stencilCompare.front = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::StencilFail, &iValue)) - m_states.frontFace.stencilFail = static_cast(iValue); + m_states.stencilFail.front = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::StencilPass, &iValue)) - m_states.frontFace.stencilPass = static_cast(iValue); + m_states.stencilPass.front = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::StencilZFail, &iValue)) - m_states.frontFace.stencilZFail = static_cast(iValue); + m_states.stencilDepthFail.front = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::StencilMask, &iValue)) - m_states.frontFace.stencilMask = static_cast(iValue); + m_states.stencilWriteMask.front = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::StencilReference, &iValue)) - m_states.frontFace.stencilReference = static_cast(iValue); + m_states.stencilReference.front = static_cast(iValue); // Stencil (back) if (matData.GetIntegerParameter(MaterialData::BackFaceStencilCompare, &iValue)) - m_states.backFace.stencilCompare = static_cast(iValue); + m_states.stencilCompare.back = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::BackFaceStencilFail, &iValue)) - m_states.backFace.stencilFail = static_cast(iValue); + m_states.stencilFail.back = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::BackFaceStencilPass, &iValue)) - m_states.backFace.stencilPass = static_cast(iValue); + m_states.stencilPass.back = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::BackFaceStencilZFail, &iValue)) - m_states.backFace.stencilZFail = static_cast(iValue); + m_states.stencilDepthFail.back = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::BackFaceStencilMask, &iValue)) - m_states.backFace.stencilMask = static_cast(iValue); + m_states.stencilWriteMask.back = static_cast(iValue); if (matData.GetIntegerParameter(MaterialData::BackFaceStencilReference, &iValue)) - m_states.backFace.stencilReference = static_cast(iValue); + m_states.stencilReference.back = static_cast(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::ColorWrite, GetRenderStates().parameters[RendererParameter_ColorWrite]); - matData->SetParameter(MaterialData::DepthBuffer, GetRenderStates().parameters[RendererParameter_DepthBuffer]); - matData->SetParameter(MaterialData::DepthWrite, GetRenderStates().parameters[RendererParameter_DepthWrite]); - matData->SetParameter(MaterialData::FaceCulling, GetRenderStates().parameters[RendererParameter_FaceCulling]); - matData->SetParameter(MaterialData::ScissorTest, GetRenderStates().parameters[RendererParameter_ScissorTest]); - matData->SetParameter(MaterialData::StencilTest, GetRenderStates().parameters[RendererParameter_StencilTest]); + matData->SetParameter(MaterialData::Blending, GetRenderStates().blending); + matData->SetParameter(MaterialData::ColorWrite, GetRenderStates().colorWrite); + matData->SetParameter(MaterialData::DepthBuffer, GetRenderStates().depthBuffer); + matData->SetParameter(MaterialData::DepthWrite, GetRenderStates().depthWrite); + matData->SetParameter(MaterialData::FaceCulling, GetRenderStates().faceCulling); + matData->SetParameter(MaterialData::ScissorTest, GetRenderStates().scissorTest); + 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::StencilFail, int(GetRenderStates().frontFace.stencilFail)); - matData->SetParameter(MaterialData::StencilPass, int(GetRenderStates().frontFace.stencilPass)); - matData->SetParameter(MaterialData::StencilZFail, int(GetRenderStates().frontFace.stencilZFail)); - matData->SetParameter(MaterialData::StencilMask, int(GetRenderStates().frontFace.stencilMask)); - matData->SetParameter(MaterialData::StencilReference, int(GetRenderStates().frontFace.stencilReference)); + matData->SetParameter(MaterialData::StencilCompare, int(GetRenderStates().stencilCompare.front)); + matData->SetParameter(MaterialData::StencilFail, int(GetRenderStates().stencilFail.front)); + matData->SetParameter(MaterialData::StencilPass, int(GetRenderStates().stencilPass.front)); + matData->SetParameter(MaterialData::StencilZFail, int(GetRenderStates().stencilDepthFail.front)); + matData->SetParameter(MaterialData::StencilMask, int(GetRenderStates().stencilWriteMask.front)); + matData->SetParameter(MaterialData::StencilReference, int(GetRenderStates().stencilReference.front)); // Stencil (back) - matData->SetParameter(MaterialData::BackFaceStencilCompare, int(GetRenderStates().backFace.stencilCompare)); - matData->SetParameter(MaterialData::BackFaceStencilFail, int(GetRenderStates().backFace.stencilFail)); - matData->SetParameter(MaterialData::BackFaceStencilPass, int(GetRenderStates().backFace.stencilPass)); - matData->SetParameter(MaterialData::BackFaceStencilZFail, int(GetRenderStates().backFace.stencilZFail)); - matData->SetParameter(MaterialData::BackFaceStencilMask, int(GetRenderStates().backFace.stencilMask)); - matData->SetParameter(MaterialData::BackFaceStencilReference, int(GetRenderStates().backFace.stencilReference)); + matData->SetParameter(MaterialData::BackFaceStencilCompare, int(GetRenderStates().stencilCompare.back)); + matData->SetParameter(MaterialData::BackFaceStencilFail, int(GetRenderStates().stencilFail.back)); + matData->SetParameter(MaterialData::BackFaceStencilPass, int(GetRenderStates().stencilPass.back)); + matData->SetParameter(MaterialData::BackFaceStencilZFail, int(GetRenderStates().stencilDepthFail.back)); + matData->SetParameter(MaterialData::BackFaceStencilMask, int(GetRenderStates().stencilWriteMask.back)); + 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.parameters[RendererParameter_FaceCulling] = true; + m_states.depthBuffer = true; + m_states.faceCulling = true; m_transformEnabled = true; SetShader("Basic"); diff --git a/src/Nazara/Graphics/SkyboxBackground.cpp b/src/Nazara/Graphics/SkyboxBackground.cpp index 75bc0cc12..fa7faefac 100644 --- a/src/Nazara/Graphics/SkyboxBackground.cpp +++ b/src/Nazara/Graphics/SkyboxBackground.cpp @@ -181,10 +181,10 @@ namespace Nz // Renderstates s_renderStates.depthFunc = RendererComparison_Equal; - s_renderStates.faceCulling = FaceSide_Front; - s_renderStates.parameters[RendererParameter_DepthBuffer] = true; - s_renderStates.parameters[RendererParameter_DepthWrite] = false; - s_renderStates.parameters[RendererParameter_FaceCulling] = true; + s_renderStates.cullingSide = FaceSide_Front; + s_renderStates.depthBuffer = true; + s_renderStates.depthWrite = false; + s_renderStates.faceCulling = true; // Exception-free zone s_indexBuffer = std::move(indexBuffer); diff --git a/src/Nazara/Graphics/TextureBackground.cpp b/src/Nazara/Graphics/TextureBackground.cpp index 1b2e53e72..a990f4af6 100644 --- a/src/Nazara/Graphics/TextureBackground.cpp +++ b/src/Nazara/Graphics/TextureBackground.cpp @@ -20,10 +20,10 @@ namespace Nz { RenderStates states; states.depthFunc = RendererComparison_Equal; - states.faceCulling = FaceSide_Back; - states.parameters[RendererParameter_DepthBuffer] = true; - states.parameters[RendererParameter_DepthWrite] = false; - states.parameters[RendererParameter_FaceCulling] = true; + states.cullingSide = FaceSide_Back; + states.depthBuffer = true; + states.depthWrite = false; + states.faceCulling = true; return states; } diff --git a/src/Nazara/Renderer/DebugDrawer.cpp b/src/Nazara/Renderer/DebugDrawer.cpp index 5623e6e8d..9f06c880f 100644 --- a/src/Nazara/Renderer/DebugDrawer.cpp +++ b/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) diff --git a/src/Nazara/Renderer/OpenGL.cpp b/src/Nazara/Renderer/OpenGL.cpp index b77319997..ba17fe015 100644 --- a/src/Nazara/Renderer/OpenGL.cpp +++ b/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); - currentRenderStates.parameters[RendererParameter_DepthWrite] = states.parameters[RendererParameter_DepthWrite]; + glDepthMask((states.depthWrite) ? GL_TRUE : GL_FALSE); + 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]); - currentRenderStates.faceCulling = states.faceCulling; + glCullFace(FaceSide[states.cullingSide]); + 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; - const RenderStates::Face& srcStates = (i == 0) ? states.backFace : states.frontFace; - RenderStates::Face& dstStates = (i == 0) ? currentRenderStates.backFace : currentRenderStates.frontFace; + glStencilFuncSeparate(GL_BACK, RendererComparison[states.stencilCompare.back], states.stencilReference.back, states.stencilWriteMask.back); + currentRenderStates.stencilCompare.back = states.stencilCompare.back; + currentRenderStates.stencilReference.back = states.stencilReference.back; + currentRenderStates.stencilWriteMask.back = states.stencilWriteMask.back; + } - if (dstStates.stencilCompare != srcStates.stencilCompare || - dstStates.stencilMask != srcStates.stencilMask || - dstStates.stencilReference != srcStates.stencilReference) - { - glStencilFuncSeparate(face, RendererComparison[srcStates.stencilCompare], srcStates.stencilReference, srcStates.stencilMask); - dstStates.stencilCompare = srcStates.stencilCompare; - dstStates.stencilMask = srcStates.stencilMask; - dstStates.stencilReference = srcStates.stencilReference; - } + if (currentRenderStates.stencilDepthFail.back != states.stencilDepthFail.back || + currentRenderStates.stencilFail.back != states.stencilFail.back || + currentRenderStates.stencilPass.back != states.stencilPass.back) + { + glStencilOpSeparate(GL_BACK, StencilOperation[states.stencilFail.back], StencilOperation[states.stencilDepthFail.back], StencilOperation[states.stencilPass.back]); + currentRenderStates.stencilDepthFail.back = states.stencilDepthFail.back; + currentRenderStates.stencilFail.back = states.stencilFail.back; + currentRenderStates.stencilPass.back = states.stencilPass.back; + } - if (dstStates.stencilFail != srcStates.stencilFail || - dstStates.stencilPass != srcStates.stencilPass || - dstStates.stencilZFail != srcStates.stencilZFail) - { - glStencilOpSeparate(face, StencilOperation[srcStates.stencilFail], StencilOperation[srcStates.stencilZFail], StencilOperation[srcStates.stencilPass]); - dstStates.stencilFail = srcStates.stencilFail; - dstStates.stencilPass = srcStates.stencilPass; - dstStates.stencilZFail = srcStates.stencilZFail; - } + if (currentRenderStates.stencilCompare.front != states.stencilCompare.front || + currentRenderStates.stencilReference.front != states.stencilReference.front || + currentRenderStates.stencilWriteMask.front != states.stencilWriteMask.front) + { + glStencilFuncSeparate(GL_FRONT, RendererComparison[states.stencilCompare.front], states.stencilReference.front, states.stencilWriteMask.front); + currentRenderStates.stencilCompare.front = states.stencilCompare.front; + currentRenderStates.stencilReference.front = states.stencilReference.front; + 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; } } diff --git a/src/Nazara/Renderer/Renderer.cpp b/src/Nazara/Renderer/Renderer.cpp index e49db2cec..028f7513f 100644 --- a/src/Nazara/Renderer/Renderer.cpp +++ b/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.frontFace.stencilCompare = compareFunc; + s_states.stencilCompare.back = 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.frontFace.stencilFail = failOperation; + s_states.stencilFail.back = 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.frontFace.stencilMask = mask; + s_states.stencilWriteMask.back = 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.frontFace.stencilPass = passOperation; + s_states.stencilPass.back = 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.frontFace.stencilReference = refValue; + s_states.stencilReference.back = 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.frontFace.stencilZFail = zfailOperation; + s_states.stencilDepthFail.back = zfailOperation; + s_states.stencilDepthFail.front = zfailOperation; break; } }