Playing with blurring

shaders/GaussianBlurGeneric.glsl

@@ -14,9 +14,6 @@ layout(location = 0) in vec2 position;
 
 out vec2 vTexCoords;
 
-/// The offset of side pixels. Its actually a 2D array
-const vec2 BLURRING_OFFSET = vec2(1.3846153846, 3.2307692308); 
-
 void main()
 {
 	vTexCoords = position;
@@ -43,7 +40,6 @@ precision mediump float;
 uniform mediump sampler2D img; ///< Input FAI
 
 in vec2 vTexCoords;
-in vec2 vOffsets;
 
 #if !defined(BLURRING_DIST)
 #	define BLURRING_DIST 0.0
@@ -67,40 +63,41 @@ in vec2 vOffsets;
 #	define TEX_FETCH r
 #endif
 
-const float BLURRING_OFFSET_X = 1.3846153846 / IMG_DIMENSION;
-const float BLURRING_OFFSET_Y = 3.2307692308 / IMG_DIMENSION;
-const float BLURRING_OFFSET[2] = float[](BLURRING_OFFSET_X, 
-	BLURRING_OFFSET_Y); 
+// Weights
+const float first_weight = 0.2270270270;
+const float weights[4] = float[](
+	0.3162162162, 0.0702702703, 
+	0.3162162162, 0.0702702703);
+
+// Calc the kernel
+#if defined(VPASS)
+#	define BLURRING_OFFSET_X(val) (float(val) / float(IMG_DIMENSION))
+#	define BLURRING_OFFSET_Y(val) 0.0
+#else
+#	define BLURRING_OFFSET_X(val) 0.0
+#	define BLURRING_OFFSET_Y(val) (float(val) / float(IMG_DIMENSION))
+#endif
 
-layout(location = 0) out COL_TYPE fFragColor;
+#define BLURRING_OFFSET(v) vec2(BLURRING_OFFSET_X(v), BLURRING_OFFSET_Y(v))
 
-const float FIRST_WEIGHT = 0.2255859375;
-const float WEIGHTS[2] = float[](0.314208984375, 0.06982421875);
+const vec2 kernel[4] = vec2[](
+	BLURRING_OFFSET(1.3846153846),
+	BLURRING_OFFSET(3.2307692308),
+	BLURRING_OFFSET(-1.3846153846),
+	BLURRING_OFFSET(-3.2307692308));
+
+// Output
+layout(location = 0) out COL_TYPE fFragColor;
 
 void main()
 {
 	// the center (0,0) pixel
-	COL_TYPE col = texture(img, vTexCoords).TEX_FETCH * FIRST_WEIGHT;
+	fFragColor = texture(img, vTexCoords).TEX_FETCH * first_weight;
 
 	// side pixels
-	for(int i = 0; i < 2; i++)
+	for(int i = 0; i < 4; i++)
 	{
-#if defined(HPASS)
-		vec2 tc = vec2(vTexCoords.x + BLURRING_DIST + BLURRING_OFFSET[i], 
-			vTexCoords.y);
-		col += texture(img, tc).TEX_FETCH * WEIGHTS[i];
-
-		tc.x = vTexCoords.x - BLURRING_DIST - BLURRING_OFFSET[i];
-		col += texture(img, tc).TEX_FETCH * WEIGHTS[i];
-#elif defined(VPASS)
-		vec2 tc = vec2(vTexCoords.x, 
-			vTexCoords.y + BLURRING_DIST + BLURRING_OFFSET[i]);
-		col += texture(img, tc).TEX_FETCH * WEIGHTS[i];
-
-		tc.y = vTexCoords.y - BLURRING_DIST - BLURRING_OFFSET[i];
-		col += texture(img, tc).TEX_FETCH * WEIGHTS[i];
-#endif
+		fFragColor += 
+			texture(img, vTexCoords + kernel[i]).TEX_FETCH * weights[i];
 	}
-
-	fFragColor = col;
 }

shaders/Pps.glsl

@@ -106,8 +106,6 @@ void main(void)
 
 	fColor = gammaCorrectionRgb(vec3(0.9, 0.92, 0.75), fColor);
 
-	//fColor = clamp(fColor, 0.0, 1.0) * 0.0001 + vec3(ssao);
-
 #if 0
 	if(fColor.r != 0.00000001)
 	{

shaders/VariableSamplingBlurGeneric.glsl

@@ -1,7 +1,8 @@
 /// Defines: 
 /// - VPASS or HPASS
 /// - COL_RGBA or COL_RGB or COL_R
-/// - SAMPLES is a number of 2 or 4 or 6
+/// - SAMPLES is a number of 3 or 5 or 7 or 9
+/// - BLURRING_DIST is optional and it's extra pixels to move the blurring
 
 #pragma anki start vertexShader
 
@@ -40,6 +41,10 @@ uniform mediump sampler2D img; ///< Input FAI
 
 in vec2 vTexCoords;
 
+#if !defined(BLURRING_DIST)
+#	define BLURRING_DIST 0.0
+#endif
+
 // Determine color type
 #if defined(COL_RGBA)
 #	define COL_TYPE vec4
@@ -58,62 +63,62 @@ in vec2 vTexCoords;
 #	define TEX_FETCH r
 #endif
 
-// Calc the kernel
+// Calc the kernel. Use offsets of 3 to take advantage of bilinear filtering
 #if defined(VPASS)
-#	define BLURRING_OFFSET_X(val) (float(val) / float(IMG_DIMENSION))
-#	define BLURRING_OFFSET_Y(val) 0.0
+#	define BLURRING_OFFSET_X(val, sign_) ((float(val) * (BLURRING_DIST + 3.0) / float(IMG_DIMENSION)) * float(sign_))
+#	define BLURRING_OFFSET_Y(val, sign_) 0.0
 #else
-#	define BLURRING_OFFSET_X(val) 0.0
-#	define BLURRING_OFFSET_Y(val) (float(val) / float(IMG_DIMENSION))
+#	define BLURRING_OFFSET_X(val, sign_) 0.0
+#	define BLURRING_OFFSET_Y(val, sign_) ((float(val) * (BLURRING_DIST + 3.0) / float(IMG_DIMENSION)) * float(sign_))
 #endif
 
-#define BLURRING_OFFSET(v) vec2(BLURRING_OFFSET_X(v), BLURRING_OFFSET_Y(v))
-
-#if SAMPLES == 2
-const vec2 kernel[3] = vec2[](
-	BLURRING_OFFSET(-1),
-	BLURRING_OFFSET(0),
-	BLURRING_OFFSET(1));
-#elif SAMPLES == 4
-const vec2 kernel[5] = vec2[](
-	BLURRING_OFFSET(-2),
-	BLURRING_OFFSET(-1),
-	BLURRING_OFFSET(0),
-	BLURRING_OFFSET(1),
-	BLURRING_OFFSET(2));
-#elif SAMPLES == 6
-const vec2 kernel[7] = vec2[](
-	BLURRING_OFFSET(-3),
-	BLURRING_OFFSET(-2),
-	BLURRING_OFFSET(-1),
-	BLURRING_OFFSET(0),
-	BLURRING_OFFSET(1),
-	BLURRING_OFFSET(2),
-	BLURRING_OFFSET(3));
-#elif SAMPLES == 8
-const vec2 kernel[9] = vec2[](
-	BLURRING_OFFSET(-4),
-	BLURRING_OFFSET(-3),
-	BLURRING_OFFSET(-2),
-	BLURRING_OFFSET(-1),
-	BLURRING_OFFSET(0),
-	BLURRING_OFFSET(1),
-	BLURRING_OFFSET(2),
-	BLURRING_OFFSET(3),
-	BLURRING_OFFSET(4));
+#define BLURRING_OFFSET(v, s) vec2(BLURRING_OFFSET_X(v, s), BLURRING_OFFSET_Y(v, s))
+
+#if SAMPLES == 3
+const vec2 kernel[SAMPLES] = vec2[](
+	BLURRING_OFFSET(1, -1),
+	BLURRING_OFFSET(0, 1),
+	BLURRING_OFFSET(1, 1));
+#elif SAMPLES == 5
+const vec2 kernel[SAMPLES] = vec2[](
+	BLURRING_OFFSET(2, -1),
+	BLURRING_OFFSET(1, -1),
+	BLURRING_OFFSET(0, 0),
+	BLURRING_OFFSET(1, 1),
+	BLURRING_OFFSET(2, 1));
+#elif SAMPLES == 7
+const vec2 kernel[SAMPLES] = vec2[](
+	BLURRING_OFFSET(3, -1),
+	BLURRING_OFFSET(2, -1),
+	BLURRING_OFFSET(1, -1),
+	BLURRING_OFFSET(0, 1),
+	BLURRING_OFFSET(1, 1),
+	BLURRING_OFFSET(2, 1),
+	BLURRING_OFFSET(3, 1));
+#elif SAMPLES == 9
+const vec2 kernel[SAMPLES] = vec2[](
+	BLURRING_OFFSET(4, -1),
+	BLURRING_OFFSET(3, -1),
+	BLURRING_OFFSET(2, -1),
+	BLURRING_OFFSET(1, -1),
+	BLURRING_OFFSET(0, 1),
+	BLURRING_OFFSET(1, 1),
+	BLURRING_OFFSET(2, 1),
+	BLURRING_OFFSET(3, 1),
+	BLURRING_OFFSET(4, 1));
 #endif
 
 layout(location = 0) out COL_TYPE fFragColor;
 
 void main()
 {
-	// the color
-	COL_TYPE col = texture(img, vTexCoords + kernel[0]);
+	// Get the first
+	COL_TYPE col = texture(img, vTexCoords + kernel[0]).TEX_FETCH;
 
-	// Get the samples
+	// Get the rest of the samples
 	for(int i = 1; i < SAMPLES; i++)
 	{
-		col += texture(img, vTexCoords + kernel[i]);
+		col += texture(img, vTexCoords + kernel[i]).TEX_FETCH;
 	}
 
 	fFragColor = col * (1.0 / float(SAMPLES));

src/renderer/Hdr.cpp

@@ -11,6 +11,8 @@ Hdr::~Hdr()
 void Hdr::initFbo(Fbo& fbo, Texture& fai)
 {
 	Renderer::createFai(width, height, GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, fai);
+
+	// Set to bilinear because the blurring techniques take advantage of that
 	fai.setFiltering(Texture::TFT_LINEAR);
 
 	// create FBO
@@ -52,22 +54,22 @@ void Hdr::initInternal(const Renderer::Initializer& initializer)
 
 	const char* SHADER_FILENAME = "shaders/GaussianBlurGeneric.glsl";
 
-	F32 blurringDistRealX = F32(blurringDist / width);
-	F32 blurringDistRealY = F32(blurringDist / height);
+	F32 blurringDistRealX = F32(blurringDist / width);// XXX
+	F32 blurringDistRealY = F32(blurringDist / height);// XXX
 
 	std::string pps =
 		"#define HPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST " + std::to_string(blurringDistRealX) + "\n"
-		"#define IMG_DIMENSION " + std::to_string(width) + ".0\n";
+		"#define BLURRING_DIST " + std::to_string(blurringDistRealX) + "\n" // XXX
+		"#define IMG_DIMENSION " + std::to_string(height) + ".0\n";
 	hblurSProg.load(ShaderProgramResource::createSrcCodeToCache(
 		SHADER_FILENAME, pps.c_str()).c_str());
 
 	pps =
 		"#define VPASS\n"
 		"#define COL_RGB\n"
-		"#define BLURRING_DIST " + std::to_string(blurringDistRealY) + "\n"
-		"#define IMG_DIMENSION " + std::to_string(height) + ".0\n";
+		"#define BLURRING_DIST " + std::to_string(blurringDistRealY) + "\n"// XXX
+		"#define IMG_DIMENSION " + std::to_string(width) + ".0\n";
 	vblurSProg.load(ShaderProgramResource::createSrcCodeToCache(
 		SHADER_FILENAME, pps.c_str()).c_str());
 

src/renderer/Ssao.cpp

@@ -16,6 +16,8 @@ struct ShaderCommonUniforms
 void Ssao::createFbo(Fbo& fbo, Texture& fai, F32 width, F32 height)
 {
 	Renderer::createFai(width, height, GL_RED, GL_RED, GL_UNSIGNED_BYTE, fai);
+
+	// Set to bilinear because the blurring techniques take advantage of that
 	fai.setFiltering(Texture::TFT_LINEAR);
 
 	fbo.create();
@@ -99,14 +101,14 @@ void Ssao::initInternal(const RendererInitializer& initializer)
 	pps = "#define HPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION " + std::to_string(bHeight) + "\n"
-		"#define SAMPLES 8\n";
+		"#define SAMPLES 7\n";
 	hblurSProg.load(ShaderProgramResource::createSrcCodeToCache(
 		SHADER_FILENAME, pps.c_str()).c_str());
 
 	pps = "#define VPASS\n"
 		"#define COL_R\n"
 		"#define IMG_DIMENSION " + std::to_string(bWidth) + "\n"
-		"#define SAMPLES 8\n";
+		"#define SAMPLES 7\n";
 	vblurSProg.load(ShaderProgramResource::createSrcCodeToCache(
 		SHADER_FILENAME, pps.c_str()).c_str());
 }

testapp/Main.cpp

@@ -546,7 +546,7 @@ void initSubsystems(int argc, char* argv[])
 	initializer.pps.hdr.blurringDist = 1.0;
 	initializer.pps.hdr.blurringIterationsCount = 1;
 	initializer.pps.hdr.exposure = 8.0;
-	initializer.pps.ssao.blurringIterationsNum = 2;
+	initializer.pps.ssao.blurringIterationsNum = 1;
 	initializer.pps.ssao.enabled = true;
 	initializer.pps.ssao.mainPassRenderingQuality = 0.5;
 	initializer.pps.ssao.blurringRenderingQuality = 0.5;