Use downscale blur's result on SSR

AnKi/Renderer/DownscaleBlur.cpp

@@ -5,7 +5,7 @@
 
 #include <AnKi/Renderer/DownscaleBlur.h>
 #include <AnKi/Renderer/Renderer.h>
-#include <AnKi/Renderer/Scale.h>
+#include <AnKi/Renderer/LightShading.h>
 #include <AnKi/Renderer/Tonemapping.h>
 #include <AnKi/Core/CVarSet.h>
 #include <AnKi/Util/Tracer.h>
@@ -26,9 +26,9 @@ Error DownscaleBlur::init()
 Error DownscaleBlur::initInternal()
 {
 	m_passCount =
-		computeMaxMipmapCount2d(getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y(), kDownscaleBurDownTo) - 1;
+		computeMaxMipmapCount2d(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(), kDownscaleBurDownTo) - 1;
 
-	const UVec2 rez = getRenderer().getPostProcessResolution() / 2;
+	const UVec2 rez = getRenderer().getInternalResolution() / 2;
 	ANKI_R_LOGV("Initializing downscale pyramid. Resolution %ux%u, mip count %u", rez.x(), rez.y(), m_passCount);
 
 	const Bool preferCompute = g_preferComputeCVar.get();
@@ -38,7 +38,7 @@ Error DownscaleBlur::initInternal()
 	texinit.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 	if(preferCompute)
 	{
-		texinit.m_usage |= TextureUsageBit::kSampledCompute | TextureUsageBit::kUavComputeWrite;
+		texinit.m_usage |= TextureUsageBit::kUavComputeWrite;
 	}
 	else
 	{
@@ -77,68 +77,48 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
 	// Create passes
-	static constexpr Array<CString, 8> passNames = {"DownBlur #0",  "Down/Blur #1", "Down/Blur #2", "Down/Blur #3",
+	static constexpr Array<CString, 8> passNames = {"Down/Blur #0", "Down/Blur #1", "Down/Blur #2", "Down/Blur #3",
 													"Down/Blur #4", "Down/Blur #5", "Down/Blur #6", "Down/Blur #7"};
-	const RenderTargetHandle inRt =
-		(getRenderer().getScale().hasUpscaledHdrRt()) ? getRenderer().getScale().getUpscaledHdrRt() : getRenderer().getScale().getTonemappedRt();
-	if(g_preferComputeCVar.get())
+	const RenderTargetHandle inRt = getRenderer().getLightShading().getRt();
+
+	for(U32 i = 0; i < m_passCount; ++i)
 	{
-		for(U32 i = 0; i < m_passCount; ++i)
+		RenderPassDescriptionBase* ppass;
+		if(g_preferComputeCVar.get())
 		{
-			ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass(passNames[i]);
-			pass.setWork([this, i](RenderPassWorkContext& rgraphCtx) {
-				run(i, rgraphCtx);
-			});
-
-			if(i > 0)
-			{
-				TextureSubresourceInfo sampleSubresource;
-				TextureSubresourceInfo renderSubresource;
-
-				sampleSubresource.m_firstMipmap = i - 1;
-				renderSubresource.m_firstMipmap = i;
-
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, renderSubresource);
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledCompute, sampleSubresource);
-			}
-			else
-			{
-				TextureSubresourceInfo renderSubresource;
-
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kUavComputeWrite, renderSubresource);
-				pass.newTextureDependency(inRt, TextureUsageBit::kSampledCompute);
-			}
+			ppass = &rgraph.newComputeRenderPass(passNames[i]);
 		}
-	}
-	else
-	{
-		for(U32 i = 0; i < m_passCount; ++i)
+		else
 		{
 			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass(passNames[i]);
-			pass.setWork([this, i](RenderPassWorkContext& rgraphCtx) {
-				run(i, rgraphCtx);
-			});
 			pass.setFramebufferInfo(m_fbDescrs[i], {m_runCtx.m_rt});
+			ppass = &pass;
+		}
 
-			if(i > 0)
-			{
-				TextureSubresourceInfo sampleSubresource;
-				TextureSubresourceInfo renderSubresource;
+		const TextureUsageBit readUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kSampledCompute : TextureUsageBit::kSampledFragment;
+		const TextureUsageBit writeUsage = (g_preferComputeCVar.get()) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
 
-				sampleSubresource.m_firstMipmap = i - 1;
-				renderSubresource.m_firstMipmap = i;
+		if(i > 0)
+		{
+			TextureSubresourceInfo sampleSubresource;
+			TextureSubresourceInfo renderSubresource;
 
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource);
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kSampledFragment, sampleSubresource);
-			}
-			else
-			{
-				TextureSubresourceInfo renderSubresource;
+			sampleSubresource.m_firstMipmap = i - 1;
+			renderSubresource.m_firstMipmap = i;
 
-				pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite, renderSubresource);
-				pass.newTextureDependency(inRt, TextureUsageBit::kSampledFragment);
-			}
+			ppass->newTextureDependency(m_runCtx.m_rt, writeUsage, renderSubresource);
+			ppass->newTextureDependency(m_runCtx.m_rt, readUsage, sampleSubresource);
+		}
+		else
+		{
+			TextureSubresourceInfo firstMip;
+			ppass->newTextureDependency(m_runCtx.m_rt, writeUsage, firstMip);
+			ppass->newTextureDependency(inRt, readUsage);
 		}
+
+		ppass->setWork([this, i](RenderPassWorkContext& rgraphCtx) {
+			run(i, rgraphCtx);
+		});
 	}
 }
 
@@ -161,19 +141,16 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		const RenderTargetHandle inRt =
-			(getRenderer().getScale().hasUpscaledHdrRt()) ? getRenderer().getScale().getUpscaledHdrRt() : getRenderer().getScale().getTonemappedRt();
-		rgraphCtx.bindColorTexture(0, 1, inRt);
+		rgraphCtx.bindColorTexture(0, 1, getRenderer().getLightShading().getRt());
 	}
 
 	rgraphCtx.bindUavTexture(0, 2, getRenderer().getTonemapping().getRt());
 
-	const Bool revertTonemap = passIdx == 0 && !getRenderer().getScale().hasUpscaledHdrRt();
-	const UVec4 fbSize(vpWidth, vpHeight, revertTonemap, 0);
-	cmdb.setPushConstants(&fbSize, sizeof(fbSize));
-
 	if(g_preferComputeCVar.get())
 	{
+		const Vec4 fbSize(F32(vpWidth), F32(vpHeight), 0.0f, 0.0f);
+		cmdb.setPushConstants(&fbSize, sizeof(fbSize));
+
 		TextureSubresourceInfo sampleSubresource;
 		sampleSubresource.m_firstMipmap = passIdx;
 		rgraphCtx.bindUavTexture(0, 3, m_runCtx.m_rt, sampleSubresource);

AnKi/Renderer/Renderer.cpp

@@ -321,7 +321,6 @@ Error Renderer::populateRenderGraph(RenderingContext& ctx)
 	m_lensFlare->populateRenderGraph(ctx);
 	m_ssao->populateRenderGraph(ctx);
 	m_lightShading->populateRenderGraph(ctx);
-	m_ssr->populateRenderGraphPostLightShading(ctx);
 	if(!getScale().getUsingGrUpscaler())
 	{
 		m_temporalAA->populateRenderGraph(ctx);
@@ -566,10 +565,18 @@ Bool Renderer::getCurrentDebugRenderTarget(Array<RenderTargetHandle, kMaxDebugRe
 			obj = inf.m_obj;
 		}
 	}
-	ANKI_ASSERT(obj);
 
-	obj->getDebugRenderTarget(m_currentDebugRtName, handles, optionalShaderProgram);
-	return true;
+	if(obj)
+	{
+		obj->getDebugRenderTarget(m_currentDebugRtName, handles, optionalShaderProgram);
+		return true;
+	}
+	else
+	{
+		ANKI_R_LOGE("Debug rendertarget doesn't exist: %s", m_currentDebugRtName.cstr());
+		m_currentDebugRtName = {};
+		return false;
+	}
 }
 
 void Renderer::setCurrentDebugRenderTarget(CString rtName)

AnKi/Renderer/Ssr.cpp

@@ -6,7 +6,7 @@
 #include <AnKi/Renderer/Ssr.h>
 #include <AnKi/Renderer/Renderer.h>
 #include <AnKi/Util/Tracer.h>
-#include <AnKi/Renderer/LightShading.h>
+#include <AnKi/Renderer/DownscaleBlur.h>
 #include <AnKi/Renderer/GBuffer.h>
 #include <AnKi/Renderer/DepthDownscale.h>
 
@@ -29,10 +29,9 @@
 
 namespace anki {
 
-// TODO remove the _ in the names
 static NumericCVar<U32> g_ssrStepIncrementCVar(CVarSubsystem::kRenderer, "SsrStepIncrement", 32, 1, 256, "The number of steps for each loop");
 static NumericCVar<U32> g_ssrMaxIterationsCVar(CVarSubsystem::kRenderer, "SsrMaxIterations", 64, 1, 256, "Max SSR raymarching loop iterations");
-static NumericCVar<F32> g_ssrRoughnessCutoffCVar(CVarSubsystem::kRenderer, "SsrRoughnessCutoff_", (ANKI_PLATFORM_MOBILE) ? 0.7f : 1.0f, 0.0f, 1.0f,
+static NumericCVar<F32> g_ssrRoughnessCutoffCVar(CVarSubsystem::kRenderer, "SsrRoughnessCutoff", (ANKI_PLATFORM_MOBILE) ? 0.7f : 1.0f, 0.0f, 1.0f,
 												 "Materials with roughness higher that this value will fallback to probe reflections");
 static BoolCVar g_ssrQuarterResolution(CVarSubsystem::kRenderer, "SsrQuarterResolution", ANKI_PLATFORM_MOBILE);
 
@@ -62,27 +61,14 @@ Error Ssr::initInternal()
 		mipTexUsage |= TextureUsageBit::kFramebufferWrite;
 	}
 
-	TextureInitInfo mipTexInit =
-		getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2,
-												   getRenderer().getHdrFormat(), mipTexUsage, "Downscaled light shading");
-	mipTexInit.m_mipmapCount = U8(computeMaxMipmapCount2d(mipTexInit.m_width, mipTexInit.m_height, 16));
-	m_mipmappedLightShdingTex = getRenderer().createAndClearRenderTarget(mipTexInit, TextureUsageBit::kAllSampled);
-
 	m_ssrRtDescr = getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR16G16B16A16_Sfloat, "SSR");
 	m_ssrRtDescr.bake();
 
 	m_fbDescr.m_colorAttachmentCount = 1;
 	m_fbDescr.bake();
 
-	ANKI_CHECK(loadShaderProgram("ShaderBinaries/Ssr.ankiprogbin", {}, m_prog, m_mipmapLightShadingGrProg, "MipGeneration"));
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/Ssr.ankiprogbin", {}, m_prog, m_ssrGrProg, "Ssr"));
 
-	BufferInitInfo buffInit("SsrCounterBuffer");
-	buffInit.m_size = sizeof(U32);
-	buffInit.m_usage = BufferUsageBit::kUavComputeWrite | BufferUsageBit::kTransferDestination;
-	m_counterBuffer = GrManager::getSingleton().newBuffer(buffInit);
-	zeroBuffer(m_counterBuffer.get());
-
 	return Error::kNone;
 }
 
@@ -93,16 +79,6 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 	const Bool preferCompute = g_preferComputeCVar.get();
 
-	if(m_mipmappedLightShdingTexImportedOnce) [[likely]]
-	{
-		m_runCtx.m_mipmappedLightShadingRt = rgraph.importRenderTarget(m_mipmappedLightShdingTex.get());
-	}
-	else
-	{
-		m_runCtx.m_mipmappedLightShadingRt = rgraph.importRenderTarget(m_mipmappedLightShdingTex.get(), TextureUsageBit::kAllSampled);
-		m_mipmappedLightShdingTexImportedOnce = true;
-	}
-
 	m_runCtx.m_ssrRt = rgraph.newRenderTarget(m_ssrRtDescr);
 
 	TextureUsageBit readUsage;
@@ -120,13 +96,15 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 	{
 		// TODO
 		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSR");
+		pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_ssrRt}, {});
+
 		ppass = &pass;
 
 		readUsage = TextureUsageBit::kSampledFragment;
 		writeUsage = TextureUsageBit::kFramebufferWrite;
 	}
 
-	ppass->newTextureDependency(m_runCtx.m_mipmappedLightShadingRt, readUsage);
+	ppass->newTextureDependency(getRenderer().getDownscaleBlur().getRt(), readUsage);
 	ppass->newTextureDependency(getRenderer().getGBuffer().getColorRt(1), readUsage);
 	ppass->newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
 	ppass->newTextureDependency(getRenderer().getDepthDownscale().getRt(), readUsage);
@@ -156,7 +134,7 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 		rgraphCtx.bindColorTexture(0, 2, getRenderer().getGBuffer().getColorRt(1));
 		rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(2));
 		rgraphCtx.bindColorTexture(0, 4, getRenderer().getDepthDownscale().getRt());
-		rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_mipmappedLightShadingRt);
+		rgraphCtx.bindColorTexture(0, 5, getRenderer().getDownscaleBlur().getRt());
 
 		if(g_preferComputeCVar.get())
 		{
@@ -171,82 +149,4 @@ void Ssr::populateRenderGraph(RenderingContext& ctx)
 	});
 }
 
-void Ssr::populateRenderGraphPostLightShading(RenderingContext& ctx)
-{
-	ANKI_TRACE_SCOPED_EVENT(SsrPost);
-
-	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
-	const Bool preferCompute = g_preferComputeCVar.get();
-
-	TextureUsageBit readUsage;
-	TextureUsageBit writeUsage;
-	RenderPassDescriptionBase* ppass;
-	if(preferCompute)
-	{
-		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("SSR: Light downscale");
-		ppass = &pass;
-
-		readUsage = TextureUsageBit::kSampledCompute;
-		writeUsage = TextureUsageBit::kUavComputeWrite;
-	}
-	else
-	{
-		// TODO
-		ANKI_ASSERT(0);
-		readUsage = TextureUsageBit::kSampledFragment;
-		writeUsage = TextureUsageBit::kFramebufferWrite;
-	}
-
-	ppass->newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
-	ppass->newTextureDependency(m_runCtx.m_mipmappedLightShadingRt, writeUsage);
-
-	ppass->setWork([this](RenderPassWorkContext& rgraphCtx) {
-		CommandBuffer& cmdb = *rgraphCtx.m_commandBuffer;
-
-		cmdb.bindShaderProgram(m_mipmapLightShadingGrProg.get());
-
-		const U32 mipsToCompute = m_mipmappedLightShdingTex->getMipmapCount();
-
-		varAU2(dispatchThreadGroupCountXY);
-		varAU2(workGroupOffset); // needed if Left and Top are not 0,0
-		varAU2(numWorkGroupsAndMips);
-		varAU4(rectInfo) = initAU4(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
-		SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, mipsToCompute);
-
-		class Constants
-		{
-		public:
-			Vec2 m_invSrcTexSize;
-			U32 m_threadGroupCount;
-			U32 m_mipmapCount;
-		} consts;
-		consts.m_invSrcTexSize = 1.0f / Vec2(getRenderer().getInternalResolution());
-		consts.m_threadGroupCount = numWorkGroupsAndMips[0];
-		consts.m_mipmapCount = numWorkGroupsAndMips[1];
-
-		cmdb.setPushConstants(&consts, sizeof(consts));
-
-		for(U32 mip = 0; mip < kMaxMipsSinglePassDownsamplerCanProduce; ++mip)
-		{
-			TextureSubresourceInfo subresource;
-			if(mip < mipsToCompute)
-			{
-				subresource.m_firstMipmap = mip;
-			}
-			else
-			{
-				subresource.m_firstMipmap = 0; // Put something random
-			}
-
-			rgraphCtx.bindUavTexture(0, 0, m_runCtx.m_mipmappedLightShadingRt, subresource, mip);
-		}
-
-		cmdb.bindUavBuffer(0, 1, m_counterBuffer.get(), 0, sizeof(U32));
-		rgraphCtx.bindColorTexture(0, 2, getRenderer().getLightShading().getRt());
-		cmdb.bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp.get());
-
-		cmdb.dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
-	});
-}
-
 } // end namespace anki

AnKi/Renderer/Ssr.h

@@ -27,8 +27,6 @@ public:
 
 	void populateRenderGraph(RenderingContext& ctx);
 
-	void populateRenderGraphPostLightShading(RenderingContext& ctx);
-
 	void getDebugRenderTarget([[maybe_unused]] CString rtName, Array<RenderTargetHandle, kMaxDebugRenderTargets>& handles,
 							  [[maybe_unused]] ShaderProgramPtr& optionalShaderProgram) const override
 	{
@@ -43,21 +41,14 @@ public:
 
 public:
 	ShaderProgramResourcePtr m_prog;
-	ShaderProgramPtr m_mipmapLightShadingGrProg;
 	ShaderProgramPtr m_ssrGrProg;
 
-	TexturePtr m_mipmappedLightShdingTex;
-	Bool m_mipmappedLightShdingTexImportedOnce = false;
-
 	RenderTargetDescription m_ssrRtDescr;
 	FramebufferDescription m_fbDescr;
 
-	BufferPtr m_counterBuffer;
-
 	class
 	{
 	public:
-		RenderTargetHandle m_mipmappedLightShadingRt;
 		RenderTargetHandle m_ssrRt;
 	} m_runCtx;
 

AnKi/Renderer/TemporalAA.cpp

@@ -31,13 +31,14 @@ Error TemporalAA::initInternal()
 
 	ANKI_CHECK(loadShaderProgram("ShaderBinaries/TemporalAA.ankiprogbin", {{"VARIANCE_CLIPPING", 1}, {"YCBCR", 0}}, m_prog, m_grProg));
 
-	for(U i = 0; i < 2; ++i)
+	for(U32 i = 0; i < 2; ++i)
 	{
 		TextureUsageBit usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 		usage |= (g_preferComputeCVar.get()) ? TextureUsageBit::kUavComputeWrite : TextureUsageBit::kFramebufferWrite;
 
-		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
-			getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(), getRenderer().getHdrFormat(), usage, "TemporalAA");
+		TextureInitInfo texinit =
+			getRenderer().create2DRenderTargetInitInfo(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
+													   getRenderer().getHdrFormat(), usage, String().sprintf("TemporalAA #%u", i).cstr());
 
 		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
@@ -64,14 +65,14 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 	const Bool preferCompute = g_preferComputeCVar.get();
 
 	// Import RTs
-	if(m_rtTexturesImportedOnce[historyRtIdx]) [[likely]]
+	if(m_rtTexturesImportedOnce) [[likely]]
 	{
 		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get());
 	}
 	else
 	{
 		m_runCtx.m_historyRt = rgraph.importRenderTarget(m_rtTextures[historyRtIdx].get(), TextureUsageBit::kSampledFragment);
-		m_rtTexturesImportedOnce[historyRtIdx] = true;
+		m_rtTexturesImportedOnce = true;
 	}
 
 	m_runCtx.m_renderRt = rgraph.importRenderTarget(m_rtTextures[renderRtIdx].get(), TextureUsageBit::kNone);

AnKi/Renderer/TemporalAA.h

@@ -33,7 +33,7 @@ public:
 
 private:
 	Array<TexturePtr, 2> m_rtTextures;
-	Array<Bool, 2> m_rtTexturesImportedOnce = {};
+	Bool m_rtTexturesImportedOnce = false;
 
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;

AnKi/Resource/MaterialResource.cpp

@@ -587,6 +587,8 @@ const MaterialVariant& MaterialResource::getOrCreateVariant(const RenderingKey&
 	case RenderingTechnique::kRtShadow:
 		initInfo.requestTechniqueAndTypes(ShaderTypeBit::kAllHit, "RtShadows");
 		break;
+	default:
+		ANKI_ASSERT(0);
 	}
 
 	const ShaderProgramResourceVariant* progVariant = nullptr;

AnKi/Shaders/DownscaleBlur.ankiprog

@@ -15,9 +15,8 @@ constexpr U32 kTonemappingBinding = 2u;
 
 struct Constants
 {
-	UVec2 m_fbSize;
-	U32 m_revertTonemapping;
-	U32 m_padding;
+	Vec2 m_fbSize;
+	UVec2 m_padding;
 };
 [[vk::push_constant]] ConstantBuffer<Constants> g_consts;
 
@@ -26,19 +25,13 @@ struct Constants
 #	endif
 
 #	if ANKI_COMPUTE_SHADER
-[numthreads(8, 8, 1)] void main(UVec4 svDispatchThreadId : SV_DISPATCHTHREADID)
+[numthreads(8, 8, 1)] void main(UVec2 svDispatchThreadId : SV_DISPATCHTHREADID)
 #	else
 RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 #	endif
 {
 #	if ANKI_COMPUTE_SHADER
-	if(svDispatchThreadId.x >= g_consts.m_fbSize.x || svDispatchThreadId.y >= g_consts.m_fbSize.y)
-	{
-		// Skip pixels outside the viewport
-		return;
-	}
-
-	const Vec2 uv = (Vec2(svDispatchThreadId.xy) + 0.5) / Vec2(g_consts.m_fbSize);
+	const Vec2 uv = (Vec2(svDispatchThreadId) + 0.5) / g_consts.m_fbSize;
 #	endif
 
 	RVec3 output;
@@ -49,15 +42,8 @@ RVec3 main([[vk::location(0)]] Vec2 uv : TEXCOORD) : SV_TARGET0
 	output += g_tex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(+1, -1)) * weight;
 	output += g_tex.SampleLevel(g_linearAnyClampSampler, uv, 0.0, IVec2(-1, +1)) * weight;
 
-	if(g_consts.m_revertTonemapping != 0u)
-	{
-		output = saturate(output);
-		output = sRgbToLinear(output);
-		output = invertTonemap(output, readExposureAndAverageLuminance().x);
-	}
-
 #	if ANKI_COMPUTE_SHADER
-	g_outUav[svDispatchThreadId.xy] = RVec4(output, 1.0);
+	g_outUav[svDispatchThreadId] = RVec4(output, 1.0);
 #	else
 	return output;
 #	endif

AnKi/Shaders/Functions.hlsl

@@ -552,21 +552,6 @@ F32 gaussianWeight(F32 s, F32 x)
 	return p;
 }
 
-#if ANKI_GLSL
-Vec4 bilinearFiltering(Texture2D tex, SamplerState nearestSampler, Vec2 uv, F32 lod, Vec2 textureSize)
-{
-	const Vec2 texelSize = 1.0 / textureSize;
-	const Vec2 unnormTexCoord = (uv * textureSize) - 0.5;
-	const Vec2 f = frac(unnormTexCoord);
-	const Vec2 snapTexCoord = (floor(unnormTexCoord) + 0.5) / textureSize;
-	const Vec4 s1 = textureLod(tex, nearestSampler, uv, lod);
-	const Vec4 s2 = textureLod(tex, nearestSampler, uv + Vec2(texelSize.x, 0.0), lod);
-	const Vec4 s3 = textureLod(tex, nearestSampler, uv + Vec2(0.0, texelSize.y), lod);
-	const Vec4 s4 = textureLod(tex, nearestSampler, uv + texelSize, lod);
-	return mix(mix(s1, s2, f.x), mix(s3, s4, f.x), f.y);
-}
-#endif
-
 // https://www.shadertoy.com/view/WsfBDf
 Vec3 animateBlueNoise(Vec3 inputBlueNoise, U32 frameIdx)
 {

AnKi/Shaders/Ssr.ankiprog

@@ -158,101 +158,6 @@ RVec4 main(Vec2 uv : TEXCOORD, Vec4 svPosition : SV_POSITION) : SV_TARGET0
 
 #endif // ANKI_TECHNIQUE_Ssr && (ANKI_COMPUTE_SHADER || ANKI_FRAGMENT_SHADER)
 
-// ===========================================================================
-// Light shading downscale                                                   =
-// ===========================================================================
-#if ANKI_TECHNIQUE_MipGeneration && ANKI_COMPUTE_SHADER
-struct Constants
-{
-	Vec2 m_invSrcTexSize;
-	U32 m_threadGroupCount;
-	U32 m_mipmapCount;
-};
-
-[[vk::push_constant]] ConstantBuffer<Constants> g_consts;
-
-[[vk::binding(0)]] globallycoherent RWTexture2D<Vec4> g_dstUavs[kMaxMipsSinglePassDownsamplerCanProduce];
-[[vk::binding(1)]] globallycoherent RWStructuredBuffer<U32> g_spdCounter;
-[[vk::binding(2)]] Texture2D<Vec4> g_srcTex;
-
-[[vk::binding(3)]] SamplerState g_linearAnyClampSampler;
-
-// Include SPD
-#	define A_GPU 1
-#	define A_HLSL 1
-#	include <ThirdParty/FidelityFX/ffx_a.h>
-
-groupshared AU1 s_spdCounter;
-groupshared AF3 s_spdIntermediateRgb[16][16];
-
-AF4 SpdLoadSourceImage(AU2 p, AU1 slice)
-{
-	ANKI_MAYBE_UNUSED(slice);
-	const AF2 uv = p * g_consts.m_invSrcTexSize + g_consts.m_invSrcTexSize;
-
-	const Vec3 val = g_srcTex.SampleLevel(g_linearAnyClampSampler, uv, 0.0).xyz;
-	return AF4(val, 0.0f);
-}
-
-AF4 SpdLoad(AU2 p, AU1 slice)
-{
-	ANKI_MAYBE_UNUSED(slice);
-	return AF4(g_dstUavs[5][p].xyz, 0.0);
-}
-
-void SpdStore(AU2 p, AF4 value, AU1 mip, AU1 slice)
-{
-	ANKI_MAYBE_UNUSED(slice);
-	g_dstUavs[mip][p] = Vec4(value.xyz, 0.0f);
-}
-
-void SpdIncreaseAtomicCounter(AU1 slice)
-{
-	ANKI_MAYBE_UNUSED(slice);
-	InterlockedAdd(g_spdCounter[0], 1u, s_spdCounter);
-}
-
-AU1 SpdGetAtomicCounter()
-{
-	return s_spdCounter;
-}
-
-void SpdResetAtomicCounter(AU1 slice)
-{
-	ANKI_MAYBE_UNUSED(slice);
-	g_spdCounter[0] = 0u;
-}
-
-AF4 SpdLoadIntermediate(AU1 x, AU1 y)
-{
-	return AF4(s_spdIntermediateRgb[x][y], 0.0f);
-}
-
-void SpdStoreIntermediate(AU1 x, AU1 y, AF4 value)
-{
-	s_spdIntermediateRgb[x][y] = value.xyz;
-}
-
-AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3)
-{
-	AF4 value = v0 / 4.0f;
-	value += v1 / 4.0f;
-	value += v2 / 4.0f;
-	value += v3 / 4.0f;
-	return AF4(value.xyz, 0.0f);
-}
-
-#	define SPD_LINEAR_SAMPLER 1
-#	include <ThirdParty/FidelityFX/ffx_spd.h>
-
-[numthreads(256, 1, 1)] void main(UVec3 svGroupId : SV_GROUPID, U32 svGroupIndex : SV_GROUPINDEX)
-{
-	const U32 slice = 0u;
-	const UVec2 offset = UVec2(0, 0);
-	SpdDownsample(AU2(svGroupId.xy), AU1(svGroupIndex), AU1(g_consts.m_mipmapCount), AU1(g_consts.m_threadGroupCount), slice, offset);
-}
-#endif
-
 // ===========================================================================
 // Techniques                                                                =
 // ===========================================================================
@@ -265,6 +170,3 @@ AF4 SpdReduce4(AF4 v0, AF4 v1, AF4 v2, AF4 v3)
 
 #pragma anki technique_start comp Ssr
 #pragma anki technique_end comp Ssr
-
-#pragma anki technique_start comp MipGeneration
-#pragma anki technique_end comp MipGeneration

AnKi/Shaders/VisualizeRenderTarget.ankiprog

@@ -16,6 +16,6 @@
 Vec3 main(Vec2 uv : TEXCOORD) : SV_TARGET0
 {
 	const Vec4 rgba = g_inTex.SampleLevel(g_nearestAnyClampSampler, uv, 0.0);
-	return rgba.xyz * rgba.w;
+	return rgba.xyz;
 }
 #pragma anki technique_end frag

Samples/Common/SampleApp.cpp

@@ -106,7 +106,7 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 
 	if(in.getKey(KeyCode::kL) == 1)
 	{
-		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "LightShading") ? "" : "LightShading");
+		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "Bloom") ? "" : "Bloom");
 	}
 
 	if(in.getKey(KeyCode::kH) == 1)

Sandbox/Main.cpp

@@ -357,7 +357,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 
 	if(in.getKey(KeyCode::kH) == 1)
 	{
-		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "LightShading") ? "" : "LightShading");
+		renderer.setCurrentDebugRenderTarget((renderer.getCurrentDebugRenderTarget() == "Bloom") ? "" : "Bloom");
 	}
 
 	/*if(in.getKey(KeyCode::J) == 1)