Optimizing bandwidth and introducing skeleton for SSLR

include/anki/renderer/Lf.h

@@ -42,10 +42,14 @@ private:
 	GlProgramPipelineHandle m_pseudoPpline;
 
 	// Sprite billboards
-	ProgramResourcePointer m_realVert; 
+	ProgramResourcePointer m_realVert;
 	ProgramResourcePointer m_realFrag;
 	GlProgramPipelineHandle m_realPpline;
 
+	// Final HDR blit
+	ProgramResourcePointer m_blitFrag;
+	GlProgramPipelineHandle m_blitPpline;
+
 	GlTextureHandle m_rt;
 	GlFramebufferHandle m_fb;
 

include/anki/renderer/Ssao.h

@@ -14,11 +14,11 @@ namespace anki {
 /// @{
 
 /// Screen space ambient occlusion pass
-class Ssao: public SwitchableRenderingPass
+class Ssao: public OptionalRenderingPass
 {
 public:
 	Ssao(Renderer* r)
-		: SwitchableRenderingPass(r)
+		: OptionalRenderingPass(r)
 	{}
 
 	void init(const RendererInitializer& initializer);

include/anki/renderer/Sslr.h

@@ -0,0 +1,39 @@
+#ifndef ANKI_RENDERER_SSLR_H
+#define ANKI_RENDERER_SSLR_H
+
+#include "anki/renderer/RenderingPass.h"
+#include "anki/resource/Resource.h"
+#include "anki/Gl.h"
+
+namespace anki {
+
+/// @addtogroup renderer
+/// @{
+
+/// Screen space local reflections pass
+class Sslr: public OptionalRenderingPass
+{
+public:
+	Sslr(Renderer* r)
+		: OptionalRenderingPass(r)
+	{}
+
+	void init(const RendererInitializer& initializer);
+	void run(GlJobChainHandle& jobs);
+
+private:
+	U32 m_width;
+	U32 m_height;
+
+	GlFramebufferHandle m_fb;
+	GlTextureHandle m_rt;
+
+	ProgramResourcePointer m_reflectionFrag;
+	GlProgramPipelineHandle m_reflectionPpline;
+};
+
+/// @}
+
+} // end namespace anki
+
+#endif

shaders/Blit.frag.glsl

@@ -0,0 +1,14 @@
+#pragma anki type frag
+#pragma anki include "shaders/Common.glsl"
+
+layout(binding = 0) uniform lowp sampler2D uTex;
+
+layout(location = 0) in vec2 inTexCoords;
+
+layout(location = 0) out vec3 outColor;
+
+void main()
+{
+	outColor = textureRt(uTex, inTexCoords).rgb;
+}
+

shaders/Pps.frag.glsl

@@ -5,8 +5,7 @@
 
 layout(binding = 0) uniform lowp sampler2D uIsRt;
 layout(binding = 1) uniform lowp sampler2D uPpsSsaoRt;
-layout(binding = 2) uniform lowp sampler2D uPpsHdrRt;
-layout(binding = 3) uniform lowp sampler2D uPpsLfRt;
+layout(binding = 2) uniform lowp sampler2D uPpsHdrLfRt;
 
 layout(location = 0) in vec2 inTexCoords;
 
@@ -92,19 +91,14 @@ void main()
 #endif
 	//outColor = erosion(uIsRt, inTexCoords);
 
-#if HDR_ENABLED
-	vec3 hdr = textureRt(uPpsHdrRt, inTexCoords).rgb;
-	outColor += hdr;
-#endif
-
 #if SSAO_ENABLED
 	float ssao = textureRt(uPpsSsaoRt, inTexCoords).r;
 	outColor *= ssao;
 #endif
 
-#if LF_ENABLED
-	vec3 lf = textureRt(uPpsLfRt, inTexCoords).rgb;
-	outColor += lf;
+#if HDR_ENABLED
+	vec3 hdr = textureRt(uPpsHdrLfRt, inTexCoords).rgb;
+	outColor += hdr;
 #endif
 
 #if GAMMA_CORRECTION_ENABLED

src/renderer/Lf.cpp

@@ -128,6 +128,11 @@ void Lf::initInternal(const RendererInitializer& initializer)
 	// Textures
 	m_lensDirtTex.load("engine_data/lens_dirt.ankitex");
 
+	// Blit
+	m_blitFrag.load("shaders/Blit.frag.glsl");
+	m_blitPpline = m_r->createDrawQuadProgramPipeline(
+		m_blitFrag->getGlProgram());
+
 	jobs.flush();
 }
 
@@ -308,6 +313,12 @@ void Lf::run(GlJobChainHandle& jobs)
 		offset += buffSize;
 	}
 
+	// Blit the HDR RT back to LF RT
+	//
+	m_r->getPps().getHdr().getRt().bind(jobs, 0);
+	m_blitPpline.bind(jobs);
+	m_r->drawQuad(jobs);
+
 	jobs.enableBlend(false);
 }
 

src/renderer/Pps.cpp

@@ -48,7 +48,6 @@ void Pps::initInternal(const RendererInitializer& initializer)
 
 	pps << "#define SSAO_ENABLED " << (U)m_ssao.getEnabled() << "\n"
 		<< "#define HDR_ENABLED " << (U)m_hdr.getEnabled() << "\n"
-		<< "#define LF_ENABLED " << (U)m_lf.getEnabled() << "\n"
 		<< "#define SHARPEN_ENABLED " << (U)initializer.get("pps.sharpen") 
 			<< "\n"
 		<< "#define GAMMA_CORRECTION_ENABLED " 
@@ -122,13 +121,14 @@ void Pps::run(GlJobChainHandle& jobs)
 	{
 		m_ssao.getRt().bind(jobs, 1);
 	}
-	if(m_hdr.getEnabled())
+
+	if(m_lf.getEnabled())
 	{
-		m_hdr.getRt().bind(jobs, 2);
+		m_lf.getRt().bind(jobs, 2);
 	}
-	if(m_lf.getEnabled())
+	else if(m_hdr.getEnabled())
 	{
-		m_lf.getRt().bind(jobs, 3);
+		m_hdr.getRt().bind(jobs, 2);
 	}
 
 	m_r->drawQuad(jobs);

src/renderer/Sslr.cpp

@@ -0,0 +1,59 @@
+#include "anki/renderer/Sslr.h"
+#include "anki/renderer/Renderer.h"
+#include <sstream>
+
+namespace anki {
+
+//==============================================================================
+void Sslr::init(const RendererInitializer& initializer)
+{
+	m_enabled = initializer.get("pps.sslr.enabled");
+
+	if(!m_enabled)
+	{
+		return;
+	}
+
+	// Size
+	const F32 quality = initializer.get("pps.sslr.renderingQuality");
+
+	m_width = quality * (F32)m_r->getWidth();
+	alignRoundUp(16, m_width);
+	m_height = quality * (F32)m_r->getHeight();
+	alignRoundUp(16, m_height);
+
+	// Programs
+	std::stringstream pps;
+
+	m_reflectionFrag.load(ProgramResource::createSrcCodeToCache(
+		"shaders/PpsSslr.frag.glsl", pps.str().c_str(), "r_").c_str());
+
+	m_reflectionPpline = m_r->createDrawQuadProgramPipeline(
+		m_reflectionFrag->getGlProgram());
+
+	// Fb
+	m_r->createRenderTarget(m_width, m_height, GL_RGB, GL_RGB8, 
+		GL_UNSIGNED_BYTE, 1, m_rt);
+
+	GlManager& gl = GlManagerSingleton::get();
+	GlJobChainHandle jobs(&gl);
+
+	m_fb = GlFramebufferHandle(jobs, {{m_rt, GL_COLOR_ATTACHMENT0}});
+
+	jobs.finish();
+}
+
+//==============================================================================
+void Sslr::run(GlJobChainHandle& jobs)
+{
+	ANKI_ASSERT(m_enabled);
+
+	m_fb.bind(jobs, true);
+	jobs.setViewport(0, 0, m_width, m_height);
+
+	m_r->drawQuad(jobs);
+}
+
+
+} // end namespace anki
+

testapp/Main.cpp

@@ -540,7 +540,7 @@ void mainLoop()
 
 		// Sleep
 		//
-#if 1
+#if 0
 		timer.stop();
 		if(timer.getElapsedTime() < AppSingleton::get().getTimerTick())
 		{