Refactoring

src/Misc/skybox.cpp

@@ -53,8 +53,8 @@ render
 */
 void Skybox::Render(const Mat3& /*rotation*/)
 {
-	/*GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	/*GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	glPushMatrix();
 

src/Renderer/Bs.cpp

@@ -115,7 +115,7 @@ void Bs::run()
 				glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 
 				r.setupShaderProg(sm.getCpMtl(), mn, r.getCamera());
-				GlStateMachineSingleton::getInstance().setBlendingEnabled(false); // a hack
+				GlStateMachineSingleton::getInstance().enable(GL_BLEND, false); // a hack
 
 				sm.getCpVao().bind();
 				glDrawElements(GL_TRIANGLES, sm.getModelPatchRsrc().getMesh().getVertIdsNum(), GL_UNSIGNED_SHORT, 0);
@@ -131,12 +131,12 @@ void Bs::run()
 
 				if(sm.getCpMtl().isBlendingEnabled())
 				{
-					GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+					GlStateMachineSingleton::getInstance().enable(GL_BLEND, true);
 					glBlendFunc(sm.getCpMtl().getBlendingSfactor(), sm.getCpMtl().getBlendingDfactor());
 				}
 				else
 				{
-					GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+					GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 				}
 
 				refractSProg->bind();

src/Renderer/Dbg.cpp

@@ -258,8 +258,8 @@ void Dbg::run()
 
 	// OGL stuff
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	setModelMat(Mat4::getIdentity());
 	renderGrid();

src/Renderer/Drawers/SceneDrawer.cpp

@@ -90,13 +90,13 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 	//
 	// FFP stuff
 	//
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(mtlr.isBlendingEnabled());
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, mtlr.isBlendingEnabled());
 	if(mtlr.isBlendingEnabled())
 	{
 		glBlendFunc(mtlr.getBlendingSfactor(), mtlr.getBlendingDfactor());
 	}
 
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(mtlr.isDepthTestingEnabled());
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, mtlr.isDepthTestingEnabled());
 
 	if(mtlr.isWireframeEnabled())
 	{

src/Renderer/Ez.cpp

@@ -58,8 +58,8 @@ void Ez::run()
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	glClear(GL_DEPTH_BUFFER_BIT);
 

src/Renderer/GlStateMachine.cpp

@@ -1,12 +1,65 @@
 #include "GlStateMachine.h"
 
 
+//======================================================================================================================
+// Statics                                                                                                             =
+//======================================================================================================================
+
+GLenum GlStateMachine::flagEnums[] =
+{
+	GL_DEPTH_TEST,
+	GL_BLEND,
+	0
+};
+
+
+//======================================================================================================================
+// enable                                                                                                              =
+//======================================================================================================================
+void GlStateMachine::enable(GLenum glFlag, bool enable)
+{
+	ASSERT(flags.find(glFlag) != flags.end());
+	bool state = flags[glFlag];
+	ASSERT(glIsEnabled(glFlag) == state);
+
+	if(enable != state)
+	{
+		if(enable)
+		{
+			glEnable(glFlag);
+		}
+		else
+		{
+			glDisable(glFlag);
+		}
+		flags[glFlag] = enable;
+	}
+}
+
+
+//======================================================================================================================
+// isEnabled                                                                                                           =
+//======================================================================================================================
+bool GlStateMachine::isEnabled(GLenum glFlag)
+{
+	ASSERT(flags.find(glFlag) != flags.end());
+	bool state = flags[glFlag];
+	ASSERT(glIsEnabled(glFlag) == state);
+	return state;
+}
+
+
 //======================================================================================================================
 // sync                                                                                                                =
 //======================================================================================================================
 void GlStateMachine::sync()
 {
-	depthTestEnabledFlag = glIsEnabled(GL_DEPTH_TEST);
-	blendingEnabledFlag = glIsEnabled(GL_BLEND);
 	sProgGlId = getCurrentProgramGlId();
+
+	// Set flags
+	GLenum* flagEnum = &flagEnums[0];
+	while(*flagEnum != 0)
+	{
+		flags[*flagEnum] = glIsEnabled(*flagEnum);
+	}
 }

src/Renderer/GlStateMachine.h

@@ -2,6 +2,7 @@
 #define GL_STATE_MACHINE_H
 
 #include <GL/glew.h>
+#include <boost/unordered_map.hpp>
 #include "Assert.h"
 #include "Singleton.h"
 
@@ -18,11 +19,8 @@ class GlStateMachine
 
 		/// @name Set the Fixed Function Pipeline, Call the OpenGL functions only when needed
 		/// @{
-		bool isDepthTestEnabled() const {return getFlag(GL_DEPTH_TEST, depthTestEnabledFlag);}
-		void setDepthTestEnabled(bool enable) {setFlag(GL_DEPTH_TEST, enable, depthTestEnabledFlag);}
-
-		bool isBlendingEnabled() const {return getFlag(GL_BLEND, blendingEnabledFlag);}
-		void setBlendingEnabled(bool enable) {setFlag(GL_BLEND, enable, blendingEnabledFlag);}
+		void enable(GLenum flag, bool enable);
+		bool isEnabled(GLenum flag);
 
 		void useShaderProg(GLuint id);
 		/// @}
@@ -30,13 +28,11 @@ class GlStateMachine
 	private:
 		/// @name The GL state
 		/// @{
-		bool depthTestEnabledFlag;
-		bool blendingEnabledFlag;
 		GLuint sProgGlId;
-		/// @}
 
-		static bool getFlag(GLenum glFlag, bool myFlag);
-		static void setFlag(GLenum glFlag, bool enable, bool& myFlag);
+		boost::unordered_map<GLenum, bool> flags;
+		static GLenum flagEnums[];
+		/// @}
 
 		static GLuint getCurrentProgramGlId();
 };
@@ -46,32 +42,6 @@ class GlStateMachine
 // Inlines                                                                                                             =
 //======================================================================================================================
 
-inline bool GlStateMachine::getFlag(GLenum glFlag, bool myFlag)
-{
-	ASSERT(glIsEnabled(glFlag) == myFlag);
-	return myFlag;
-}
-
-
-inline void GlStateMachine::setFlag(GLenum glFlag, bool enable, bool& myFlag)
-{
-	ASSERT(glIsEnabled(glFlag) == myFlag);
-
-	if(enable != myFlag)
-	{
-		if(enable)
-		{
-			glEnable(glFlag);
-		}
-		else
-		{
-			glDisable(glFlag);
-		}
-		myFlag = enable;
-	}
-}
-
-
 inline void GlStateMachine::useShaderProg(GLuint id)
 {
 	ASSERT(getCurrentProgramGlId() == sProgGlId);

src/Renderer/Hdr.cpp

@@ -88,8 +88,8 @@ void Hdr::run()
 	int h = renderingQuality * r.getHeight();
 	Renderer::setViewport(0, 0, w, h);
 
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 
 	// pass 0
 	toneFbo.bind();

src/Renderer/Is.cpp

@@ -139,7 +139,7 @@ void Is::init(const RendererInitializer& initializer)
 //======================================================================================================================
 void Is::ambientPass(const Vec3& color)
 {
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	// set the shader
 	ambientPassSProg->bind();
@@ -162,7 +162,7 @@ void Is::pointLightPass(const PointLight& light)
 
 	// stencil optimization
 	smo.run(light);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 
 	// shader prog
 	const ShaderProg& shader = *pointLightSProg; // ensure the const-ness
@@ -212,15 +212,15 @@ void Is::spotLightPass(const SpotLight& light)
 		fbo.bind();
 
 		// and restore blending and depth test
-		GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+		GlStateMachineSingleton::getInstance().enable(GL_BLEND, true);
 		glBlendFunc(GL_ONE, GL_ONE);
-		GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+		GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 		Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 	}
 
 	// stencil optimization
 	smo.run(light);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 
 	// set the texture
 	//light.getTexture().setRepeat(false);
@@ -314,11 +314,11 @@ void Is::run()
 	fbo.bind();
 
 	// ambient pass
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 	ambientPass(SceneSingleton::getInstance().getAmbientCol());
 
 	// light passes
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, true);
 	glBlendFunc(GL_ONE, GL_ONE);
 	glEnable(GL_STENCIL_TEST);
 

src/Renderer/MainRenderer.cpp

@@ -67,7 +67,7 @@ void MainRenderer::initGl()
 	// defaults
 	//glDisable(GL_LIGHTING);
 	//glDisable(GL_TEXTURE_2D);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 	glDisable(GL_STENCIL_TEST);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	glDepthMask(true);
@@ -98,8 +98,8 @@ void MainRenderer::render(Camera& cam_)
 	glBindFramebuffer(GL_FRAMEBUFFER, 0); // Bind the window framebuffer
 
 	setViewport(0, 0, AppSingleton::getInstance().getWindowWidth(), AppSingleton::getInstance().getWindowHeight());
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 	sProg->bind();
 	//sProg->findUniVar("rasterImage")->set(ms.getNormalFai(), 0);
 	//sProg->findUniVar("rasterImage")->set(pps.getSsao().getFai(), 0);

src/Renderer/Ms.cpp

@@ -80,7 +80,7 @@ void Ms::run()
 
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
-	//GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
+	//GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, true);
 	//app->getScene().skybox.Render(cam.getViewMatrix().getRotationPart());
 	//glDepthFunc(GL_LEQUAL);
 

src/Renderer/Pps.cpp

@@ -162,8 +162,8 @@ void Pps::runPrePass()
 
 	prePassFbo.bind();
 
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	prePassSProg->bind();
@@ -183,7 +183,7 @@ void Pps::runPrePass()
 //======================================================================================================================
 void Pps::runBlur()
 {
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	for(uint i = 0; i < blurringIterationsNum; i++)
 	{
@@ -219,7 +219,7 @@ void Pps::runSideBlur()
 {
 	sideBlurFbo.bind();
 
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, true);
 	glBlendFunc(GL_ONE, GL_ONE);
 
 	sideBlurSProg->bind();
@@ -244,8 +244,8 @@ void Pps::runPostPass()
 
 	postPassFbo.bind();
 
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	postPassSProg->bind();

src/Renderer/Sm.cpp

@@ -123,8 +123,8 @@ void Sm::run(const Camera& cam, float distance)
 
 	// disable color & blend & enable depth test
 	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
 
 	// for artifacts
 	glPolygonOffset(2.0, 2.0); // keep the values as low as possible!!!!

src/Renderer/Smo.cpp

@@ -69,12 +69,12 @@ void Smo::setUpGl(bool inside)
 	if(inside)
 	{
 		glCullFace(GL_FRONT);
-		GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+		GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 	}
 	else
 	{
 		glDepthMask(GL_FALSE);
-		GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
+		GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, true);
 	}
 }
 

src/Renderer/Ssao.cpp

@@ -98,8 +98,8 @@ void Ssao::run()
 	int height = renderingQuality * r.getHeight();
 	const Camera& cam = r.getCamera();
 
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 
 
 	Renderer::setViewport(0, 0, width, height);

src/Ui/Ui.cpp

@@ -44,9 +44,9 @@ static void SetGL()
 	shader->bind();
 	shader->findUniVar("fontMap")->setTexture(*fontMap, 0);
 
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, true);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_DEPTH_TEST, false);
 	glColor4fv(color);
 
 	// matrix stuff

tools/shredder/src/Main.cpp

@@ -130,7 +130,7 @@ void initEngine(int argc, char** argv)
 	glEnable(GL_CULL_FACE);
 	glDisable(GL_LIGHTING);
 	glDisable(GL_TEXTURE_2D);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(false)eton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().enable(GL_BLEND, lse)eton::getInstance().setBlendingEnabled(false);
 	glDisable(GL_STENCIL_TEST);
 	glPolygonMode(GL_FRONT, GL_FILL);
 	glDepthMask(true);