Blurring

shaders/Final.glsl

@@ -16,5 +16,5 @@ void main()
 	//if( gl_FragCoord.x > 0.5 ) discard;
 
 	fFragColor = texture2D(rasterImage, vTexCoords).rgb;
-	//fFragColor = vec3(texture2D(rasterImage, vTexCoords).r);
+	//fFragColor = vec3(texture2D(rasterImage, vTexCoords).b);
 }

shaders/MsMpGeneric.glsl

@@ -124,6 +124,7 @@ uniform vec3 specularCol = vec3(1.0, 0.0, 1.0);
 #if defined(ALPHA_TESTING)
 	uniform float alphaTestingTolerance = 0.5; ///< Below this value the pixels are getting discarded 
 #endif
+uniform float blurring = 0.0;
 
 in vec3 vNormal;
 in vec3 vTangent;
@@ -133,7 +134,7 @@ in vec3 vVertPosViewSpace;
 // @todo 
 in vec3 eye;
 
-layout(location = 0) out vec2 fMsNormalFai;
+layout(location = 0) out vec3 fMsNormalFai;
 layout(location = 1) out vec3 fMsDiffuseFai;
 layout(location = 2) out vec4 fMsSpecularFai;
 
@@ -312,7 +313,7 @@ void main()
 	//
 	// Final Stage. Write all data
 	//
-	fMsNormalFai = packNormal(_normal_);
+	fMsNormalFai = vec3(packNormal(_normal_), blurring);
 	fMsDiffuseFai = _diffColl_;
 	fMsSpecularFai = _specularCol_;
 }

shaders/PpsBlurGeneric.glsl

@@ -0,0 +1,73 @@
+#pragma anki vertShaderBegins
+
+layout(location = 0) in vec2 position;
+
+out vec2 vTexCoords;
+out float vOffsets[2]; ///< For side pixels
+
+uniform float imgDimension = 0.0; ///< the img width for hspass or the img height for vpass
+
+const float BLURRING_OFFSET[2] = float[](1.3846153846, 3.2307692308); ///< The offset of side pixels
+
+
+void main()
+{
+	vTexCoords = position;
+
+	vOffsets[0] = BLURRING_OFFSET[0] / imgDimension;
+	vOffsets[1] = BLURRING_OFFSET[1] / imgDimension;
+
+	gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0);
+}
+
+
+#pragma anki fragShaderBegins
+
+
+uniform sampler2D img; ///< Input FAI
+uniform sampler2D msNormalFai;
+
+in vec2 vTexCoords;
+in float vOffsets[2];
+
+layout(location = 0) out vec3 fFragColor;
+
+
+const float FIRST_WEIGHT = 0.2255859375;
+const float WEIGHTS[2] = float[](0.314208984375, 0.06982421875);
+
+
+void main()
+{
+	float blurringDist = texture2D(msNormalFai, vTexCoords).b;
+
+	/*if(blurringDist == 0.0)
+	{
+		fFragColor = texture2D(img, vTexCoords).rgb;
+	}
+	else*/
+	{
+		// the center (0,0) pixel
+		vec3 col = texture2D(img, vTexCoords).rgb * FIRST_WEIGHT;
+
+		// side pixels
+		for(int i = 0; i < 2; i++)
+		{
+			#if defined(HPASS)
+				vec2 texCoords = vec2(vTexCoords.x + vOffsets[i] * blurringDist, vTexCoords.y);
+				col += texture2D(img, texCoords).rgb * WEIGHTS[i];
+
+				texCoords.x = vTexCoords.x - blurringDist * vOffsets[i];
+				col += texture2D(img, texCoords).rgb * WEIGHTS[i];
+			#elif defined(VPASS)
+				vec2 texCoords = vec2(vTexCoords.x, vTexCoords.y + blurringDist * vOffsets[i]);
+				col += texture2D(img, texCoords).rgb * WEIGHTS[i];
+
+				texCoords.y = vTexCoords.y - blurringDist * vOffsets[i];
+				col += texture2D(img, texCoords).rgb * WEIGHTS[i];
+			#endif
+		}
+
+		fFragColor = col;
+	}
+}

shaders/PpsSideBlur.glsl

@@ -0,0 +1,17 @@
+// The final pass
+
+#pragma anki vertShaderBegins
+
+#pragma anki include "shaders/SimpleVert.glsl"
+
+#pragma anki fragShaderBegins
+
+uniform sampler2D tex;
+in vec2 vTexCoords;
+layout(location = 0) out vec3 fFragColor;
+
+
+void main()
+{
+	fFragColor = vec3(0.0, 0.0, texture2D(tex, vTexCoords).r);
+}

src/Core/Object.h

@@ -27,12 +27,12 @@ class Object
 		Container& getObjChildren() {return objChilds;}
 		/// @}
 
+		void addChild(Object* child);
+		void removeChild(Object* child);
+
 	private:
 		Object* objParent; ///< May be nullptr
 		Container objChilds;
-
-		void addChild(Object* child);
-		void removeChild(Object* child);
 };
 
 

src/Main.cpp

@@ -175,6 +175,8 @@ void init()
 	imp->skelAnimModelNodeCtrl->set(imp->getSkin().getSkelAnims()[0].get());
 	imp->skelAnimModelNodeCtrl->setStep(0.8);
 
+	imp->addChild(*cam);
+
 	return;
 
 	// sarge

src/Math/Mat4.inl.h

@@ -802,7 +802,7 @@ inline float Mat4::getDet() const
 inline Mat4 Mat4::getInverse() const
 {
 	/// @todo test this
-	#if !defined(MATH_INTEL_SIMD)
+	/*#if !defined(MATH_INTEL_SIMD)
 		Mat4 r(SELF);
 		__m128 minor0, minor1, minor2, minor3;
 		__m128 det, tmp1;
@@ -882,7 +882,7 @@ inline Mat4 Mat4::getInverse() const
 		r.arrMm[3] = minor3;
 
 		return r;
-	#else
+	#else*/
 		float tmp[12];
 		float det;
 		const Mat4& in = SELF;
@@ -954,7 +954,7 @@ inline Mat4 Mat4::getInverse() const
 		det = 1.0 / det;
 		m4 *= det;
 		return m4;
-	#endif
+	//#endif
 }
 
 // invert

src/Renderer/Drawers/SceneDrawer.cpp

@@ -81,7 +81,7 @@ void SceneDrawer::UsrDefVarVisitor::operator()(MtlUserDefinedVar::Fai x) const
 // setupShaderProg                                                                                                     =
 //======================================================================================================================
 void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform& nodeWorldTransform, const Camera& cam,
-                                  const Renderer& r)
+                                  const Renderer& r, float blurring)
 {
 	uint textureUnit = 0;
 
@@ -227,6 +227,14 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr, const Transform&
 		mtlr.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->set(&col);
 	}
 
+	if(mtlr.getStdUniVar(Material::SUV_BLURRING))
+	{
+		/*blurring *= 10.0;
+		INFO(blurring);*/
+		float b = blurring;
+		mtlr.getStdUniVar(Material::SUV_BLURRING)->set(&b);
+	}
+
 
 	//
 	// set user defined vars
@@ -248,12 +256,17 @@ void SceneDrawer::renderRenderableNode(const RenderableNode& renderable, const C
 {
 	const MaterialRuntime* mtlr;
 	const Vao* vao;
+	float blurring = 0.0;
 
 	switch(rtype)
 	{
 		case RPT_COLOR:
 			mtlr = &renderable.getCpMtlRun();
 			vao = &renderable.getCpVao();
+
+			blurring = (renderable.getWorldTransform().getOrigin() -
+			            renderable.getPrevWorldTransform().getOrigin()).getLength();
+
 			break;
 
 		case RPT_DEPTH:
@@ -262,7 +275,7 @@ void SceneDrawer::renderRenderableNode(const RenderableNode& renderable, const C
 			break;
 	}
 
-	setupShaderProg(*mtlr, renderable.getWorldTransform(), cam, r);
+	setupShaderProg(*mtlr, renderable.getWorldTransform(), cam, r, blurring);
 
 	vao->bind();
 	glDrawElements(GL_TRIANGLES, renderable.getVertIdsNum(), GL_UNSIGNED_SHORT, 0);

src/Renderer/Drawers/SceneDrawer.h

@@ -59,7 +59,7 @@ class SceneDrawer
 		/// @param cam Needed for some matrices (view & projection)
 		/// @param r The renderer, needed for some FAIs and some matrices
 		static void setupShaderProg(const MaterialRuntime& mtlr, const Transform& nodeWorldTransform,
-		                            const Camera& cam, const Renderer& r);
+		                            const Camera& cam, const Renderer& r, float blurring = 0.0);
 };
 
 

src/Renderer/Ms.cpp

@@ -31,7 +31,7 @@ void Ms::init(const RendererInitializer& initializer)
 
 		// create the FAIs
 
-		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RG16F, GL_RG, GL_FLOAT, normalFai);
+		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB16F, GL_RGB, GL_FLOAT, normalFai);
 		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGB8, GL_RGB, GL_FLOAT, diffuseFai);
 		Renderer::createFai(r.getWidth(), r.getHeight(), GL_RGBA8, GL_RGBA, GL_FLOAT, specularFai);
 		Renderer::createFai(r.getWidth(), r.getHeight(), GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL,

src/Renderer/Pps.cpp

@@ -102,6 +102,55 @@ void Pps::init(const RendererInitializer& initializer)
 
 	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);
+
+	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());
+	}
+
+	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 v blur post-processing stage FBO: " + e.what());
+	}
+
+
+	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");
 }
 
 
@@ -135,6 +184,40 @@ void Pps::runPrePass()
 }
 
 
+//======================================================================================================================
+// runBlur                                                                                                             =
+//======================================================================================================================
+void Pps::runBlur()
+{
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(false);
+	uint blurringIterationsNum = 1;
+	for(uint i = 0; i < blurringIterationsNum; i++)
+	{
+		// hpass
+		hBlurFbo.bind();
+
+		hBlurSProg->bind();
+		hBlurSProg->findUniVar("img")->set(postPassFai, 0);
+		hBlurSProg->findUniVar("msNormalFai")->set(r.getMs().getNormalFai(), 1);
+		float tmp = r.getWidth();
+		hBlurSProg->findUniVar("imgDimension")->set(&tmp);
+
+		r.drawQuad();
+
+		// vpass
+		vBlurFbo.bind();
+
+		vBlurSProg->bind();
+		vBlurSProg->findUniVar("img")->set(blurFai, 0);
+		vBlurSProg->findUniVar("msNormalFai")->set(r.getMs().getNormalFai(), 1);
+		tmp = r.getHeight();
+		vBlurSProg->findUniVar("imgDimension")->set(&tmp);
+
+		r.drawQuad();
+	}
+}
+
+
 //======================================================================================================================
 // runPostPass                                                                                                         =
 //======================================================================================================================
@@ -161,5 +244,17 @@ void Pps::runPostPass()
 
 	r.drawQuad();
 
-	//Fbo::unbind();
+	//
+	// todo
+	//
+	sideBlurFbo.bind();
+	sideBlurSProg->bind();
+	sideBlurSProg->findUniVar("tex")->set(*sideBlur, 0);
+	GlStateMachineSingleton::getInstance().setBlendingEnabled(true);
+	glBlendFunc(GL_ONE, GL_ONE);
+	r.drawQuad();
+
+
+	runBlur();
+
 }

src/Renderer/Pps.h

@@ -40,10 +40,18 @@ class Pps: private RenderingPass
 
 		Fbo prePassFbo;
 		Fbo postPassFbo;
+		Fbo hBlurFbo; ///< Fbo that writes to blurFai
+		Fbo vBlurFbo; ///< Fbo that writes to postPassSProg
+		Fbo sideBlurFbo;
 		RsrcPtr<ShaderProg> prePassSProg;
 		RsrcPtr<ShaderProg> postPassSProg;
+		RsrcPtr<ShaderProg> hBlurSProg;
+		RsrcPtr<ShaderProg> vBlurSProg;
+		RsrcPtr<ShaderProg> sideBlurSProg;
 		Texture prePassFai; ///< FAI #1
 		Texture postPassFai; ///< FAI #2
+		Texture blurFai; ///< Temp FAI for blurring
+		RsrcPtr<Texture> sideBlur;
 
 		void initPassFbo(Fbo& fbo, Texture& fai);
 
@@ -52,6 +60,8 @@ class Pps: private RenderingPass
 
 		/// After BS pass
 		void initPostPassSProg();
+
+		void runBlur();
 };
 
 

src/Renderer/Ssao.cpp

@@ -50,7 +50,9 @@ void Ssao::init(const RendererInitializer& initializer)
 	enabled = initializer.pps.ssao.enabled;
 
 	if(!enabled)
+	{
 		return;
+	}
 
 	renderingQuality = initializer.pps.ssao.renderingQuality;
 	blurringIterationsNum = initializer.pps.ssao.blurringIterationsNum;

src/Resources/Material/Material.cpp

@@ -39,7 +39,8 @@ boost::array<Material::StdVarNameAndGlDataTypePair, Material::SUV_NUM> Material:
 	{"ppsPrePassFai", GL_SAMPLER_2D},
 	{"ppsPostPassFai", GL_SAMPLER_2D},
 	{"rendererSize", GL_FLOAT_VEC2},
-	{"sceneAmbientColor", GL_FLOAT_VEC3}
+	{"sceneAmbientColor", GL_FLOAT_VEC3},
+	{"blurring", GL_FLOAT},
 }};
 
 Material::PreprocDefines Material::msGenericDefines[] =

src/Resources/Material/Material.h

@@ -122,6 +122,7 @@ class Material: private MaterialProps
 			// Other
 			SUV_RENDERER_SIZE,
 			SUV_SCENE_AMBIENT_COLOR,
+			SUV_BLURRING,
 			// num
 			SUV_NUM ///< The number of standard uniform variables
 		};

src/Scene/Cameras/Camera.cpp

@@ -94,6 +94,7 @@ void Camera::updateViewMatrix()
 
 	// The view matrix is: Mview = camera.world_transform.Inverted(). Bus instead of inverting we do the following:
 	Mat3 camInvertedRot = getWorldTransform().getRotation().getTransposed();
+	camInvertedRot *= 1.0 / getWorldTransform().getScale();
 	Vec3 camInvertedTsl = -(camInvertedRot * getWorldTransform().getOrigin());
 	viewMat = Mat4(camInvertedTsl, camInvertedRot);
 }

src/Scene/SceneNode.cpp

@@ -43,6 +43,8 @@ SceneNode::~SceneNode()
 //======================================================================================================================
 void SceneNode::updateWorldTransform()
 {
+	prevWorldTransform = worldTransform;
+
 	if(getObjParent())
 	{
 		const SceneNode* parent = static_cast<const SceneNode*>(getObjParent());

src/Scene/SceneNode.h

@@ -36,13 +36,9 @@ class SceneNode: public Object
 
 		/// @name Accessors
 		/// @{
-		const Transform& getLocalTransform() const {return localTransform;}
-		Transform& getLocalTransform() {return localTransform;}
-		void setLocalTransform(const Transform& t) {localTransform = t;}
-
-		const Transform& getWorldTransform() const {return worldTransform;}
-		Transform& getWorldTransform() {return worldTransform;}
-		void setWorldTransform(const Transform& t) {worldTransform = t;}
+		GETTER_SETTER(Transform, localTransform, getLocalTransform, setLocalTransform)
+		GETTER_SETTER(Transform, worldTransform, getWorldTransform, setWorldTransform)
+		GETTER_R(Transform, prevWorldTransform, getPrevWorldTransform)
 
 		GETTER_R_BY_VAL(SceneNodeType, type, getSceneNodeType)
 
@@ -81,12 +77,15 @@ class SceneNode: public Object
 		/// This update happens only when the object gets moved. Called only by the Scene
 		void updateWorldTransform();
 
+		void addChild(SceneNode& node) {Object::addChild(&node);}
+
 	protected:
 		std::string name;
 
 	private:
 		Transform localTransform; ///< The transformation in local space
 		Transform worldTransform; ///< The transformation in world space (local combined with parent's transformation)
+		Transform prevWorldTransform;
 
 		SceneNodeType type;
 		bool compoundFlag; ///< This means that the children will inherit the world transform of this node