Tonemapping: Adding bloom

include/anki/gr/gl/RenderingThread.h

@@ -15,7 +15,7 @@ namespace anki {
 /// @addtogroup opengl
 /// @{
 
-#define ANKI_DISABLE_GL_RENDERING_THREAD 1
+#define ANKI_DISABLE_GL_RENDERING_THREAD 0
 
 /// Command queue. It's essentialy a queue of command buffers waiting for 
 /// execution and a server

include/anki/renderer/Hdr.h → include/anki/renderer/Bloom.h

@@ -3,8 +3,8 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#ifndef ANKI_RENDERER_HDR_H
-#define ANKI_RENDERER_HDR_H
+#ifndef ANKI_RENDERER_BLOOM_H
+#define ANKI_RENDERER_BLOOM_H
 
 #include "anki/renderer/RenderingPass.h"
 #include "anki/Gr.h"
@@ -20,23 +20,20 @@ class ShaderProgram;
 /// @addtogroup renderer
 /// @{
 
-/// High dynamic range lighting pass
-class Hdr: public RenderingPass
+/// Bloom pass.
+class Bloom: public RenderingPass
 {
 	friend class Pps;
 
 public:
-	/// @name Accessors
-	/// @{
-	F32 getExposure() const
-	{
-		return m_exposure;
-	}
-	void setExposure(const F32 x)
-	{
-		m_exposure = x;
-		m_parameterUpdateTimestamp = getGlobalTimestamp();
-	}
+	Bloom(Renderer* r)
+	:	RenderingPass(r)
+	{}
+
+	~Bloom();
+
+	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
+	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
 
 	U32 getBlurringIterationsCount() const
 	{
@@ -46,21 +43,20 @@ public:
 	{
 		m_blurringIterationsCount = x;
 	}
-	/// @}
 
 	/// @privatesection
 	/// @{
-	TextureHandle& _getRt()
+	TextureHandle& getRt()
 	{
 		return m_vblurRt;
 	}
 
-	U32 _getWidth() const
+	U32 getWidth() const
 	{
 		return m_width;
 	}
 
-	U32 _getHeight() const
+	U32 getHeight() const
 	{
 		return m_height;
 	}
@@ -68,7 +64,7 @@ public:
 
 private:
 	U32 m_width, m_height;
-	F32 m_exposure = 4.0; ///< How bright is the HDR
+	F32 m_threshold = 10.0; ///< How bright it is
 	U32 m_blurringIterationsCount = 2; ///< The blurring iterations
 	F32 m_blurringDist = 1.0; ///< Distance in blurring
 	
@@ -91,15 +87,6 @@ private:
 	Timestamp m_commonUboUpdateTimestamp = 0;
 	BufferHandle m_commonBuff;
 
-	Hdr(Renderer* r)
-	:	RenderingPass(r)
-	{}
-
-	~Hdr();
-
-	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
-	ANKI_USE_RESULT Error run(CommandBufferHandle& jobs);
-
 	ANKI_USE_RESULT Error initFb(FramebufferHandle& fb, TextureHandle& rt);
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 

include/anki/renderer/Common.h

@@ -13,6 +13,7 @@ namespace anki {
 // Forward
 class Fs;
 class Tm;
+class Bloom;
 
 // Render target formats
 const U MS_COLOR_ATTACHMENTS_COUNT = 2;

include/anki/renderer/Pps.h

@@ -10,7 +10,6 @@
 #include "anki/Gr.h"
 #include "anki/resource/TextureResource.h"
 #include "anki/resource/Resource.h"
-#include "anki/renderer/Hdr.h"
 #include "anki/renderer/Ssao.h"
 #include "anki/renderer/Bl.h"
 #include "anki/renderer/Lf.h"
@@ -30,13 +29,14 @@ class Pps: public RenderingPass
 	friend class Renderer;
 
 public:
-	const Hdr& getHdr() const
+	const Bloom& getBloom() const
 	{
-		return m_hdr;
+		return *m_bloom;
 	}
-	Hdr& getHdr()
+
+	Bloom& getBloom()
 	{
-		return m_hdr;
+		return *m_bloom;
 	}
 
 	const Ssao& getSsao() const
@@ -75,6 +75,16 @@ public:
 		return m_sslr;
 	}
 
+	const Tm& getTm() const
+	{
+		return *m_tm;
+	}
+
+	Tm& getTm()
+	{
+		return *m_tm;
+	}
+
 	/// Load the color grading texture.
 	Error loadColorGradingTexture(CString filename);
 
@@ -92,7 +102,7 @@ public:
 
 private:
 	Tm* m_tm = nullptr;
-	Hdr m_hdr;
+	Bloom* m_bloom;
 	Ssao m_ssao;
 	Bl m_bl;
 	Lf m_lf;

shaders/Pps.frag.glsl

@@ -5,12 +5,12 @@
 
 #pragma anki type frag
 #pragma anki include "shaders/Common.glsl"
-#pragma anki include "shaders/photoshop_filters.glsl"
+#pragma anki include "shaders/Tonemapping.glsl"
 #pragma anki include "shaders/LinearDepth.glsl"
 
 layout(binding = 0) uniform lowp sampler2D u_isRt;
 layout(binding = 1) uniform lowp sampler2D u_ppsSsaoRt;
-layout(binding = 2) uniform lowp sampler2D u_ppsHdrLfRt;
+layout(binding = 2) uniform lowp sampler2D u_ppsBloomLfRt;
 layout(binding = 3) uniform lowp sampler3D u_lut;
 
 layout(std140, binding = 0) readonly buffer _blk
@@ -105,6 +105,7 @@ vec3 colorGrading(in vec3 color)
 	return textureLod(u_lut, lutCoords, 0.0).rgb;
 }
 
+#if 0
 //==============================================================================
 // Uncharted 2 tonemap operator
 // @param l Luminance
@@ -147,6 +148,7 @@ vec3 tonemap(in vec3 color)
 
 	return pow(color / l, vec3(SATURATION)) * ld;
 }
+#endif
 
 //==============================================================================
 void main()
@@ -155,7 +157,7 @@ void main()
 	out_color = sharpen(u_isRt, in_texCoords);
 #else
 	out_color = textureRt(u_isRt, in_texCoords).rgb;
-	out_color = tonemap(out_color);
+	out_color = tonemap(out_color, u_averageLuminancePad3.x, 0.0);
 #endif
 
 #if SSAO_ENABLED
@@ -163,22 +165,17 @@ void main()
 	out_color *= ssao;
 #endif
 
-#if HDR_ENABLED
-	vec3 hdr = textureRt(u_ppsHdrLfRt, in_texCoords).rgb;
-	out_color += hdr;
-#endif
-
-#if 0
-	out_color = BlendHardLight(vec3(0.7, 0.72, 0.4), out_color);
-	//out_color = gammaCorrectionRgb(vec3(0.9, 0.92, 0.75), out_color);
+#if BLOOM_ENABLED
+	vec3 bloom = textureRt(u_ppsBloomLfRt, in_texCoords).rgb;
+	out_color += bloom;
 #endif
 
 	out_color = colorGrading(out_color);
 
 #if 0
-	if(gl_FragCoord.x > 2400 && gl_FragCoord.y > 1200)
+	if(out_color.x != 0.0000001)
 	{
-		out_color = vec3(u_averageLuminancePad3.x);
+		out_color = hdr;
 	}
 #endif
 }

shaders/PpsHdr.frag.glsl → shaders/PpsBloom.frag.glsl

@@ -5,15 +5,20 @@
 
 #pragma anki type frag
 #pragma anki include "shaders/Common.glsl"
+#pragma anki include "shaders/Tonemapping.glsl"
 
 // Vars
 layout(binding = 0) uniform lowp sampler2D u_tex; ///< Its the IS RT
 
-layout(std140) uniform _blk
+layout(std140, binding = 0) uniform _blk
 {
-	vec4 u_exposurePad3;
+	vec4 u_thresholdPad3;
+};
+
+layout(std140, binding = 0) readonly buffer _blk1
+{
+	vec4 u_averageLuminancePad3;
 };
-#define u_exposure u_exposurePad3.x
 
 layout(location = 0) in vec2 in_texCoord;
 layout(location = 0) out vec3 out_color;
@@ -21,8 +26,6 @@ layout(location = 0) out vec3 out_color;
 // Consts
 const uint MIPMAP = 6;
 
-const float BRIGHT_MAX = 5.0;
-
 vec3 readTexture(in uint mipmap)
 {
 	uint w = ANKI_RENDERER_WIDTH / (2 << (mipmap - 1));
@@ -39,20 +42,10 @@ vec3 readTexture(in uint mipmap)
 
 void main()
 {
-	vec3 color = vec3(0.0);
+	out_color = readTexture(MIPMAP);
+	out_color += readTexture(MIPMAP - 1);
+	out_color += readTexture(MIPMAP - 2);
 	
-	color += readTexture(MIPMAP);
-	color += readTexture(MIPMAP - 1);
-	color += readTexture(MIPMAP - 2);
-	
-	color /= 3.0;
-
-#if 1
-	float luminance = dot(vec3(0.30, 0.59, 0.11), color);
-	float yd = u_exposure * (u_exposure / BRIGHT_MAX + 1.0) /
-		(u_exposure + 1.0) * luminance;
-	color *= yd;
-#endif
-
-	out_color = color;
+	out_color /= 3.0;
+	out_color = tonemap(out_color, u_averageLuminancePad3.x, u_thresholdPad3.x);
 }

shaders/PpsTmAverageLuminance.comp.glsl

@@ -75,11 +75,11 @@ void main()
 	if(gl_LocalInvocationIndex == 0)
 	{
 		float crntLum = exp(g_avgLum[0] / float(WORKGROUP_SIZE));
-#if 0
+#if 1
 		float prevLum = u_averageLuminancePad3.x;
 
 		// Lerp between previous and new L value
-		const float INTERPOLATION_FACTOR = 0.5;
+		const float INTERPOLATION_FACTOR = 0.05;
 		u_averageLuminancePad3.x = prevLum * (1.0 - INTERPOLATION_FACTOR) 
 			+ crntLum * INTERPOLATION_FACTOR;
 #else

shaders/Tonemapping.glsl

@@ -0,0 +1,60 @@
+// Copyright (C) 2009-2015, Panagiotis Christopoulos Charitos.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#ifndef ANKI_SHADERS_TONEMAP_GLSL
+#define ANKI_SHADERS_TONEMAP_GLSL
+
+#pragma anki include "shaders/Common.glsl"
+
+// A tick to compute log of base 10
+float log10(in float x)
+{
+	return log(x) / log(10.0);
+}
+
+float computeLuminance(in vec3 color)
+{
+	return dot(vec3(0.30, 0.59, 0.11), color);
+}
+
+vec3 computeExposedColor(in vec3 color, in float avgLum, in float threshold)
+{
+	float keyValue = 1.03 - (2.0 / (2.0 + log10(avgLum + 1.0)));
+	float linearExposure = (keyValue / avgLum);
+	float exposure = log2(max(EPSILON, linearExposure));
+
+	exposure -= threshold;
+	return exp2(exposure) * color;
+}
+
+// Reinhard operator
+vec3 tonemapReinhard(in vec3 color, in float saturation)
+{
+	float lum = computeLuminance(color);   
+	float toneMappedLuminance = lum / (lum + 1.0);
+	return toneMappedLuminance * pow(color / lum, vec3(saturation));   
+}
+
+// Uncharted 2 operator
+vec3 tonemapUncharted2(in vec3 color)
+{
+	const float A = 0.15;
+	const float B = 0.50;
+	const float C = 0.10;
+	const float D = 0.20;
+	const float E = 0.02;
+	const float F = 0.30;
+
+	return ((color * (A * color + C * B) + D * E) 
+		/ (color * (A * color + B) + D * F)) - E / F;
+}
+
+vec3 tonemap(in vec3 color, in float avgLum, in float threshold)
+{
+	vec3 c = computeExposedColor(color, avgLum, threshold);
+	return tonemapReinhard(c, 1.0);
+}
+
+#endif

src/core/Config.cpp

@@ -32,12 +32,12 @@ Config::Config()
 	newOption("is.maxLightsPerTile", 16);
 
 	// Pps
-	newOption("pps.hdr.enabled", true);
-	newOption("pps.hdr.renderingQuality", 0.5);
-	newOption("pps.hdr.blurringDist", 1.0);
-	newOption("pps.hdr.samples", 5);
-	newOption("pps.hdr.blurringIterationsCount", 1);
-	newOption("pps.hdr.exposure", 4.0);
+	newOption("pps.bloom.enabled", true);
+	newOption("pps.bloom.renderingQuality", 0.5);
+	newOption("pps.bloom.blurringDist", 1.0);
+	newOption("pps.bloom.samples", 5);
+	newOption("pps.bloom.blurringIterationsCount", 1);
+	newOption("pps.bloom.threshold", 1.0);
 
 	newOption("pps.ssao.enabled", true);
 	newOption("pps.ssao.renderingQuality", 0.3);

src/renderer/Hdr.cpp → src/renderer/Bloom.cpp

@@ -3,18 +3,19 @@
 // Code licensed under the BSD License.
 // http://www.anki3d.org/LICENSE
 
-#include "anki/renderer/Hdr.h"
+#include "anki/renderer/Bloom.h"
 #include "anki/renderer/Renderer.h"
+#include "anki/renderer/Tm.h"
 #include "anki/misc/ConfigSet.h"
 
 namespace anki {
 
 //==============================================================================
-Hdr::~Hdr()
+Bloom::~Bloom()
 {}
 
 //==============================================================================
-Error Hdr::initFb(FramebufferHandle& fb, TextureHandle& rt)
+Error Bloom::initFb(FramebufferHandle& fb, TextureHandle& rt)
 {
 	// Set to bilinear because the blurring techniques take advantage of that
 	ANKI_CHECK(m_r->createRenderTarget(m_width, m_height, 
@@ -33,26 +34,26 @@ Error Hdr::initFb(FramebufferHandle& fb, TextureHandle& rt)
 }
 
 //==============================================================================
-Error Hdr::initInternal(const ConfigSet& initializer)
+Error Bloom::initInternal(const ConfigSet& initializer)
 {
-	m_enabled = initializer.get("pps.hdr.enabled");
+	m_enabled = initializer.get("pps.bloom.enabled");
 
 	if(!m_enabled)
 	{
 		return ErrorCode::NONE;
 	}
 
-	const F32 renderingQuality = initializer.get("pps.hdr.renderingQuality");
+	const F32 renderingQuality = initializer.get("pps.bloom.renderingQuality");
 
 	m_width = renderingQuality * (F32)m_r->getWidth();
 	alignRoundDown(16, m_width);
 	m_height = renderingQuality * (F32)m_r->getHeight();
 	alignRoundDown(16, m_height);
 
-	m_exposure = initializer.get("pps.hdr.exposure");
-	m_blurringDist = initializer.get("pps.hdr.blurringDist");
+	m_threshold = initializer.get("pps.bloom.threshold");
+	m_blurringDist = initializer.get("pps.bloom.blurringDist");
 	m_blurringIterationsCount = 
-		initializer.get("pps.hdr.blurringIterationsCount");
+		initializer.get("pps.bloom.blurringIterationsCount");
 
 	ANKI_CHECK(initFb(m_hblurFb, m_hblurRt));
 	ANKI_CHECK(initFb(m_vblurFb, m_vblurRt));
@@ -70,7 +71,7 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 	cmdb.flush();
 
 	ANKI_CHECK(m_toneFrag.loadToCache(&getResourceManager(),
-		"shaders/PpsHdr.frag.glsl", 
+		"shaders/PpsBloom.frag.glsl", 
 		m_r->_getShadersPrependedSource().toCString(), "r_"));
 
 	ANKI_CHECK(m_r->createDrawQuadPipeline(
@@ -117,20 +118,19 @@ Error Hdr::initInternal(const ConfigSet& initializer)
 }
 
 //==============================================================================
-Error Hdr::init(const ConfigSet& initializer)
+Error Bloom::init(const ConfigSet& initializer)
 {
 	Error err = initInternal(initializer);
-
 	if(err)
 	{
-		ANKI_LOGE("Failed to init PPS HDR");
+		ANKI_LOGE("Failed to init PPS bloom");
 	}
 
 	return err;
 }
 
 //==============================================================================
-Error Hdr::run(CommandBufferHandle& cmdb)
+Error Bloom::run(CommandBufferHandle& cmdb)
 {
 	ANKI_ASSERT(m_enabled);
 
@@ -151,6 +151,7 @@ Error Hdr::run(CommandBufferHandle& cmdb)
 
 	m_r->getIs()._getRt().bind(cmdb, 0);
 	m_commonBuff.bindShaderBuffer(cmdb, 0);
+	m_r->getPps().getTm().getAverageLuminanceBuffer().bindShaderBuffer(cmdb, 0);
 
 	m_r->drawQuad(cmdb);
 
@@ -181,9 +182,9 @@ Error Hdr::run(CommandBufferHandle& cmdb)
 }
 
 //==============================================================================
-void Hdr::updateDefaultBlock(CommandBufferHandle& cmdb)
+void Bloom::updateDefaultBlock(CommandBufferHandle& cmdb)
 {
-	Vec4 uniform(m_exposure, 0.0, 0.0, 0.0);
+	Vec4 uniform(m_threshold, 0.0, 0.0, 0.0);
 	m_commonBuff.write(cmdb, &uniform, sizeof(uniform), 0, 0, sizeof(uniform));
 }
 

src/renderer/Lf.cpp

@@ -4,6 +4,7 @@
 // http://www.anki3d.org/LICENSE
 
 #include "anki/renderer/Lf.h"
+#include "anki/renderer/Bloom.h"
 #include "anki/renderer/Renderer.h"
 #include "anki/scene/SceneGraph.h"
 #include "anki/scene/MoveComponent.h"
@@ -65,8 +66,8 @@ Error Lf::initPseudo(const ConfigSet& config)
 
 	pps.sprintf(
 		"#define TEX_DIMENSIONS vec2(%u.0, %u.0)\n", 
-		m_r->getPps().getHdr()._getWidth(),
-		m_r->getPps().getHdr()._getHeight());
+		m_r->getPps().getBloom().getWidth(),
+		m_r->getPps().getBloom().getHeight());
 
 	ANKI_CHECK(m_pseudoFrag.loadToCache(&getResourceManager(), 
 		"shaders/PpsLfPseudoPass.frag.glsl", pps.toCString(), "r_"));
@@ -154,7 +155,7 @@ Error Lf::initOcclusion(const ConfigSet& config)
 Error Lf::initInternal(const ConfigSet& config)
 {
 	m_enabled = config.get("pps.lf.enabled") 
-		&& config.get("pps.hdr.enabled");
+		&& config.get("pps.bloom.enabled");
 	if(!m_enabled)
 	{
 		return ErrorCode::NONE;
@@ -165,8 +166,8 @@ Error Lf::initInternal(const ConfigSet& config)
 	ANKI_CHECK(initOcclusion(config));
 
 	// Create the render target
-	ANKI_CHECK(m_r->createRenderTarget(m_r->getPps().getHdr()._getWidth(), 
-		m_r->getPps().getHdr()._getHeight(), 
+	ANKI_CHECK(m_r->createRenderTarget(m_r->getPps().getBloom().getWidth(), 
+		m_r->getPps().getBloom().getHeight(), 
 		PixelFormat(ComponentFormat::R8G8B8, TransformFormat::UNORM), 
 		1, SamplingFilter::LINEAR, 1, m_rt));
 
@@ -273,13 +274,13 @@ Error Lf::run(CommandBufferHandle& cmdBuff)
 
 	// Set the common state
 	m_fb.bind(cmdBuff);
-	cmdBuff.setViewport(0, 0, m_r->getPps().getHdr()._getWidth(), 
-		m_r->getPps().getHdr()._getHeight());
+	cmdBuff.setViewport(0, 0, m_r->getPps().getBloom().getWidth(), 
+		m_r->getPps().getBloom().getHeight());
 
 	m_pseudoPpline.bind(cmdBuff);
 
 	Array<TextureHandle, 2> tarr = {{
-		m_r->getPps().getHdr()._getRt(), 
+		m_r->getPps().getBloom().getRt(), 
 		m_lensDirtTex->getGlTexture()}};
 	cmdBuff.bindTextures(0, tarr.begin(), tarr.getSize());
 
@@ -395,7 +396,7 @@ Error Lf::run(CommandBufferHandle& cmdBuff)
 
 	// Blit the HDR RT back to LF RT
 	//
-	m_r->getPps().getHdr()._getRt().bind(cmdBuff, 0);
+	m_r->getPps().getBloom().getRt().bind(cmdBuff, 0);
 	m_blitPpline.bind(cmdBuff);
 	m_r->drawQuad(cmdBuff);
 

src/renderer/Pps.cpp

@@ -5,7 +5,7 @@
 
 #include "anki/renderer/Pps.h"
 #include "anki/renderer/Renderer.h"
-#include "anki/renderer/Hdr.h"
+#include "anki/renderer/Bloom.h"
 #include "anki/renderer/Ssao.h"
 #include "anki/renderer/Tm.h"
 #include "anki/util/Logger.h"
@@ -16,7 +16,6 @@ namespace anki {
 //==============================================================================
 Pps::Pps(Renderer* r)
 :	RenderingPass(r), 
-	m_hdr(r), 
 	m_ssao(r), 
 	m_bl(r), 
 	m_lf(r),
@@ -48,7 +47,10 @@ Error Pps::initInternal(const ConfigSet& config)
 	ANKI_CHECK(m_tm->create(config));
 
 	ANKI_CHECK(m_ssao.init(config));
-	ANKI_CHECK(m_hdr.init(config));
+
+	m_bloom = getAllocator().newInstance<Bloom>(m_r);
+	ANKI_CHECK(m_bloom->init(config));
+
 	ANKI_CHECK(m_lf.init(config));
 	ANKI_CHECK(m_sslr.init(config));
 
@@ -71,13 +73,13 @@ Error Pps::initInternal(const ConfigSet& config)
 
 	pps.sprintf(
 		"#define SSAO_ENABLED %u\n"
-		"#define HDR_ENABLED %u\n"
+		"#define BLOOM_ENABLED %u\n"
 		"#define SHARPEN_ENABLED %u\n"
 		"#define GAMMA_CORRECTION_ENABLED %u\n"
 		"#define FBO_WIDTH %u\n"
 		"#define FBO_HEIGHT %u\n",
 		m_ssao.getEnabled(), 
-		m_hdr.getEnabled(), 
+		m_bloom->getEnabled(), 
 		U(config.get("pps.sharpen")),
 		U(config.get("pps.gammaCorrection")),
 		m_r->getWidth(),
@@ -131,9 +133,9 @@ Error Pps::run(CommandBufferHandle& cmdb)
 
 	m_tm->run(cmdb);
 
-	if(m_hdr.getEnabled())
+	if(m_bloom->getEnabled())
 	{
-		ANKI_CHECK(m_hdr.run(cmdb));
+		ANKI_CHECK(m_bloom->run(cmdb));
 	}
 
 	if(m_lf.getEnabled())
@@ -172,9 +174,9 @@ Error Pps::run(CommandBufferHandle& cmdb)
 	{
 		m_lf._getRt().bind(cmdb, 2);
 	}
-	else if(m_hdr.getEnabled())
+	else if(m_bloom->getEnabled())
 	{
-		m_hdr._getRt().bind(cmdb, 2);
+		m_bloom->getRt().bind(cmdb, 2);
 	}
 
 	m_lut->getGlTexture().bind(cmdb, 3);

src/renderer/Tm.cpp

@@ -33,8 +33,9 @@ Error Tm::create(const ConfigSet& initializer)
 	ANKI_CHECK(m_luminancePpline.create(&getGrManager(), pplineInit));
 
 	// Create buffer
+	Vec4 data(0.5);
 	ANKI_CHECK(m_luminanceBuff.create(&getGrManager(), GL_SHADER_STORAGE_BUFFER,
-		nullptr, sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
+		&data[0], sizeof(Vec4), GL_DYNAMIC_STORAGE_BIT));
 
 	return ErrorCode::NONE;
 }

testapp/Main.cpp

@@ -489,12 +489,12 @@ Error initSubsystems(int argc, char* argv[])
 	config.set("is.sm.poissonEnabled", false);
 	config.set("is.sm.resolution", 1024);
 	config.set("pps.enabled", true);
-	config.set("pps.hdr.enabled", true);
-	config.set("pps.hdr.renderingQuality", 0.5);
-	config.set("pps.hdr.blurringDist", 1.0);
-	config.set("pps.hdr.blurringIterationsCount", 3);
-	config.set("pps.hdr.exposure", 15.0);
-	config.set("pps.hdr.samples", 17);
+	config.set("pps.bloom.enabled", true);
+	config.set("pps.bloom.renderingQuality", 0.5);
+	config.set("pps.bloom.blurringDist", 1.0);
+	config.set("pps.bloom.blurringIterationsCount", 3);
+	config.set("pps.bloom.threshold", 1.0);
+	config.set("pps.bloom.samples", 17);
 	config.set("pps.sslr.enabled", false);
 	config.set("pps.sslr.renderingQuality", 0.5);
 	config.set("pps.sslr.blurringIterationsCount", 1);