- Cleaning PPS

- Optimizing the GaussianBlurGeneric.glsl a bit

shaders/GaussianBlurGeneric.glsl

@@ -13,17 +13,16 @@ layout(location = 0) in vec2 position;
 uniform float imgDimension = 0.0; ///< the img width for hspass or the img height for vpass
 
 out vec2 vTexCoords;
-out float vOffsets[2]; ///< For side pixels
+out vec2 vOffsets; ///< For side pixels. Its actually a 2D array
 
-const float BLURRING_OFFSET[2] = float[](1.3846153846, 3.2307692308); ///< The offset of side pixels
+const vec2 BLURRING_OFFSET = vec2(1.3846153846, 3.2307692308); ///< The offset of side pixels. Its actually a 2D array
 
 
 void main()
 {
 	vTexCoords = position;
 
-	vOffsets[0] = BLURRING_OFFSET[0] / imgDimension;
-	vOffsets[1] = BLURRING_OFFSET[1] / imgDimension;
+	vOffsets = BLURRING_OFFSET / imgDimension;
 
 	gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0);
 }
@@ -46,7 +45,7 @@ uniform sampler2D img; ///< Input FAI
 uniform float blurringDist = 0.0;
 
 in vec2 vTexCoords;
-in float vOffsets[2];
+in vec2 vOffsets;
 
 
 // Determine color type

src/Renderer/Pps.cpp

@@ -2,6 +2,7 @@
 #include "Renderer.h"
 #include "Hdr.h"
 #include "Ssao.h"
+#include "RendererInitializer.h"
 
 
 //======================================================================================================================
@@ -14,66 +15,6 @@ Pps::Pps(Renderer& r_):
 {}
 
 
-//======================================================================================================================
-// initPassFbo                                                                                                         =
-//======================================================================================================================
-void Pps::initPassFbo(Fbo& fbo, Texture& fai)
-{
-	fbo.create();
-	fbo.bind();
-
-	fbo.setNumOfColorAttachements(1);
-
-	Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB, GL_RGB, GL_FLOAT, fai);
-
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fai.getGlId(), 0);
-
-	fbo.checkIfGood();
-
-	fbo.unbind();
-}
-
-
-//======================================================================================================================
-// initPrePassSProg                                                                                                    =
-//======================================================================================================================
-void Pps::initPrePassSProg()
-{
-	std::string pps = "";
-	std::string prefix = "";
-
-	if(ssao.isEnabled())
-	{
-		pps += "#define SSAO_ENABLED\n";
-		prefix += "Ssao";
-	}
-
-	prePassSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl", pps.c_str(),
-	                                                       prefix.c_str()).c_str());
-	prePassSProg->bind();
-}
-
-
-//======================================================================================================================
-// initPostPassSProg                                                                                                   =
-//======================================================================================================================
-void Pps::initPostPassSProg()
-{
-	std::string pps = "";
-	std::string prefix = "";
-
-	if(hdr.isEnabled())
-	{
-		pps += "#define HDR_ENABLED\n";
-		prefix += "Hdr";
-	}
-
-	postPassSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl", pps.c_str(),
-	                                                        prefix.c_str()).c_str());
-	postPassSProg->bind();
-}
-
-
 //======================================================================================================================
 // init                                                                                                                =
 //======================================================================================================================
@@ -81,76 +22,131 @@ void Pps::init(const RendererInitializer& initializer)
 {
 	ssao.init(initializer);
 	hdr.init(initializer);
+	blurringEnabled = initializer.pps.blurringEnabled;
+	blurringIterationsNum = initializer.pps.blurringIterationsNum;
+
+	//
+	// Init pre pass
+	//
 
+	// FBO
 	try
 	{
-		initPassFbo(prePassFbo, prePassFai);
+		prePassFbo.create();
+		prePassFbo.bind();
+		prePassFbo.setNumOfColorAttachements(1);
+		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB, GL_RGB, GL_FLOAT, prePassFai);
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, prePassFai.getGlId(), 0);
+		prePassFbo.checkIfGood();
+		prePassFbo.unbind();
 	}
 	catch(std::exception& e)
 	{
 		throw EXCEPTION("Cannot create pre-pass post-processing stage FBO: " + e.what());
 	}
 
-	try
-	{
-		initPassFbo(postPassFbo, postPassFai);
-	}
-	catch(std::exception& e)
+	// SProg
+	std::string pps = "";
+	std::string prefix = "";
+	if(ssao.isEnabled())
 	{
-		throw EXCEPTION("Cannot create post-pass post-processing stage FBO: " + e.what());
+		pps += "#define SSAO_ENABLED\n";
+		prefix += "Ssao";
 	}
 
-	initPrePassSProg();
-	initPostPassSProg();
-
-
-	hBlurSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsBlurGeneric.glsl", "#define HPASS\n",
-	                                                     "h").c_str());
-	vBlurSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsBlurGeneric.glsl", "#define VPASS\n",
-	                                                     "v").c_str());
-
-	Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB, GL_RGB, GL_FLOAT, blurFai);
+	prePassSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsPrePass.glsl", pps.c_str(),
+	                                                       prefix.c_str()).c_str());
 
-	try
-	{
-		hBlurFbo.create();
-		hBlurFbo.bind();
-		hBlurFbo.setNumOfColorAttachements(1);
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, blurFai.getGlId(), 0);
-	}
-	catch(std::exception& e)
-	{
-		throw EXCEPTION("Cannot create h blur post-processing stage FBO: " + e.what());
-	}
+	//
+	// Init post pass
+	//
 
+	// FBO
 	try
 	{
-		vBlurFbo.create();
-		vBlurFbo.bind();
-		vBlurFbo.setNumOfColorAttachements(1);
+		postPassFbo.create();
+		postPassFbo.bind();
+		postPassFbo.setNumOfColorAttachements(1);
+		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB, GL_RGB, GL_FLOAT, postPassFai);
 		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, postPassFai.getGlId(), 0);
+		postPassFbo.checkIfGood();
+		postPassFbo.unbind();
 	}
 	catch(std::exception& e)
 	{
-		throw EXCEPTION("Cannot create v blur post-processing stage FBO: " + e.what());
+		throw EXCEPTION("Cannot create post-pass post-processing stage FBO: " + e.what());
 	}
 
+	// SProg
+	pps = "";
+	prefix = "";
 
-	try
-	{
-		sideBlurFbo.create();
-		sideBlurFbo.bind();
-		sideBlurFbo.setNumOfColorAttachements(1);
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, r.getMs().getNormalFai().getGlId(), 0);
-	}
-	catch(std::exception& e)
+	if(hdr.isEnabled())
 	{
-		throw EXCEPTION("Cannot create side blur post-processing stage FBO: " + e.what());
+		pps += "#define HDR_ENABLED\n";
+		prefix += "Hdr";
 	}
 
-	sideBlur.loadRsrc("engine-rsrc/side-blur.png");
+	postPassSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsPostPass.glsl", pps.c_str(),
+	                                                        prefix.c_str()).c_str());
 
-	sideBlurSProg.loadRsrc("shaders/PpsSideBlur.glsl");
+
+	//
+	// Blurring
+	//
+	if(blurringEnabled)
+	{
+		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB, GL_RGB, GL_FLOAT, blurFai);
+
+		// Horizontal
+		try
+		{
+			hBlurFbo.create();
+			hBlurFbo.bind();
+			hBlurFbo.setNumOfColorAttachements(1);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, blurFai.getGlId(), 0);
+		}
+		catch(std::exception& e)
+		{
+			throw EXCEPTION("Cannot create horizontal blur post-processing stage FBO: " + e.what());
+		}
+
+		hBlurSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsBlurGeneric.glsl", "#define HPASS\n",
+															 "h").c_str());
+
+		// Vertical
+		try
+		{
+			vBlurFbo.create();
+			vBlurFbo.bind();
+			vBlurFbo.setNumOfColorAttachements(1);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, postPassFai.getGlId(), 0);
+		}
+		catch(std::exception& e)
+		{
+			throw EXCEPTION("Cannot create vertical blur post-processing stage FBO: " + e.what());
+		}
+
+		vBlurSProg.loadRsrc(ShaderProg::createSrcCodeToCache("shaders/PpsBlurGeneric.glsl", "#define VPASS\n",
+															 "v").c_str());
+
+		// Side blur
+		try
+		{
+			sideBlurFbo.create();
+			sideBlurFbo.bind();
+			sideBlurFbo.setNumOfColorAttachements(1);
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+								   r.getMs().getNormalFai().getGlId(), 0);
+		}
+		catch(std::exception& e)
+		{
+			throw EXCEPTION("Cannot create side blur post-processing stage FBO: " + e.what());
+		}
+
+		sideBlur.loadRsrc("engine-rsrc/side-blur.png");
+		sideBlurSProg.loadRsrc("shaders/PpsSideBlur.glsl");
+	} // end blurring enabled
 }
 
 
@@ -179,8 +175,6 @@ void Pps::runPrePass()
 	}
 
 	r.drawQuad();
-
-	//Fbo::unbind();
 }
 
 
@@ -190,7 +184,7 @@ void Pps::runPrePass()
 void Pps::runBlur()
 {
 	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
-	uint blurringIterationsNum = 1;
+
 	for(uint i = 0; i < blurringIterationsNum; i++)
 	{
 		// hpass
@@ -218,11 +212,31 @@ void Pps::runBlur()
 }
 
 
+//======================================================================================================================
+// runSideBlur                                                                                                         =
+//======================================================================================================================
+void Pps::runSideBlur()
+{
+	sideBlurFbo.bind();
+
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+	glBlendFunc(GL_ONE, GL_ONE);
+
+	sideBlurSProg->bind();
+	sideBlurSProg->findUniVar("tex")->set(*sideBlur, 0);
+
+	r.drawQuad();
+}
+
+
 //======================================================================================================================
 // runPostPass                                                                                                         =
 //======================================================================================================================
 void Pps::runPostPass()
 {
+	//
+	// The actual pass
+	//
 	if(hdr.isEnabled())
 	{
 		hdr.run();
@@ -236,7 +250,6 @@ void Pps::runPostPass()
 
 	postPassSProg->bind();
 	postPassSProg->findUniVar("ppsPrePassFai")->set(prePassFai, 0);
-
 	if(hdr.isEnabled())
 	{
 		postPassSProg->findUniVar("ppsHdrFai")->set(hdr.getFai(), 1);
@@ -245,16 +258,11 @@ void Pps::runPostPass()
 	r.drawQuad();
 
 	//
-	// todo
+	// Blurring
 	//
-	sideBlurFbo.bind();
-	sideBlurSProg->bind();
-	sideBlurSProg->findUniVar("tex")->set(*sideBlur, 0);
-	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
-	glBlendFunc(GL_ONE, GL_ONE);
-	r.drawQuad();
-
-
-	runBlur();
-
+	if(blurringEnabled)
+	{
+		runSideBlur();
+		runBlur();
+	}
 }

src/Renderer/Pps.h

@@ -52,16 +52,11 @@ class Pps: private RenderingPass
 		Texture postPassFai; ///< FAI #2
 		Texture blurFai; ///< Temp FAI for blurring
 		RsrcPtr<Texture> sideBlur;
-
-		void initPassFbo(Fbo& fbo, Texture& fai);
-
-		/// Before BS pass
-		void initPrePassSProg();
-
-		/// After BS pass
-		void initPostPassSProg();
+		bool blurringEnabled;
+		uint blurringIterationsNum;
 
 		void runBlur();
+		void runSideBlur();
 };
 
 

src/Renderer/RendererInitializer.h

@@ -50,6 +50,9 @@ struct RendererInitializer
 			float renderingQuality;
 			float blurringIterationsNum;
 		} ssao;
+
+		bool blurringEnabled;
+		uint blurringIterationsNum;
 	} pps;
 
 	// Dbg