optimizing

src/Core/Logger.cpp

@@ -92,7 +92,7 @@ void Logger::execCommonConstructionCode()
 //======================================================================================================================
 void Logger::append(const char* cstr, int len)
 {
-	boost::mutex::scoped_lock lock(mutex);
+	mutex.lock();
 
 	if(len > STREAM_SIZE - 1)
 	{
@@ -110,12 +110,14 @@ void Logger::append(const char* cstr, int len)
 		memcpy(sptr, cstr, charsLeft);
 		sptr += charsLeft;
 		flush();
+		mutex.unlock();
 		append(cstr + charsLeft, len - charsLeft);
 		return;
 	}
 
 	memcpy(sptr, cstr, len);
 	sptr += len;
+	mutex.unlock();
 }
 
 

src/Misc/skybox.cpp

@@ -53,8 +53,8 @@ render
 */
 void Skybox::Render(const Mat3& /*rotation*/)
 {
-	/*glDisable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	/*GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(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());
-				glDisable(GL_BLEND); // a hack
+				GlStateMachineSingleton::getInstance().setBlendingEnabled(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())
 				{
-					glEnable(GL_BLEND);
+					GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
 					glBlendFunc(sm.getCpMtl().getBlendingSfactor(), sm.getCpMtl().getBlendingDfactor());
 				}
 				else
 				{
-					glDisable(GL_BLEND);
+					GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 				}
 
 				refractSProg->bind();

src/Renderer/Dbg.cpp

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

src/Renderer/Drawers/SceneDrawer.cpp

@@ -7,6 +7,7 @@
 #include "App.h"
 #include "Scene.h"
 #include "MaterialRuntime.h"
+#include "GlStateMachine.h"
 
 
 //======================================================================================================================
@@ -89,26 +90,13 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 	//
 	// FFP stuff
 	//
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(mtlr.isBlendingEnabled());
 	if(mtlr.isBlendingEnabled())
 	{
-		glEnable(GL_BLEND);
-		//glDisable(GL_BLEND);
 		glBlendFunc(mtlr.getBlendingSfactor(), mtlr.getBlendingDfactor());
 	}
-	else
-	{
-		glDisable(GL_BLEND);
-	}
 
-
-	if(mtlr.isDepthTestingEnabled())
-	{
-		glEnable(GL_DEPTH_TEST);
-	}
-	else
-	{
-		glDisable(GL_DEPTH_TEST);
-	}
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(mtlr.isDepthTestingEnabled());
 
 	if(mtlr.isWireframeEnabled())
 	{

src/Renderer/Drawers/SceneDrawer.h

@@ -30,7 +30,7 @@ class SceneDrawer
 		void renderRenderableNode(const RenderableNode& renderable, const Camera& cam, RenderingPassType rtype) const;
 
 	private:
-		/// @todo
+		/// Set the uniform using this visitor
 		class UsrDefVarVisitor: public boost::static_visitor<void>
 		{
 			public:

src/Renderer/Ez.cpp

@@ -55,8 +55,8 @@ void Ez::run()
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-	glEnable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 
 	/// @todo Uncomment
 	/*for(Vec<MeshNode*>::iterator it=app->getScene().meshNodes.begin(); it!=app->getScene().meshNodes.end(); it++)

src/Renderer/GlStateMachine.h

@@ -0,0 +1,81 @@
+#ifndef GL_STATE_MACHINE_H
+#define GL_STATE_MACHINE_H
+
+#include <GL/glew.h>
+#include "Assert.h"
+#include "Singleton.h"
+
+
+/// Access the GL state machine.
+/// This class saves us from calling the GL functions
+class GlStateMachine
+{
+	public:
+		GlStateMachine() {sync();}
+
+		/// Sync the local members with the opengl ones
+		void sync();
+
+		/// @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);}
+		/// @}
+
+	private:
+		bool depthTestEnabledFlag;
+		bool blendingEnabledFlag;
+
+		static bool getFlag(GLenum glFlag, bool myFlag);
+		static void setFlag(GLenum glFlag, bool enable, bool& myFlag);
+};
+
+
+//======================================================================================================================
+// Inlines                                                                                                             =
+//======================================================================================================================
+
+inline void GlStateMachine::sync()
+{
+	depthTestEnabledFlag = glIsEnabled(GL_DEPTH_TEST);
+	blendingEnabledFlag = glIsEnabled(GL_BLEND);
+}
+
+
+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;
+	}
+}
+
+
+//======================================================================================================================
+// Other                                                                                                               =
+//======================================================================================================================
+
+typedef Singleton<GlStateMachine> GlStateMachineSingleton; ///< Make the GlStateMachine singleton class
+
+
+#endif

src/Renderer/Hdr.cpp

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

src/Renderer/Is.cpp

@@ -197,7 +197,7 @@ void Is::drawLightPassQuad() const
 //======================================================================================================================
 void Is::ambientPass(const Vec3& color)
 {
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 
 	// set the shader
 	ambientPassSProg->bind();
@@ -269,9 +269,9 @@ void Is::spotLightPass(const SpotLight& light)
 		fbo.bind();
 
 		// and restore blending and depth test
-		glEnable(GL_BLEND);
+		GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
 		glBlendFunc(GL_ONE, GL_ONE);
-		glDisable(GL_DEPTH_TEST);
+		GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
 		Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 	}
 
@@ -345,13 +345,13 @@ void Is::run()
 	// OGL stuff
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
-	glDisable(GL_DEPTH_TEST);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
 
 	// ambient pass
 	ambientPass(SceneSingleton::getInstance().getAmbientCol());
 
 	// light passes
-	glEnable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(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);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 	glDisable(GL_STENCIL_TEST);
 	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	glDepthMask(true);
@@ -97,8 +97,8 @@ void MainRenderer::render(Camera& cam_)
 	//
 	Fbo::unbind();
 	setViewport(0, 0, AppSingleton::getInstance().getWindowWidth(), AppSingleton::getInstance().getWindowHeight());
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(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());
 
-	//glEnable(GL_DEPTH_TEST);
+	//GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
 	//app->getScene().skybox.Render(cam.getViewMatrix().getRotationPart());
 	//glDepthFunc(GL_LEQUAL);
 

src/Renderer/Pps.cpp

@@ -117,8 +117,8 @@ void Pps::runPrePass()
 
 	prePassFbo.bind();
 
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	prePassSProg->bind();
@@ -147,8 +147,8 @@ void Pps::runPostPass()
 
 	postPassFbo.bind();
 
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(false);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 	Renderer::setViewport(0, 0, r.getWidth(), r.getHeight());
 
 	postPassSProg->bind();

src/Renderer/Renderer.h

@@ -16,6 +16,7 @@
 #include "GlException.h"
 #include "SceneDrawer.h"
 #include "SkinsDeformer.h"
+#include "GlStateMachine.h"
 
 
 class Camera;

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);
-	glEnable(GL_DEPTH_TEST);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(true);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
 
 	// for artifacts
 	glPolygonOffset(2.0, 2.0); // keep the values as low as possible!!!!

src/Renderer/Ssao.cpp

@@ -107,8 +107,8 @@ void Ssao::run()
 	int height = renderingQuality * r.getHeight();
 	const Camera& cam = r.getCamera();
 
-	glDisable(GL_BLEND);
-	glDisable(GL_DEPTH_TEST);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(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);
 
-	glEnable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
 	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glDisable(GL_DEPTH_TEST);
+	GlStateMachineSingleton::getInstance().setDepthTestEnabled(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);
-	glDisable(GL_BLEND);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false)eton::getInstance().setBlendingEnabled(false);
 	glDisable(GL_STENCIL_TEST);
 	glPolygonMode(GL_FRONT, GL_FILL);
 	glDepthMask(true);