Move ForwardShading to the render graph

src/anki/renderer/Common.h

@@ -50,6 +50,9 @@ class ShaderProgramResourceVariant;
 /// @addtogroup renderer
 /// @{
 
+/// Don't create second level command buffers if they contain more drawcalls than this constant.
+const U MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER = 16;
+
 /// FS size is rendererSize/FS_FRACTION.
 const U FS_FRACTION = 2;
 

src/anki/renderer/ForwardShading.cpp

@@ -37,24 +37,22 @@ Error ForwardShading::initInternal(const ConfigSet&)
 	m_width = m_r->getWidth() / FS_FRACTION;
 	m_height = m_r->getHeight() / FS_FRACTION;
 
-	// Create RT
-	m_rt = m_r->createAndClearRenderTarget(m_r->create2DRenderTargetInitInfo(m_width,
+	// Create RT descr
+	m_rtDescr = m_r->create2DRenderTargetDescription(m_width,
 		m_height,
 		FORWARD_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT,
 		TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
 		SamplingFilter::LINEAR,
-		1,
-		"forward"));
-
-	FramebufferInitInfo fbInit("forward");
-	fbInit.m_colorAttachmentCount = 1;
-	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
-	fbInit.m_colorAttachments[0].m_clearValue.m_colorf = {{0.0, 0.0, 0.0, 1.0}};
-	// TODO fbInit.m_depthStencilAttachment.m_texture = m_r->getDepthDownscale().m_hd.m_depthRt;
-	fbInit.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
-	fbInit.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
-	m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
+		"forward");
+	m_rtDescr.bake();
+
+	// Create FB descr
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::CLEAR;
+	m_fbDescr.m_colorAttachments[0].m_clearValue.m_colorf = {{0.0, 0.0, 0.0, 1.0}};
+	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::LOAD;
+	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::DEPTH;
+	m_fbDescr.bake();
 
 	ANKI_CHECK(initVol());
 	ANKI_CHECK(initUpscale());
@@ -99,7 +97,7 @@ Error ForwardShading::initUpscale()
 	return Error::NONE;
 }
 
-void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb)
+void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph)
 {
 	cmdb->bindShaderProgram(m_vol.m_grProg);
 	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ONE);
@@ -109,9 +107,11 @@ void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb
 	Vec4* unis = allocateAndBindUniforms<Vec4*>(sizeof(Vec4), cmdb, 0, 0);
 	computeLinearizeDepthOptimal(ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, unis->x(), unis->y());
 
-	// TODO cmdb->bindTextureAndSampler(0, 0, m_r->getDepthDownscale().m_hd.m_colorRt, m_r->getNearestSampler());
-	// TODO cmdb->bindTextureAndSampler(0, 1, m_r->getDepthDownscale().m_qd.m_colorRt, m_r->getNearestSampler());
-	// TODO cmdb->bindTexture(0, 2, m_r->getVolumetric().m_main.getRt());
+	cmdb->bindTextureAndSampler(
+		0, 0, rgraph.getTexture(m_r->getDepthDownscale().getHalfDepthColorRt()), m_r->getNearestSampler());
+	cmdb->bindTextureAndSampler(
+		0, 1, rgraph.getTexture(m_r->getDepthDownscale().getQuarterColorRt()), m_r->getNearestSampler());
+	cmdb->bindTexture(0, 2, rgraph.getTexture(m_r->getVolumetric().getRt()));
 	cmdb->bindTexture(0, 3, m_vol.m_noiseTex->getGrTexture());
 
 	m_r->drawQuad(cmdb);
@@ -122,17 +122,16 @@ void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb
 	cmdb->setDepthCompareOperation(CompareOperation::LESS);
 }
 
-void ForwardShading::drawUpscale(RenderingContext& ctx)
+void ForwardShading::drawUpscale(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph)
 {
-	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
-
 	Vec4* linearDepth = allocateAndBindUniforms<Vec4*>(sizeof(Vec4), cmdb, 0, 0);
 	computeLinearizeDepthOptimal(
 		ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, linearDepth->x(), linearDepth->y());
 
-	// TODO cmdb->bindTexture(0, 0, m_r->getGBuffer().m_depthRt);
-	// TODO cmdb->bindTextureAndSampler(0, 1, m_r->getDepthDownscale().m_hd.m_colorRt, m_r->getNearestSampler());
-	cmdb->bindTexture(0, 2, m_rt);
+	cmdb->bindTexture(0, 0, rgraph.getTexture(m_r->getGBuffer().getDepthRt()));
+	cmdb->bindTextureAndSampler(
+		0, 1, rgraph.getTexture(m_r->getDepthDownscale().getHalfDepthColorRt()), m_r->getNearestSampler());
+	cmdb->bindTexture(0, 2, rgraph.getTexture(m_runCtx.m_rt));
 	cmdb->bindTexture(0, 3, m_upscale.m_noiseTex->getGrTexture());
 
 	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::SRC_ALPHA);
@@ -146,7 +145,8 @@ void ForwardShading::drawUpscale(RenderingContext& ctx)
 	cmdb->setBlendFactors(0, BlendFactor::ONE, BlendFactor::ZERO);
 }
 
-void ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const
+void ForwardShading::run(
+	RenderingContext& ctx, CommandBufferPtr& cmdb, U threadId, U threadCount, const RenderGraph& rgraph)
 {
 	const U problemSize = ctx.m_renderQueue->m_forwardShadingRenderables.getSize();
 	PtrSize start, end;
@@ -158,22 +158,8 @@ void ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U th
 		return;
 	}
 
-	// Create the command buffer and set some state
-	CommandBufferInitInfo cinf;
-	cinf.m_flags = CommandBufferFlag::SECOND_LEVEL | CommandBufferFlag::GRAPHICS_WORK;
-	if(end - start < COMMAND_BUFFER_SMALL_BATCH_MAX_COMMANDS)
-	{
-		cinf.m_flags |= CommandBufferFlag::SMALL_BATCH;
-	}
-	cinf.m_framebuffer = m_fb;
-	CommandBufferPtr cmdb = m_r->getGrManager().newInstance<CommandBuffer>(cinf);
-	ctx.m_forwardShading.m_commandBuffers[threadId] = cmdb;
-
-	cmdb->informTextureCurrentUsage(m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE);
-	// TODO: cmdb->informTextureCurrentUsage(m_r->getShadowMapping().m_shadowAtlas, TextureUsageBit::SAMPLED_FRAGMENT);
-
-	// TODO cmdb->bindTexture(0, 0, m_r->getDepthDownscale().m_qd.m_colorRt);
-	// TODO: cmdb->bindTexture(0, 1, m_r->getShadowMapping().m_shadowAtlas);
+	cmdb->bindTexture(0, 0, rgraph.getTexture(m_r->getDepthDownscale().getQuarterColorRt()));
+	cmdb->bindTexture(0, 1, rgraph.getTexture(m_r->getShadowMapping().getShadowmapRt()));
 	bindUniforms(cmdb, 0, 0, ctx.m_lightShading.m_commonToken);
 	bindUniforms(cmdb, 0, 1, ctx.m_lightShading.m_pointLightsToken);
 	bindUniforms(cmdb, 0, 2, ctx.m_lightShading.m_spotLightsToken);
@@ -193,39 +179,38 @@ void ForwardShading::buildCommandBuffers(RenderingContext& ctx, U threadId, U th
 		cmdb,
 		ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + start,
 		ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + end);
-}
 
-void ForwardShading::setPreRunBarriers(RenderingContext& ctx)
-{
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rt,
-		TextureUsageBit::NONE,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureSurfaceInfo(0, 0, 0, 0));
+	if(threadId == threadCount - 1)
+	{
+		drawVolumetric(ctx, cmdb, rgraph);
+	}
 }
 
-void ForwardShading::setPostRunBarriers(RenderingContext& ctx)
+void ForwardShading::populateRenderGraph(RenderingContext& ctx)
 {
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rt,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::SAMPLED_FRAGMENT,
-		TextureSurfaceInfo(0, 0, 0, 0));
-}
+	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	m_runCtx.m_ctx = &ctx;
 
-void ForwardShading::run(RenderingContext& ctx)
-{
-	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
-	cmdb->beginRenderPass(m_fb);
-	cmdb->setViewport(0, 0, m_width, m_height);
+	// Create RT
+	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
 
-	for(U i = 0; i < m_r->getThreadPool().getThreadsCount(); ++i)
-	{
-		if(ctx.m_forwardShading.m_commandBuffers[i].isCreated())
-		{
-			cmdb->pushSecondLevelCommandBuffer(ctx.m_forwardShading.m_commandBuffers[i]);
-		}
-	}
+	// Create pass
+	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Forward shading");
+
+	pass.setWork(runCallback,
+		this,
+		computeNumberOfSecondLevelCommandBuffers(ctx.m_renderQueue->m_forwardShadingRenderables.getSize()));
+	pass.setFramebufferInfo(m_fbDescr, {{m_runCtx.m_rt}}, m_r->getDepthDownscale().getHalfDepthDepthRt());
+
+	pass.newConsumer({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
+	pass.newConsumer({m_r->getDepthDownscale().getHalfDepthDepthRt(), TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ});
+	pass.newConsumer({m_r->getDepthDownscale().getHalfDepthColorRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getDepthDownscale().getQuarterColorRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getVolumetric().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_FRAGMENT});
 
-	cmdb->endRenderPass();
+	pass.newProducer({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
+	pass.newProducer({m_r->getDepthDownscale().getHalfDepthDepthRt(), TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ});
 }
 
 } // end namespace anki

src/anki/renderer/ForwardShading.h

@@ -26,43 +26,27 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	void buildCommandBuffers(RenderingContext& ctx, U threadId, U threadCount) const;
+	/// Populate the rendergraph.
+	void populateRenderGraph(RenderingContext& ctx);
 
-	void setPreRunBarriers(RenderingContext& ctx);
+	void drawUpscale(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph);
 
-	void run(RenderingContext& ctx);
-
-	void setPostRunBarriers(RenderingContext& ctx);
-
-	void drawVolumetric(RenderingContext& ctx, CommandBufferPtr cmdb);
-
-	void drawUpscale(RenderingContext& ctx);
-
-	TexturePtr getRt() const
-	{
-		return m_rt;
-	}
-
-	U getWidth() const
+	U32 getWidth() const
 	{
 		return m_width;
 	}
 
-	U getHeight() const
+	U32 getHeight() const
 	{
 		return m_height;
 	}
 
-	FramebufferPtr getFramebuffer() const
-	{
-		return m_fb;
-	}
-
 private:
-	U m_width;
-	U m_height;
-	FramebufferPtr m_fb;
-	TexturePtr m_rt;
+	U32 m_width;
+	U32 m_height;
+
+	GraphicsRenderPassFramebufferDescription m_fbDescr;
+	RenderTargetDescription m_rtDescr;
 
 	class Vol
 	{
@@ -80,9 +64,32 @@ private:
 		TextureResourcePtr m_noiseTex;
 	} m_upscale;
 
+	class
+	{
+	public:
+		RenderTargetHandle m_rt;
+		RenderingContext* m_ctx = nullptr;
+	} m_runCtx;
+
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 	ANKI_USE_RESULT Error initVol();
 	ANKI_USE_RESULT Error initUpscale();
+
+	/// A RenderPassWorkCallback.
+	static void runCallback(void* userData,
+		CommandBufferPtr cmdb,
+		U32 secondLevelCmdbIdx,
+		U32 secondLevelCmdbCount,
+		const RenderGraph& rgraph)
+	{
+		ANKI_ASSERT(userData);
+		ForwardShading* self = static_cast<ForwardShading*>(userData);
+		self->run(*self->m_runCtx.m_ctx, cmdb, secondLevelCmdbIdx, secondLevelCmdbCount, rgraph);
+	}
+
+	void run(RenderingContext& ctx, CommandBufferPtr& cmdb, U threadId, U threadCount, const RenderGraph& rgraph);
+
+	void drawVolumetric(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph);
 };
 /// @}
 

src/anki/renderer/LightShading.cpp

@@ -187,7 +187,7 @@ void LightShading::run(RenderingContext& ctx)
 	cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
 
 	// Apply the forward shading result
-	m_r->getForwardShading().drawUpscale(ctx);
+	// TODO m_r->getForwardShading().drawUpscale(ctx);
 
 	cmdb->endRenderPass();
 }

src/anki/renderer/Renderer.cpp

@@ -540,19 +540,20 @@ void Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId,
 		ctx.m_gbuffer.m_commandBuffers[threadId]->flush();
 	}
 
-	// SM
-	//
-	// TODO: m_shadowMapping->buildCommandBuffers(ctx, threadId, threadCount);
+// SM
+//
+// TODO: m_shadowMapping->buildCommandBuffers(ctx, threadId, threadCount);
 
-	// FS
-	//
-	m_forwardShading->buildCommandBuffers(ctx, threadId, threadCount);
+// FS
+//
+#if 0
+	// TODO m_forwardShading->buildCommandBuffers(ctx, threadId, threadCount);
 
 	// Append to the last FB's cmdb the other passes
 	if(ctx.m_forwardShading.m_lastThreadWithWork == threadId)
 	{
 		m_lensFlare->run(ctx, ctx.m_forwardShading.m_commandBuffers[threadId]);
-		m_forwardShading->drawVolumetric(ctx, ctx.m_forwardShading.m_commandBuffers[threadId]);
+		// TODO m_forwardShading->drawVolumetric(ctx, ctx.m_forwardShading.m_commandBuffers[threadId]);
 	}
 	else if(threadId == threadCount - 1 && ctx.m_forwardShading.m_lastThreadWithWork == MAX_U32)
 	{
@@ -564,15 +565,10 @@ void Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId,
 		init.m_framebuffer = m_forwardShading->getFramebuffer();
 		CommandBufferPtr cmdb = getGrManager().newInstance<CommandBuffer>(init);
 
-		// Inform on textures
-		cmdb->informTextureSurfaceCurrentUsage(m_forwardShading->getRt(),
-			TextureSurfaceInfo(0, 0, 0, 0),
-			TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE);
-
 		cmdb->setViewport(0, 0, m_forwardShading->getWidth(), m_forwardShading->getHeight());
 
 		m_lensFlare->run(ctx, cmdb);
-		m_forwardShading->drawVolumetric(ctx, cmdb);
+		// TODO m_forwardShading->drawVolumetric(ctx, cmdb);
 
 		ctx.m_forwardShading.m_commandBuffers[threadId] = cmdb;
 	}
@@ -581,6 +577,7 @@ void Renderer::buildCommandBuffersInternal(RenderingContext& ctx, U32 threadId,
 	{
 		ctx.m_forwardShading.m_commandBuffers[threadId]->flush();
 	}
+#endif
 }
 
 Error Renderer::buildCommandBuffers(RenderingContext& ctx)

src/anki/renderer/RendererObject.cpp

@@ -64,4 +64,20 @@ void RendererObject::bindStorage(CommandBufferPtr& cmdb, U set, U binding, const
 	}
 }
 
+U32 RendererObject::computeNumberOfSecondLevelCommandBuffers(U32 drawcallCount) const
+{
+	const U drawcallsPerThread = drawcallCount / m_r->getThreadPool().getThreadsCount();
+	U secondLevelCmdbCount;
+	if(drawcallsPerThread < MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER)
+	{
+		secondLevelCmdbCount = max<U>(1u, drawcallCount / MIN_DRAWCALLS_PER_2ND_LEVEL_COMMAND_BUFFER);
+	}
+	else
+	{
+		secondLevelCmdbCount = m_r->getThreadPool().getThreadsCount();
+	}
+
+	return secondLevelCmdbCount;
+}
+
 } // end namespace anki

src/anki/renderer/RendererObject.h

@@ -74,6 +74,8 @@ protected:
 	ResourceManager& getResourceManager();
 
 	void* allocateFrameStagingMemory(PtrSize size, StagingGpuMemoryType usage, StagingGpuMemoryToken& token);
+
+	U32 computeNumberOfSecondLevelCommandBuffers(U32 drawcallCount) const;
 };
 /// @}
 

src/anki/renderer/Volumetric.cpp

@@ -230,4 +230,9 @@ void Volumetric::populateRenderGraph(RenderingContext& ctx)
 	}
 }
 
+RenderTargetHandle Volumetric::getRt() const
+{
+	return m_runCtx.m_rts[m_r->getFrameCount() & 1];
+}
+
 } // end namespace anki

src/anki/renderer/Volumetric.h

@@ -38,6 +38,8 @@ anki_internal:
 	/// Populate the rendergraph.
 	void populateRenderGraph(RenderingContext& ctx);
 
+	RenderTargetHandle getRt() const;
+
 private:
 	U32 m_width = 0, m_height = 0;