Implemented a better bloom effect with no threshold (#550)

* Added blending function and equation settings to the pipeline state (now 16 bytes instead of 8 bytes, sad but necessary).
* Fixed a bunch of pipeline state values that were using the incorrect number of bits 🫣
* Added `CirlcularIterator` to iterate over things... circularly 😅
* Added `PingPongFramebuffer`, not used atm (was at some point during implementation), but could be useful for other effects!
* Added new overload to `FramebufferUtil::SetupFramebuffer` providing more control over the texture desc.
* Changed post-processing stack order by adding auto-exposure before bloom.

Author: adriengivry

Resources/Engine/Shaders/PostProcess/Bloom.ovfx

@@ -16,15 +16,15 @@ void main()
 #version 450 core
 
 in vec2 TexCoords;
-out vec4 FRAGMENT_COLOR;
+out vec3 FRAGMENT_COLOR;
 
 uniform sampler2D _InputTexture;
 uniform sampler2D _BloomTexture;
-uniform float _BloomIntensity;
+uniform float _BloomStrength;
 
 void main()
 {
-    const vec3 sceneColor = texture(_InputTexture, TexCoords).rgb;
+    const vec3 hdrColor = texture(_InputTexture, TexCoords).rgb;
     const vec3 bloomColor = texture(_BloomTexture, TexCoords).rgb;
-    FRAGMENT_COLOR = vec4(sceneColor + _BloomIntensity * bloomColor, 1.0);
+    FRAGMENT_COLOR = mix(hdrColor, bloomColor, _BloomStrength);
 }

Resources/Engine/Shaders/PostProcess/BloomDownsampling.ovfx

@@ -0,0 +1,115 @@
+#feature KARIS_AVERAGE
+
+#shader vertex
+#version 450 core
+
+layout(location = 0) in vec2 geo_Pos;
+layout(location = 1) in vec2 geo_TexCoords;
+
+out vec2 TexCoords;
+
+void main()
+{
+    TexCoords = geo_TexCoords;
+    gl_Position = vec4(geo_Pos, 0.0, 1.0);
+}
+
+#shader fragment
+#version 450 core
+
+in vec2 TexCoords;
+out vec3 downsample;
+
+uniform sampler2D _InputTexture;
+uniform vec2 _InputResolution;
+
+vec3 PowVec3(vec3 v, float p)
+{
+    return vec3(pow(v.x, p), pow(v.y, p), pow(v.z, p));
+}
+
+const float invGamma = 1.0 / 2.2;
+vec3 ToSRGB(vec3 v)   { return PowVec3(v, invGamma); }
+
+float sRGBToLuma(vec3 col)
+{
+    //return dot(col, vec3(0.2126f, 0.7152f, 0.0722f));
+    return dot(col, vec3(0.299f, 0.587f, 0.114f));
+}
+
+float KarisAverage(vec3 col)
+{
+    // Formula is 1 / (1 + luma)
+    float luma = sRGBToLuma(ToSRGB(col)) * 0.25f;
+    return 1.0f / (1.0f + luma);
+}
+
+void main()
+{
+    vec2 srcTexelSize = 1.0 / _InputResolution;
+    float x = srcTexelSize.x;
+    float y = srcTexelSize.y;
+
+    // Take 13 samples around current texel:
+    // a - b - c
+    // - j - k -
+    // d - e - f
+    // - l - m -
+    // g - h - i
+    // === ('e' is the current texel) ===
+    vec3 a = texture(_InputTexture, vec2(TexCoords.x - 2*x, TexCoords.y + 2*y)).rgb;
+    vec3 b = texture(_InputTexture, vec2(TexCoords.x,       TexCoords.y + 2*y)).rgb;
+    vec3 c = texture(_InputTexture, vec2(TexCoords.x + 2*x, TexCoords.y + 2*y)).rgb;
+
+    vec3 d = texture(_InputTexture, vec2(TexCoords.x - 2*x, TexCoords.y)).rgb;
+    vec3 e = texture(_InputTexture, vec2(TexCoords.x,       TexCoords.y)).rgb;
+    vec3 f = texture(_InputTexture, vec2(TexCoords.x + 2*x, TexCoords.y)).rgb;
+
+    vec3 g = texture(_InputTexture, vec2(TexCoords.x - 2*x, TexCoords.y - 2*y)).rgb;
+    vec3 h = texture(_InputTexture, vec2(TexCoords.x,       TexCoords.y - 2*y)).rgb;
+    vec3 i = texture(_InputTexture, vec2(TexCoords.x + 2*x, TexCoords.y - 2*y)).rgb;
+
+    vec3 j = texture(_InputTexture, vec2(TexCoords.x - x, TexCoords.y + y)).rgb;
+    vec3 k = texture(_InputTexture, vec2(TexCoords.x + x, TexCoords.y + y)).rgb;
+    vec3 l = texture(_InputTexture, vec2(TexCoords.x - x, TexCoords.y - y)).rgb;
+    vec3 m = texture(_InputTexture, vec2(TexCoords.x + x, TexCoords.y - y)).rgb;
+
+    // Apply weighted distribution:
+    // 0.5 + 0.125 + 0.125 + 0.125 + 0.125 = 1
+    // a,b,d,e * 0.125
+    // b,c,e,f * 0.125
+    // d,e,g,h * 0.125
+    // e,f,h,i * 0.125
+    // j,k,l,m * 0.5
+    // This shows 5 square areas that are being sampled. But some of them overlap,
+    // so to have an energy preserving downsample we need to make some adjustments.
+    // The weights are the distributed, so that the sum of j,k,l,m (e.g.)
+    // contribute 0.5 to the final color output. The code below is written
+    // to effectively yield this sum. We get:
+    // 0.125*5 + 0.03125*4 + 0.0625*4 = 1
+
+    // Check if we need to perform Karis average on each block of 4 samples
+#if defined(KARIS_AVERAGE)
+    vec3 groups[5];
+    // We are writing to mip 0, so we need to apply Karis average to each block
+    // of 4 samples to prevent fireflies (very bright subpixels, leads to pulsating
+    // artifacts).
+    groups[0] = (a+b+d+e) * (0.125f/4.0f);
+    groups[1] = (b+c+e+f) * (0.125f/4.0f);
+    groups[2] = (d+e+g+h) * (0.125f/4.0f);
+    groups[3] = (e+f+h+i) * (0.125f/4.0f);
+    groups[4] = (j+k+l+m) * (0.5f/4.0f);
+    groups[0] *= KarisAverage(groups[0]);
+    groups[1] *= KarisAverage(groups[1]);
+    groups[2] *= KarisAverage(groups[2]);
+    groups[3] *= KarisAverage(groups[3]);
+    groups[4] *= KarisAverage(groups[4]);
+    downsample = groups[0]+groups[1]+groups[2]+groups[3]+groups[4];
+    downsample = max(downsample, 0.0001f);
+#else
+    downsample = e*0.125;                // ok
+    downsample += (a+c+g+i)*0.03125;     // ok
+    downsample += (b+d+f+h)*0.0625;      // ok
+    downsample += (j+k+l+m)*0.125;       // ok
+#endif
+}

Resources/Engine/Shaders/PostProcess/BloomUpsampling.ovfx

@@ -0,0 +1,54 @@
+#shader vertex
+#version 450 core
+
+layout(location = 0) in vec2 geo_Pos;
+layout(location = 1) in vec2 geo_TexCoords;
+
+out vec2 TexCoords;
+
+void main()
+{
+    TexCoords = geo_TexCoords;
+    gl_Position = vec4(geo_Pos, 0.0, 1.0);
+}
+
+#shader fragment
+#version 450 core
+
+in vec2 TexCoords;
+out vec3 upsample;
+
+uniform sampler2D _InputTexture;
+uniform float _FilterRadius;
+
+void main()
+{
+    float x = _FilterRadius;
+    float y = _FilterRadius;
+
+    // Take 9 samples around current texel:
+    // a - b - c
+    // d - e - f
+    // g - h - i
+    // === ('e' is the current texel) ===
+    vec3 a = texture(_InputTexture, vec2(TexCoords.x - x, TexCoords.y + y)).rgb;
+    vec3 b = texture(_InputTexture, vec2(TexCoords.x,     TexCoords.y + y)).rgb;
+    vec3 c = texture(_InputTexture, vec2(TexCoords.x + x, TexCoords.y + y)).rgb;
+
+    vec3 d = texture(_InputTexture, vec2(TexCoords.x - x, TexCoords.y)).rgb;
+    vec3 e = texture(_InputTexture, vec2(TexCoords.x,     TexCoords.y)).rgb;
+    vec3 f = texture(_InputTexture, vec2(TexCoords.x + x, TexCoords.y)).rgb;
+
+    vec3 g = texture(_InputTexture, vec2(TexCoords.x - x, TexCoords.y - y)).rgb;
+    vec3 h = texture(_InputTexture, vec2(TexCoords.x,     TexCoords.y - y)).rgb;
+    vec3 i = texture(_InputTexture, vec2(TexCoords.x + x, TexCoords.y - y)).rgb;
+
+    // Apply weighted distribution, by using a 3x3 tent filter:
+    //  1   | 1 2 1 |
+    // -- * | 2 4 2 |
+    // 16   | 1 2 1 |
+    upsample = e*4.0;
+    upsample += (b+d+f+h)*2.0;
+    upsample += (a+c+g+i);
+    upsample *= 1.0 / 16.0;
+}

Resources/Engine/Shaders/PostProcess/Blur.ovfx

@@ -105,4 +105,4 @@ namespace OvCore::Helpers
 		static OvAudio::Resources::Sound* DeserializeSound(tinyxml2::XMLDocument& p_doc, tinyxml2::XMLNode* p_node, const std::string& p_name);
 		#pragma endregion
 	};
-}
+}

Resources/Engine/Shaders/PostProcess/Brightness.ovfx

@@ -12,6 +12,22 @@
 
 namespace OvCore::Rendering::FramebufferUtil
 {
+	/**
+	* Prepare the given framebuffer for rendering by attaching
+	* the necessary textures and renderbuffers.
+	* @note This overload gives more control over the texture desc.
+	* @param p_framebuffer
+	* @param p_textureDesc
+	* @param p_useDepth
+	* @param p_useStencil
+	*/
+	void SetupFramebuffer(
+		OvRendering::HAL::Framebuffer& p_framebuffer,
+		const OvRendering::Settings::TextureDesc& p_textureDesc,
+		bool p_useDepth = true,
+		bool p_useStencil = false
+	);
+
 	/**
 	* Prepare the given framebuffer for rendering by attaching
 	* the necessary textures and renderbuffers

Sources/Overload/OvCore/include/OvCore/Helpers/Serializer.h

@@ -0,0 +1,36 @@
+/**
+* @project: Overload
+* @author: Overload Tech.
+* @licence: MIT
+*/
+
+#pragma once
+
+#include <array>
+
+#include <OvRendering/HAL/Framebuffer.h>
+#include <OvTools/Utils/CircularIterator.h>
+
+namespace OvCore::Rendering
+{
+	/**
+	* Convenient ping-pong buffer holding two framebuffers
+	*/
+	class PingPongFramebuffer : public OvTools::Utils::CircularIterator<OvRendering::HAL::Framebuffer, 2>
+	{
+	public:
+		/**
+		* Create a ping pong buffer
+		* @param p_debugName
+		*/
+		PingPongFramebuffer(std::string_view p_debugName = std::string_view{});
+
+		/**
+		* Return the two framebuffers
+		*/
+		std::array<OvRendering::HAL::Framebuffer, 2>& GetFramebuffers();
+
+	private:
+		std::array<OvRendering::HAL::Framebuffer, 2> m_framebuffers;
+	};
+}

Sources/Overload/OvCore/include/OvCore/Rendering/FramebufferUtil.h

@@ -6,22 +6,27 @@
 
 #pragma once
 
+#include <OvCore/Rendering/PingPongFramebuffer.h>
 #include <OvCore/Rendering/PostProcess/AEffect.h>
 #include <OvRendering/Data/Material.h>
 #include <OvRendering/HAL/Framebuffer.h>
 
 namespace OvCore::Rendering::PostProcess
 {
+	namespace BloomConstants
+	{
+		constexpr uint32_t kMinPassCount = 1;
+		constexpr uint32_t kMaxPassCount = 10;
+		constexpr float kMaxBloomIntensity = 1.0f / 0.04f; // 0.04f being the default internal interpolation factor.
+	}
+
 	/**
 	* Settings for the BloomEffect
 	*/
 	struct BloomSettings : public EffectSettings
 	{
-		float threshold = 1.0f;
-		float radius = 5.0f;
-		int kernelSize = 6;
-		float intensity = 0.6f;
-		int passes = 10;
+		float intensity = 1.0f;
+		int passes = 6;
 	};
 
 	/**
@@ -60,9 +65,11 @@ namespace OvCore::Rendering::PostProcess
 		) override;
 
 	private:
-		std::array<OvRendering::HAL::Framebuffer, 2> m_bloomPingPong;
-		OvRendering::Data::Material m_brightnessMaterial;
-		OvRendering::Data::Material m_blurMaterial;
+		std::array<OvRendering::HAL::Framebuffer, BloomConstants::kMaxPassCount> m_bloomSamplingBuffers;
+		OvRendering::HAL::Framebuffer m_bloomOutputBuffer;
+		OvRendering::Data::Material m_downsamplingMaterial;
+		OvRendering::Data::Material m_upsamplingMaterial;
 		OvRendering::Data::Material m_bloomMaterial;
+		OvRendering::Data::Material m_blitMaterial;
 	};
 }