Move DepthDownscale, LightShading and other passes to the render graph

src/anki/gr/RenderGraph.cpp

@@ -118,7 +118,7 @@ public:
 	}
 };
 
-void GraphicsRenderPassFramebufferDescription::bake()
+void FramebufferDescription::bake()
 {
 	ANKI_ASSERT(m_hash == 0 && "Already baked");
 	if(m_defaultFb)
@@ -133,7 +133,7 @@ void GraphicsRenderPassFramebufferDescription::bake()
 	for(U i = 0; i < m_colorAttachmentCount; ++i)
 	{
 		FramebufferAttachmentInfo& out = m_fbInitInfo.m_colorAttachments[i];
-		const GraphicsRenderPassFramebufferDescriptionAttachment& in = m_colorAttachments[i];
+		const FramebufferDescriptionAttachment& in = m_colorAttachments[i];
 
 		out.m_surface = in.m_surface;
 		out.m_clearValue = in.m_clearValue;
@@ -144,7 +144,7 @@ void GraphicsRenderPassFramebufferDescription::bake()
 	if(!!m_depthStencilAttachment.m_aspect)
 	{
 		FramebufferAttachmentInfo& out = m_fbInitInfo.m_depthStencilAttachment;
-		const GraphicsRenderPassFramebufferDescriptionAttachment& in = m_depthStencilAttachment;
+		const FramebufferDescriptionAttachment& in = m_depthStencilAttachment;
 
 		out.m_surface = in.m_surface;
 		out.m_loadOperation = in.m_loadOperation;

src/anki/gr/RenderGraph.h

@@ -248,8 +248,8 @@ protected:
 };
 
 /// Framebuffer attachment info.
-/// @memberof GraphicsRenderPassFramebufferDescription
-class GraphicsRenderPassFramebufferDescriptionAttachment
+/// @memberof FramebufferDescription
+class FramebufferDescriptionAttachment
 {
 public:
 	TextureSurfaceInfo m_surface;
@@ -265,14 +265,14 @@ public:
 
 /// Describes a framebuffer.
 /// @memberof GraphicsRenderPassDescription
-class GraphicsRenderPassFramebufferDescription
+class FramebufferDescription
 {
 	friend class GraphicsRenderPassDescription;
 
 public:
-	Array<GraphicsRenderPassFramebufferDescriptionAttachment, MAX_COLOR_ATTACHMENTS> m_colorAttachments;
+	Array<FramebufferDescriptionAttachment, MAX_COLOR_ATTACHMENTS> m_colorAttachments;
 	U32 m_colorAttachmentCount = 0;
-	GraphicsRenderPassFramebufferDescriptionAttachment m_depthStencilAttachment;
+	FramebufferDescriptionAttachment m_depthStencilAttachment;
 
 	void setDefaultFramebuffer()
 	{
@@ -306,7 +306,7 @@ public:
 	{
 	}
 
-	void setFramebufferInfo(const GraphicsRenderPassFramebufferDescription& fbInfo,
+	void setFramebufferInfo(const FramebufferDescription& fbInfo,
 		const Array<RenderTargetHandle, MAX_COLOR_ATTACHMENTS>& colorRenderTargetHandles,
 		RenderTargetHandle depthStencilRenderTargetHandle)
 	{

src/anki/renderer/Bloom.h

@@ -51,7 +51,7 @@ private:
 		U32 m_width = 0;
 		U32 m_height = 0;
 
-		GraphicsRenderPassFramebufferDescription m_fbDescr;
+		FramebufferDescription m_fbDescr;
 		RenderTargetDescription m_rtDescr;
 		RenderTargetHandle m_rt;
 	} m_exposure;
@@ -66,7 +66,7 @@ private:
 		U32 m_height = 0;
 
 		RenderTargetDescription m_rtDescr;
-		GraphicsRenderPassFramebufferDescription m_fbDescr;
+		FramebufferDescription m_fbDescr;
 		RenderTargetHandle m_rt;
 	} m_upscale;
 

src/anki/renderer/DepthDownscale.h

@@ -56,7 +56,7 @@ private:
 		RenderTargetDescription m_depthRtDescr;
 		RenderTargetDescription m_colorRtDescr;
 
-		GraphicsRenderPassFramebufferDescription m_fbDescr;
+		FramebufferDescription m_fbDescr;
 
 		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;
@@ -67,7 +67,7 @@ private:
 	public:
 		RenderTargetDescription m_colorRtDescr;
 
-		GraphicsRenderPassFramebufferDescription m_fbDescr;
+		FramebufferDescription m_fbDescr;
 
 		ShaderProgramResourcePtr m_prog;
 		ShaderProgramPtr m_grProg;

src/anki/renderer/DownscaleBlur.cpp

@@ -13,6 +13,7 @@ namespace anki
 DownscaleBlur::~DownscaleBlur()
 {
 	m_passes.destroy(getAllocator());
+	m_runCtx.m_rts.destroy(getAllocator());
 }
 
 Error DownscaleBlur::initSubpass(U idx, const UVec2& inputTexSize)
@@ -23,21 +24,14 @@ Error DownscaleBlur::initSubpass(U idx, const UVec2& inputTexSize)
 	pass.m_height = inputTexSize.y() / 2;
 
 	// RT
-	pass.m_rt = m_r->createAndClearRenderTarget(m_r->create2DRenderTargetInitInfo(pass.m_width,
+	pass.m_rtDescr = m_r->create2DRenderTargetDescription(pass.m_width,
 		pass.m_height,
 		LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT,
 		TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE
 			| TextureUsageBit::SAMPLED_COMPUTE,
 		SamplingFilter::LINEAR,
-		1,
-		"downblur"));
-
-	// FB
-	FramebufferInitInfo fbInit("downblur");
-	fbInit.m_colorAttachmentCount = 1;
-	fbInit.m_colorAttachments[0].m_texture = pass.m_rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
-	pass.m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
+		"downblur");
+	pass.m_rtDescr.bake();
 
 	return Error::NONE;
 }
@@ -67,6 +61,14 @@ Error DownscaleBlur::initInternal(const ConfigSet&)
 		size /= 2;
 	}
 
+	m_runCtx.m_rts.create(getAllocator(), passCount);
+
+	// FB descr
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
+	m_fbDescr.bake();
+
+	// Shader programs
 	ANKI_CHECK(getResourceManager().loadResource("programs/DownscaleBlur.ankiprog", m_prog));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variant);
@@ -75,54 +77,64 @@ Error DownscaleBlur::initInternal(const ConfigSet&)
 	return Error::NONE;
 }
 
-void DownscaleBlur::setPreRunBarriers(RenderingContext& ctx)
+void DownscaleBlur::run(const RenderGraph& rgraph, CommandBufferPtr& cmdb)
 {
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_passes[0].m_rt,
-		TextureUsageBit::NONE,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureSurfaceInfo(0, 0, 0, 0));
+	const U passIdx = m_runCtx.m_crntPassIdx++;
+
+	if(passIdx > 0)
+	{
+		// Bind the previous pass' Rt
+
+		cmdb->bindTexture(0, 0, rgraph.getTexture(m_runCtx.m_rts[passIdx - 1]));
+	}
+	else
+	{
+		cmdb->bindTexture(0, 0, rgraph.getTexture(m_r->getTemporalAA().getRt()));
+	}
+
+	const Subpass& pass = m_passes[passIdx];
+	cmdb->setViewport(0, 0, pass.m_width, pass.m_height);
+	cmdb->bindShaderProgram(m_grProg);
+	m_r->drawQuad(cmdb);
 }
 
-void DownscaleBlur::run(RenderingContext& ctx)
+void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 {
-	CommandBufferPtr cmdb = ctx.m_commandBuffer;
-
-	cmdb->bindTexture(0, 0, m_r->getTemporalAA().getRt());
+	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+	m_runCtx.m_crntPassIdx = 0;
 
+	// Create RTs
 	for(U i = 0; i < m_passes.getSize(); ++i)
 	{
-		Subpass& pass = m_passes[i];
+		m_runCtx.m_rts[i] = rgraph.newRenderTarget(m_passes[i].m_rtDescr);
+	}
 
-		if(i > 0u)
-		{
-			cmdb->setTextureSurfaceBarrier(m_passes[i - 1].m_rt,
-				TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-				TextureUsageBit::SAMPLED_FRAGMENT,
-				TextureSurfaceInfo(0, 0, 0, 0));
+	// Create passes
+	for(U i = 0; i < m_passes.getSize(); ++i)
+	{
+		GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Downscale Blur");
 
-			cmdb->setTextureSurfaceBarrier(pass.m_rt,
-				TextureUsageBit::NONE,
-				TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-				TextureSurfaceInfo(0, 0, 0, 0));
+		pass.setWork(runCallback, this, 0);
 
-			cmdb->bindTexture(0, 0, m_passes[i - 1].m_rt);
+		RenderTargetHandle renderRt, sampleRt;
+		if(i > 0)
+		{
+			renderRt = m_runCtx.m_rts[i];
+			sampleRt = m_runCtx.m_rts[i - 1];
+		}
+		else
+		{
+			renderRt = m_runCtx.m_rts[0];
+			sampleRt = m_r->getTemporalAA().getRt();
 		}
 
-		cmdb->setViewport(0, 0, pass.m_width, pass.m_height);
-		cmdb->bindShaderProgram(m_grProg);
+		pass.setFramebufferInfo(m_fbDescr, {{renderRt}}, {});
 
-		cmdb->beginRenderPass(pass.m_fb);
-		m_r->drawQuad(cmdb);
-		cmdb->endRenderPass();
-	}
-}
+		pass.newConsumer({renderRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+		pass.newConsumer({sampleRt, TextureUsageBit::SAMPLED_FRAGMENT});
 
-void DownscaleBlur::setPostRunBarriers(RenderingContext& ctx)
-{
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_passes.getBack().m_rt,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::SAMPLED_COMPUTE | TextureUsageBit::SAMPLED_FRAGMENT,
-		TextureSurfaceInfo(0, 0, 0, 0));
+		pass.newProducer({renderRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+	}
 }
 
 } // end namespace anki

src/anki/renderer/DownscaleBlur.h

@@ -26,9 +26,8 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& cfg);
 
-	void setPreRunBarriers(RenderingContext& ctx);
-	void run(RenderingContext& ctx);
-	void setPostRunBarriers(RenderingContext& ctx);
+	/// Populate the rendergraph.
+	void populateRenderGraph(RenderingContext& ctx);
 
 	U getPassWidth(U pass) const
 	{
@@ -40,27 +39,49 @@ anki_internal:
 		return m_passes[min<U>(pass, m_passes.getSize() - 1)].m_height;
 	}
 
-	TexturePtr getPassTexture(U pass) const
+	RenderTargetHandle getPassRt(U pass) const
 	{
-		return m_passes[min<U>(pass, m_passes.getSize() - 1)].m_rt;
+		return m_runCtx.m_rts[min<U>(pass, m_runCtx.m_rts.getSize() - 1)];
 	}
 
 private:
 	class Subpass
 	{
 	public:
-		TexturePtr m_rt;
-		FramebufferPtr m_fb;
+		RenderTargetDescription m_rtDescr;
 		U32 m_width, m_height;
 	};
 
+	DynamicArray<Subpass> m_passes;
+
+	FramebufferDescription m_fbDescr;
+
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
-	DynamicArray<Subpass> m_passes;
+	class
+	{
+	public:
+		DynamicArray<RenderTargetHandle> m_rts;
+		U32 m_crntPassIdx = MAX_U32;
+	} m_runCtx;
 
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& cfg);
 	ANKI_USE_RESULT Error initSubpass(U idx, const UVec2& inputTexSize);
+
+	void run(const RenderGraph& rgraph, CommandBufferPtr& cmdb);
+
+	/// A RenderPassWorkCallback for the downscall passes.
+	static void runCallback(void* userData,
+		CommandBufferPtr cmdb,
+		U32 secondLevelCmdbIdx,
+		U32 secondLevelCmdbCount,
+		const RenderGraph& rgraph)
+	{
+		ANKI_ASSERT(userData);
+		DownscaleBlur* self = static_cast<DownscaleBlur*>(userData);
+		self->run(rgraph, cmdb);
+	}
 };
 /// @}
 

src/anki/renderer/ForwardShading.cpp

@@ -122,8 +122,9 @@ void ForwardShading::drawVolumetric(RenderingContext& ctx, CommandBufferPtr& cmd
 	cmdb->setDepthCompareOperation(CompareOperation::LESS);
 }
 
-void ForwardShading::drawUpscale(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph)
+void ForwardShading::drawUpscale(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb)
 {
+	// **WARNING** Remember to update the consumers of the render pass that calls this method
 	Vec4* linearDepth = allocateAndBindUniforms<Vec4*>(sizeof(Vec4), cmdb, 0, 0);
 	computeLinearizeDepthOptimal(
 		ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, linearDepth->x(), linearDepth->y());

src/anki/renderer/ForwardShading.h

@@ -29,7 +29,7 @@ anki_internal:
 	/// Populate the rendergraph.
 	void populateRenderGraph(RenderingContext& ctx);
 
-	void drawUpscale(RenderingContext& ctx, CommandBufferPtr& cmdb, const RenderGraph& rgraph);
+	void drawUpscale(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb);
 
 	U32 getWidth() const
 	{
@@ -41,11 +41,16 @@ anki_internal:
 		return m_height;
 	}
 
+	RenderTargetHandle getRt() const
+	{
+		return m_runCtx.m_rt;
+	}
+
 private:
 	U32 m_width;
 	U32 m_height;
 
-	GraphicsRenderPassFramebufferDescription m_fbDescr;
+	FramebufferDescription m_fbDescr;
 	RenderTargetDescription m_rtDescr;
 
 	class Vol

src/anki/renderer/GBuffer.h

@@ -43,7 +43,7 @@ anki_internal:
 private:
 	Array<RenderTargetDescription, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRtDescrs;
 	RenderTargetDescription m_depthRtDescr;
-	GraphicsRenderPassFramebufferDescription m_fbDescr;
+	FramebufferDescription m_fbDescr;
 
 	RenderingContext* m_ctx = nullptr;
 	Array<RenderTargetHandle, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRts;

src/anki/renderer/Indirect.cpp

@@ -286,7 +286,7 @@ void Indirect::initCacheEntry(U32 cacheEntryIdx)
 	{
 		// Light pass FB
 		{
-			GraphicsRenderPassFramebufferDescription& fbDescr = cacheEntry.m_lightShadingFbDescrs[faceIdx];
+			FramebufferDescription& fbDescr = cacheEntry.m_lightShadingFbDescrs[faceIdx];
 			ANKI_ASSERT(!fbDescr.isBacked());
 			fbDescr.m_colorAttachmentCount = 1;
 			fbDescr.m_colorAttachments[0].m_surface.m_layer = cacheEntryIdx;
@@ -297,7 +297,7 @@ void Indirect::initCacheEntry(U32 cacheEntryIdx)
 
 		// Irradiance FB
 		{
-			GraphicsRenderPassFramebufferDescription& fbDescr = cacheEntry.m_irradianceFbDescrs[faceIdx];
+			FramebufferDescription& fbDescr = cacheEntry.m_irradianceFbDescrs[faceIdx];
 			ANKI_ASSERT(!fbDescr.isBacked());
 			fbDescr.m_colorAttachmentCount = 1;
 			fbDescr.m_colorAttachments[0].m_surface.m_layer = cacheEntryIdx;

src/anki/renderer/Indirect.h

@@ -46,6 +46,16 @@ anki_internal:
 		return m_integrationLutSampler;
 	}
 
+	RenderTargetHandle getReflectionRt() const
+	{
+		return m_ctx.m_lightShadingRt;
+	}
+
+	RenderTargetHandle getIrradianceRt() const
+	{
+		return m_ctx.m_irradianceRt;
+	}
+
 private:
 	struct LightPassVertexUniforms;
 	struct LightPassPointLightUniforms;
@@ -57,7 +67,7 @@ private:
 		U32 m_tileSize = 0;
 		Array<RenderTargetDescription, GBUFFER_COLOR_ATTACHMENT_COUNT> m_colorRtDescrs;
 		RenderTargetDescription m_depthRtDescr;
-		GraphicsRenderPassFramebufferDescription m_fbDescr;
+		FramebufferDescription m_fbDescr;
 	} m_gbuffer; ///< G-buffer pass.
 
 	class
@@ -99,8 +109,8 @@ private:
 		U64 m_probeUuid;
 		Timestamp m_lastUsedTimestamp = 0; ///< When it was rendered.
 
-		Array<GraphicsRenderPassFramebufferDescription, 6> m_lightShadingFbDescrs;
-		Array<GraphicsRenderPassFramebufferDescription, 6> m_irradianceFbDescrs;
+		Array<FramebufferDescription, 6> m_lightShadingFbDescrs;
+		Array<FramebufferDescription, 6> m_irradianceFbDescrs;
 	};
 
 	DynamicArray<CacheEntry> m_cacheEntries;

src/anki/renderer/LightShading.cpp

@@ -12,15 +12,15 @@
 #include <anki/renderer/LightBin.h>
 #include <anki/renderer/RenderQueue.h>
 #include <anki/renderer/ForwardShading.h>
+#include <anki/renderer/DepthDownscale.h>
 #include <anki/misc/ConfigSet.h>
 #include <anki/util/HighRezTimer.h>
 
 namespace anki
 {
 
-class ShaderCommonUniforms
+struct ShaderCommonUniforms
 {
-public:
 	Vec4 m_projectionParams;
 	Vec4 m_rendererSizeTimePad1;
 	Vec4 m_nearFarClustererMagicPad1;
@@ -31,17 +31,6 @@ public:
 	Mat4 m_invProjMat;
 };
 
-enum class IsShaderVariantBit : U8
-{
-	P_LIGHTS = 1 << 0,
-	S_LIGHTS = 1 << 1,
-	DECALS = 1 << 2,
-	INDIRECT = 1 << 3,
-	P_LIGHTS_SHADOWS = 1 << 4,
-	S_LIGHTS_SHADOWS = 1 << 5
-};
-ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(IsShaderVariantBit, inline)
-
 LightShading::LightShading(Renderer* r)
 	: RendererObject(r)
 {
@@ -49,10 +38,7 @@ LightShading::LightShading(Renderer* r)
 
 LightShading::~LightShading()
 {
-	if(m_lightBin)
-	{
-		getAllocator().deleteInstance(m_lightBin);
-	}
+	getAllocator().deleteInstance(m_lightBin);
 }
 
 Error LightShading::init(const ConfigSet& config)
@@ -92,9 +78,7 @@ Error LightShading::initInternal(const ConfigSet& config)
 		&m_r->getThreadPool(),
 		&m_r->getStagingGpuMemoryManager());
 
-	//
 	// Load shaders and programs
-	//
 	ANKI_CHECK(getResourceManager().loadResource("programs/LightShading.ankiprog", m_prog));
 
 	ShaderProgramResourceConstantValueInitList<4> consts(m_prog);
@@ -105,22 +89,19 @@ Error LightShading::initInternal(const ConfigSet& config)
 
 	m_prog->getOrCreateVariant(consts.get(), m_progVariant);
 
-	//
-	// Create framebuffer
-	//
-	m_rt = m_r->createAndClearRenderTarget(m_r->create2DRenderTargetInitInfo(m_r->getWidth(),
+	// Create RT descr
+	m_rtDescr = m_r->create2DRenderTargetDescription(m_r->getWidth(),
 		m_r->getHeight(),
 		LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT,
 		TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
 		SamplingFilter::LINEAR,
-		1,
-		"lightp"));
+		"Light Shading");
+	m_rtDescr.bake();
 
-	FramebufferInitInfo fbInit("lightp");
-	fbInit.m_colorAttachmentCount = 1;
-	fbInit.m_colorAttachments[0].m_texture = m_rt;
-	fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
-	m_fb = getGrManager().newInstance<Framebuffer>(fbInit);
+	// Create FB descr
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
+	m_fbDescr.bake();
 
 	return Error::NONE;
 }
@@ -149,23 +130,20 @@ Error LightShading::binLights(RenderingContext& ctx)
 	return Error::NONE;
 }
 
-void LightShading::run(RenderingContext& ctx)
+void LightShading::run(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb)
 {
-	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
-
-	cmdb->beginRenderPass(m_fb);
 	cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
 	cmdb->bindShaderProgram(m_progVariant->getProgram());
 
-	// TODO cmdb->bindTexture(1, 0, m_r->getGBuffer().m_rt0);
-	// TODO cmdb->bindTexture(1, 1, m_r->getGBuffer().m_rt1);
-	// TODO cmdb->bindTexture(1, 2, m_r->getGBuffer().m_rt2);
-	// TODO cmdb->bindTexture(1, 3, m_r->getGBuffer().m_depthRt, DepthStencilAspectBit::DEPTH);
-	// TODO cmdb->bindTexture(1, 4, m_r->getSsao().getRt());
+	cmdb->bindTexture(1, 0, rgraph.getTexture(m_r->getGBuffer().getColorRt(0)));
+	cmdb->bindTexture(1, 1, rgraph.getTexture(m_r->getGBuffer().getColorRt(1)));
+	cmdb->bindTexture(1, 2, rgraph.getTexture(m_r->getGBuffer().getColorRt(2)));
+	cmdb->bindTexture(1, 3, rgraph.getTexture(m_r->getGBuffer().getDepthRt()), DepthStencilAspectBit::DEPTH);
+	cmdb->bindTexture(1, 4, rgraph.getTexture(m_r->getSsao().getRt()));
 
-	// TODO: cmdb->bindTexture(0, 0, m_r->getShadowMapping().m_shadowAtlas);
-	// TODO: cmdb->bindTexture(0, 1, m_r->getIndirect().getReflectionTexture());
-	// TODO: cmdb->bindTexture(0, 2, m_r->getIndirect().getIrradianceTexture());
+	cmdb->bindTexture(0, 0, rgraph.getTexture(m_r->getShadowMapping().getShadowmapRt()));
+	cmdb->bindTexture(0, 1, rgraph.getTexture(m_r->getIndirect().getReflectionRt()));
+	cmdb->bindTexture(0, 2, rgraph.getTexture(m_r->getIndirect().getIrradianceRt()));
 	cmdb->bindTextureAndSampler(
 		0, 3, m_r->getIndirect().getIntegrationLut(), m_r->getIndirect().getIntegrationLutSampler());
 	cmdb->bindTexture(
@@ -187,9 +165,7 @@ void LightShading::run(RenderingContext& ctx)
 	cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
 
 	// Apply the forward shading result
-	// TODO m_r->getForwardShading().drawUpscale(ctx);
-
-	cmdb->endRenderPass();
+	m_r->getForwardShading().drawUpscale(ctx, rgraph, cmdb);
 }
 
 void LightShading::updateCommonBlock(RenderingContext& ctx)
@@ -215,20 +191,34 @@ void LightShading::updateCommonBlock(RenderingContext& ctx)
 	blk->m_invProjMat = ctx.m_projMatJitter.getInverse();
 }
 
-void LightShading::setPreRunBarriers(RenderingContext& ctx)
+void LightShading::populateRenderGraph(RenderingContext& ctx)
 {
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rt,
-		TextureUsageBit::NONE,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureSurfaceInfo(0, 0, 0, 0));
-}
+	m_runCtx.m_ctx = &ctx;
+	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-void LightShading::setPostRunBarriers(RenderingContext& ctx)
-{
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rt,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE,
-		TextureUsageBit::SAMPLED_FRAGMENT,
-		TextureSurfaceInfo(0, 0, 0, 0));
+	// Create RT
+	m_runCtx.m_rt = rgraph.newRenderTarget(m_rtDescr);
+
+	// Create pass
+	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("Light Shading");
+
+	pass.setWork(runCallback, this, 0);
+	pass.setFramebufferInfo(m_fbDescr, {{m_runCtx.m_rt}}, {});
+
+	pass.newConsumer({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+	pass.newConsumer({m_r->getGBuffer().getColorRt(0), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getGBuffer().getColorRt(1), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getGBuffer().getColorRt(2), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getSsao().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getIndirect().getReflectionRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getIndirect().getIrradianceRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+
+	pass.newConsumer({m_r->getDepthDownscale().getHalfDepthColorRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getForwardShading().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+
+	pass.newProducer({m_runCtx.m_rt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 }
 
 } // end namespace anki

src/anki/renderer/LightShading.h

@@ -28,17 +28,13 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& initializer);
 
-	ANKI_USE_RESULT Error binLights(RenderingContext& ctx);
-
-	void setPreRunBarriers(RenderingContext& ctx);
-
-	void run(RenderingContext& ctx);
+	void populateRenderGraph(RenderingContext& ctx);
 
-	void setPostRunBarriers(RenderingContext& ctx);
+	ANKI_USE_RESULT Error binLights(RenderingContext& ctx);
 
-	TexturePtr getRt() const
+	RenderTargetHandle getRt() const
 	{
-		return m_rt;
+		return m_runCtx.m_rt;
 	}
 
 	const LightBin& getLightBin() const
@@ -47,14 +43,11 @@ anki_internal:
 	}
 
 private:
-	/// The IS render target
-	TexturePtr m_rt;
-
 	Array<U32, 3> m_clusterCounts = {{0, 0, 0}};
 	U32 m_clusterCount = 0;
 
-	/// The IS FBO
-	FramebufferPtr m_fb;
+	RenderTargetDescription m_rtDescr;
+	FramebufferDescription m_fbDescr;
 
 	// Light shaders
 	ShaderProgramResourcePtr m_prog;
@@ -67,10 +60,31 @@ private:
 	U32 m_maxLightIds;
 	/// @}
 
+	class
+	{
+	public:
+		RenderTargetHandle m_rt;
+		RenderingContext* m_ctx;
+	} m_runCtx; ///< Run context.
+
 	/// Called by init
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& initializer);
 
 	void updateCommonBlock(RenderingContext& ctx);
+
+	void run(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb);
+
+	/// A RenderPassWorkCallback for the light pass.
+	static void runCallback(void* userData,
+		CommandBufferPtr cmdb,
+		U32 secondLevelCmdbIdx,
+		U32 secondLevelCmdbCount,
+		const RenderGraph& rgraph)
+	{
+		ANKI_ASSERT(userData);
+		LightShading* self = static_cast<LightShading*>(userData);
+		self->run(*self->m_runCtx.m_ctx, rgraph, cmdb);
+	}
 };
 /// @}
 

src/anki/renderer/ShadowMapping.h

@@ -66,7 +66,7 @@ private:
 		}
 	};
 
-	GraphicsRenderPassFramebufferDescription m_esmFbDescr; ///< The FB for ESM
+	FramebufferDescription m_esmFbDescr; ///< The FB for ESM
 	TexturePtr m_esmAtlas; ///< ESM texture atlas.
 	RenderTargetHandle m_esmRt;
 
@@ -114,7 +114,7 @@ private:
 	/// @name Scratch buffer stuff
 	/// @{
 	RenderTargetHandle m_scratchRt; ///< Size of the RT is (m_scratchTileSize * m_scratchTileCount, m_scratchTileSize).
-	GraphicsRenderPassFramebufferDescription m_scratchFbDescr; ///< FB info.
+	FramebufferDescription m_scratchFbDescr; ///< FB info.
 	RenderTargetDescription m_scratchRtDescr; ///< Render target.
 
 	U32 m_scratchTileCount = 0;

src/anki/renderer/Ssao.cpp

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

src/anki/renderer/Ssao.h

@@ -33,6 +33,8 @@ anki_internal:
 	/// Populate the rendergraph.
 	void populateRenderGraph(RenderingContext& ctx);
 
+	RenderTargetHandle getRt() const;
+
 private:
 	U32 m_width, m_height;
 
@@ -66,7 +68,7 @@ private:
 	} m_runCtx; ///< Runtime context.
 
 	Array<TexturePtr, 2> m_rtTextures;
-	GraphicsRenderPassFramebufferDescription m_fbDescr;
+	FramebufferDescription m_fbDescr;
 
 	ANKI_USE_RESULT Error initMain(const ConfigSet& set);
 	ANKI_USE_RESULT Error initVBlur(const ConfigSet& set);

src/anki/renderer/TemporalAA.cpp

@@ -43,64 +43,61 @@ Error TemporalAA::initInternal(const ConfigSet& config)
 
 	for(U i = 0; i < 2; ++i)
 	{
-		m_rts[i] = m_r->createAndClearRenderTarget(m_r->create2DRenderTargetInitInfo(m_r->getWidth(),
+		m_rtTextures[i] = m_r->createAndClearRenderTarget(m_r->create2DRenderTargetInitInfo(m_r->getWidth(),
 			m_r->getHeight(),
 			LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT,
 			TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
 			SamplingFilter::LINEAR,
 			1,
-			"taa"));
-
-		FramebufferInitInfo fbInit("taa");
-		fbInit.m_colorAttachmentCount = 1;
-		fbInit.m_colorAttachments[0].m_texture = m_rts[i];
-		fbInit.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
-		m_fbs[i] = getGrManager().newInstance<Framebuffer>(fbInit);
+			"TemporalAA"));
 	}
 
-	return Error::NONE;
-}
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
+	m_fbDescr.bake();
 
-void TemporalAA::setPreRunBarriers(RenderingContext& ctx)
-{
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rts[m_r->getFrameCount() & 1],
-		TextureUsageBit::NONE,
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureSurfaceInfo(0, 0, 0, 0));
+	return Error::NONE;
 }
 
-void TemporalAA::run(RenderingContext& ctx)
+void TemporalAA::run(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb)
 {
-	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
-
-	cmdb->beginRenderPass(m_fbs[m_r->getFrameCount() & 1]);
 	cmdb->setViewport(0, 0, m_r->getWidth(), m_r->getHeight());
 
 	cmdb->bindShaderProgram(m_grProg);
-	// TODO cmdb->bindTextureAndSampler(0, 0, m_r->getGBuffer().m_depthRt, m_r->getLinearSampler());
-	cmdb->bindTextureAndSampler(0, 1, m_r->getLightShading().getRt(), m_r->getLinearSampler());
-	cmdb->informTextureCurrentUsage(m_rts[(m_r->getFrameCount() + 1) & 1], TextureUsageBit::SAMPLED_FRAGMENT);
-	cmdb->bindTextureAndSampler(0, 2, m_rts[(m_r->getFrameCount() + 1) & 1], m_r->getLinearSampler());
-	cmdb->bindStorageBuffer(0, 0, m_r->getTonemapping().m_luminanceBuff, 0, MAX_PTR_SIZE);
+	cmdb->bindTextureAndSampler(0, 0, rgraph.getTexture(m_r->getGBuffer().getDepthRt()), m_r->getLinearSampler());
+	cmdb->bindTextureAndSampler(0, 1, rgraph.getTexture(m_r->getLightShading().getRt()), m_r->getLinearSampler());
+	cmdb->bindTextureAndSampler(0, 2, rgraph.getTexture(m_runCtx.m_historyRt), m_r->getLinearSampler());
+	cmdb->bindStorageBuffer(0, 0, rgraph.getBuffer(m_r->getTonemapping().getAverageLuminanceBuffer()), 0, MAX_PTR_SIZE);
 
 	Mat4* unis = allocateAndBindUniforms<Mat4*>(sizeof(Mat4), cmdb, 0, 0);
 	*unis = ctx.m_jitterMat * ctx.m_prevViewProjMat * ctx.m_viewProjMatJitter.getInverse();
 
 	m_r->drawQuad(cmdb);
-	cmdb->endRenderPass();
 }
 
-void TemporalAA::setPostRunBarriers(RenderingContext& ctx)
+void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 {
-	ctx.m_commandBuffer->setTextureSurfaceBarrier(m_rts[m_r->getFrameCount() & 1],
-		TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE,
-		TextureUsageBit::SAMPLED_FRAGMENT,
-		TextureSurfaceInfo(0, 0, 0, 0));
-}
+	m_runCtx.m_ctx = &ctx;
+	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-TexturePtr TemporalAA::getRt() const
-{
-	return m_rts[m_r->getFrameCount() & 1];
+	// Import RTs
+	m_runCtx.m_historyRt = rgraph.importRenderTarget(
+		"TemporalAA hist", m_rtTextures[(m_r->getFrameCount() + 1) & 1], TextureUsageBit::SAMPLED_FRAGMENT);
+	m_runCtx.m_renderRt =
+		rgraph.importRenderTarget("TemporalAA", m_rtTextures[m_r->getFrameCount() & 1], TextureUsageBit::NONE);
+
+	// Create pass
+	GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("TemporalAA");
+
+	pass.setWork(runCallback, this, 0);
+	pass.setFramebufferInfo(m_fbDescr, {{m_runCtx.m_renderRt}}, {});
+
+	pass.newConsumer({m_runCtx.m_renderRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+	pass.newConsumer({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_r->getLightShading().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newConsumer({m_runCtx.m_historyRt, TextureUsageBit::SAMPLED_FRAGMENT});
+
+	pass.newProducer({m_runCtx.m_renderRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 }
 
 } // end namespace anki

src/anki/renderer/TemporalAA.h

@@ -21,22 +21,45 @@ public:
 
 	~TemporalAA();
 
-	TexturePtr getRt() const;
-
 	ANKI_USE_RESULT Error init(const ConfigSet& cfg);
 
-	void setPreRunBarriers(RenderingContext& ctx);
-	void run(RenderingContext& ctx);
-	void setPostRunBarriers(RenderingContext& ctx);
+	void populateRenderGraph(RenderingContext& ctx);
+
+	RenderTargetHandle getRt() const
+	{
+		return m_runCtx.m_renderRt;
+	}
 
 private:
-	Array<TexturePtr, 2> m_rts;
-	Array<FramebufferPtr, 2> m_fbs;
+	Array<TexturePtr, 2> m_rtTextures;
+	FramebufferDescription m_fbDescr;
 
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 
+	class
+	{
+	public:
+		RenderingContext* m_ctx = nullptr;
+		RenderTargetHandle m_renderRt;
+		RenderTargetHandle m_historyRt;
+	} m_runCtx;
+
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& cfg);
+
+	void run(const RenderingContext& ctx, const RenderGraph& rgraph, CommandBufferPtr& cmdb);
+
+	/// A RenderPassWorkCallback for the AA pass.
+	static void runCallback(void* userData,
+		CommandBufferPtr cmdb,
+		U32 secondLevelCmdbIdx,
+		U32 secondLevelCmdbCount,
+		const RenderGraph& rgraph)
+	{
+		ANKI_ASSERT(userData);
+		TemporalAA* self = static_cast<TemporalAA*>(userData);
+		self->run(*self->m_runCtx.m_ctx, rgraph, cmdb);
+	}
 };
 /// @}
 

src/anki/renderer/Tonemapping.cpp

@@ -61,14 +61,31 @@ Error Tonemapping::initInternal(const ConfigSet& initializer)
 	return Error::NONE;
 }
 
-void Tonemapping::run(RenderingContext& ctx)
+void Tonemapping::run(const RenderGraph& rgraph, CommandBufferPtr& cmdb)
 {
-	CommandBufferPtr& cmdb = ctx.m_commandBuffer;
 	cmdb->bindShaderProgram(m_grProg);
-	cmdb->bindStorageBuffer(0, 0, m_luminanceBuff, 0, MAX_PTR_SIZE);
-	cmdb->bindTexture(0, 0, m_r->getDownscaleBlur().getPassTexture(m_rtIdx));
+	cmdb->bindStorageBuffer(0, 0, rgraph.getBuffer(m_runCtx.m_buffHandle), 0, MAX_PTR_SIZE);
+	cmdb->bindTexture(0, 0, rgraph.getTexture(m_r->getDownscaleBlur().getPassRt(m_rtIdx)));
 
 	cmdb->dispatchCompute(1, 1, 1);
 }
 
+void Tonemapping::populateRenderGraph(RenderingContext& ctx)
+{
+	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
+
+	// Create buffer
+	m_runCtx.m_buffHandle = rgraph.importBuffer("Avg lum", m_luminanceBuff, BufferUsageBit::NONE);
+
+	// Create the pass
+	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Avg lum");
+
+	pass.setWork(runCallback, this, 0);
+
+	pass.newConsumer({m_runCtx.m_buffHandle, BufferUsageBit::STORAGE_COMPUTE_READ_WRITE});
+	pass.newConsumer({m_r->getDownscaleBlur().getPassRt(m_rtIdx), TextureUsageBit::SAMPLED_COMPUTE});
+
+	pass.newProducer({m_runCtx.m_buffHandle, BufferUsageBit::STORAGE_COMPUTE_READ_WRITE});
+}
+
 } // end namespace anki

src/anki/renderer/Tonemapping.h

@@ -17,8 +17,6 @@ namespace anki
 class Tonemapping : public RendererObject
 {
 anki_internal:
-	BufferPtr m_luminanceBuff;
-
 	Tonemapping(Renderer* r)
 		: RendererObject(r)
 	{
@@ -26,14 +24,42 @@ anki_internal:
 
 	ANKI_USE_RESULT Error init(const ConfigSet& cfg);
 
-	void run(RenderingContext& ctx);
+	/// Populate the rendergraph.
+	void populateRenderGraph(RenderingContext& ctx);
+
+	RenderPassBufferHandle getAverageLuminanceBuffer() const
+	{
+		return m_runCtx.m_buffHandle;
+	}
 
 private:
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;
 	U8 m_rtIdx;
 
+	BufferPtr m_luminanceBuff;
+
+	class
+	{
+	public:
+		RenderPassBufferHandle m_buffHandle;
+	} m_runCtx;
+
 	ANKI_USE_RESULT Error initInternal(const ConfigSet& cfg);
+
+	void run(const RenderGraph& rgraph, CommandBufferPtr& cmdb);
+
+	/// A RenderPassWorkCallback to run the compute pass.
+	static void runCallback(void* userData,
+		CommandBufferPtr cmdb,
+		U32 secondLevelCmdbIdx,
+		U32 secondLevelCmdbCount,
+		const RenderGraph& rgraph)
+	{
+		ANKI_ASSERT(userData);
+		Tonemapping* self = static_cast<Tonemapping*>(userData);
+		self->run(rgraph, cmdb);
+	}
 };
 /// @}
 

src/anki/renderer/Volumetric.h

@@ -77,7 +77,7 @@ private:
 	} m_runCtx; ///< Runtime context.
 
 	Array<TexturePtr, 2> m_rtTextures;
-	GraphicsRenderPassFramebufferDescription m_fbDescr;
+	FramebufferDescription m_fbDescr;
 
 	ANKI_USE_RESULT Error initMain(const ConfigSet& set);
 	ANKI_USE_RESULT Error initVBlur(const ConfigSet& set);

src/anki/util/Allocator.h

@@ -83,7 +83,7 @@ public:
 	template<typename... TArgs>
 	explicit GenericPoolAllocator(AllocAlignedCallback allocCb, void* allocCbUserData, TArgs&&... args)
 	{
-		m_pool = reinterpret_cast<TPool*>(allocCb(allocCbUserData, nullptr, sizeof(TPool), alignof(TPool)));
+		m_pool = static_cast<TPool*>(allocCb(allocCbUserData, nullptr, sizeof(TPool), alignof(TPool)));
 		if(ANKI_UNLIKELY(!m_pool))
 		{
 			ANKI_UTIL_LOGF("Out of memory");
@@ -140,7 +140,7 @@ public:
 
 		// Operator new doesn't respect alignment (in GCC at least) so use the type's alignment. If hint override the
 		// alignment
-		PtrSize alignment = (hint != nullptr) ? *reinterpret_cast<const PtrSize*>(hint) : alignof(value_type);
+		PtrSize alignment = (hint != nullptr) ? *static_cast<const PtrSize*>(hint) : alignof(value_type);
 
 		void* out = m_pool->allocate(size, alignment);
 		if(ANKI_UNLIKELY(out == nullptr))
@@ -148,7 +148,7 @@ public:
 			ANKI_UTIL_LOGF("Out of memory");
 		}
 
-		return reinterpret_cast<pointer>(out);
+		return static_cast<pointer>(out);
 	}
 
 	/// Deallocate memory

src/anki/util/ThreadHive.cpp

@@ -39,7 +39,7 @@ private:
 	/// Thread callaback
 	static Error threadCallback(anki::ThreadCallbackInfo& info)
 	{
-		Thread& self = *reinterpret_cast<Thread*>(info.m_userData);
+		Thread& self = *static_cast<Thread*>(info.m_userData);
 
 		self.m_hive->threadRun(self.m_id);
 		return Error::NONE;

src/anki/util/ThreadPool.cpp

@@ -39,7 +39,7 @@ private:
 	/// Thread callaback
 	static Error threadCallback(ThreadCallbackInfo& info)
 	{
-		ThreadPoolThread& self = *reinterpret_cast<ThreadPoolThread*>(info.m_userData);
+		ThreadPoolThread& self = *static_cast<ThreadPoolThread*>(info.m_userData);
 		Barrier& barrier = self.m_threadpool->m_barrier;
 		const PtrSize threadCount = self.m_threadpool->getThreadsCount();
 		Bool quit = false;
@@ -75,7 +75,7 @@ ThreadPool::ThreadPool(U32 threadsCount)
 	m_threadsCount = threadsCount;
 	ANKI_ASSERT(m_threadsCount <= MAX_THREADS && m_threadsCount > 0);
 
-	m_threads = reinterpret_cast<detail::ThreadPoolThread*>(malloc(sizeof(detail::ThreadPoolThread) * m_threadsCount));
+	m_threads = static_cast<detail::ThreadPoolThread*>(malloc(sizeof(detail::ThreadPoolThread) * m_threadsCount));
 
 	if(m_threads == nullptr)
 	{

src/anki/util/ThreadPosix.cpp

@@ -5,6 +5,7 @@
 
 #include <anki/util/Thread.h>
 #include <anki/util/Logger.h>
+#include <anki/util/Functions.h>
 #include <cstring>
 #include <algorithm>
 #include <pthread.h>
@@ -16,7 +17,7 @@ namespace anki
 static void* pthreadCallback(void* ud)
 {
 	ANKI_ASSERT(ud != nullptr);
-	Thread* thread = reinterpret_cast<Thread*>(ud);
+	Thread* thread = static_cast<Thread*>(ud);
 
 	// Set thread name
 	if(thread->getName()[0] != '\0')
@@ -31,7 +32,7 @@ static void* pthreadCallback(void* ud)
 
 	Error err = thread->getCallback()(info);
 
-	return reinterpret_cast<void*>(static_cast<PtrSize>(err._getCode()));
+	return numberToPtr<void*>(err._getCode());
 }
 
 Thread::Thread(const char* name)
@@ -79,7 +80,7 @@ void Thread::start(void* userData, ThreadCallback callback, I pinToCore)
 		pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpus);
 	}
 
-	pthread_t* thread = reinterpret_cast<pthread_t*>(m_impl);
+	pthread_t* thread = static_cast<pthread_t*>(m_impl);
 
 	m_callback = callback;
 	m_userData = userData;
@@ -100,7 +101,7 @@ void Thread::start(void* userData, ThreadCallback callback, I pinToCore)
 Error Thread::join()
 {
 	ANKI_ASSERT(m_started);
-	pthread_t* thread = reinterpret_cast<pthread_t*>(m_impl);
+	pthread_t* thread = static_cast<pthread_t*>(m_impl);
 
 	void* out;
 	I err = pthread_join(*thread, &out);
@@ -114,7 +115,7 @@ Error Thread::join()
 #endif
 
 	// Set return error code
-	Error code = static_cast<Error>(reinterpret_cast<PtrSize>(out));
+	Error code = static_cast<Error>(ptrToNumber(out));
 	return code;
 }
 
@@ -144,7 +145,7 @@ Mutex::Mutex()
 
 Mutex::~Mutex()
 {
-	pthread_mutex_t* mtx = reinterpret_cast<pthread_mutex_t*>(m_impl);
+	pthread_mutex_t* mtx = static_cast<pthread_mutex_t*>(m_impl);
 	pthread_mutex_destroy(mtx);
 
 	free(m_impl);
@@ -154,7 +155,7 @@ Mutex::~Mutex()
 void Mutex::lock()
 {
 	ANKI_ASSERT(m_impl);
-	pthread_mutex_t* mtx = reinterpret_cast<pthread_mutex_t*>(m_impl);
+	pthread_mutex_t* mtx = static_cast<pthread_mutex_t*>(m_impl);
 
 	I err = pthread_mutex_lock(mtx);
 	if(err)
@@ -166,7 +167,7 @@ void Mutex::lock()
 Bool Mutex::tryLock()
 {
 	ANKI_ASSERT(m_impl);
-	pthread_mutex_t* mtx = reinterpret_cast<pthread_mutex_t*>(m_impl);
+	pthread_mutex_t* mtx = static_cast<pthread_mutex_t*>(m_impl);
 
 	I err = pthread_mutex_trylock(mtx);
 	return err == 0;
@@ -175,7 +176,7 @@ Bool Mutex::tryLock()
 void Mutex::unlock()
 {
 	ANKI_ASSERT(m_impl);
-	pthread_mutex_t* mtx = reinterpret_cast<pthread_mutex_t*>(m_impl);
+	pthread_mutex_t* mtx = static_cast<pthread_mutex_t*>(m_impl);
 
 	I err = pthread_mutex_unlock(mtx);
 	if(err)
@@ -204,7 +205,7 @@ ConditionVariable::ConditionVariable()
 
 ConditionVariable::~ConditionVariable()
 {
-	pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(m_impl);
+	pthread_cond_t* cond = static_cast<pthread_cond_t*>(m_impl);
 	pthread_cond_destroy(cond);
 
 	free(m_impl);
@@ -214,14 +215,14 @@ ConditionVariable::~ConditionVariable()
 void ConditionVariable::notifyOne()
 {
 	ANKI_ASSERT(m_impl);
-	pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(m_impl);
+	pthread_cond_t* cond = static_cast<pthread_cond_t*>(m_impl);
 	pthread_cond_signal(cond);
 }
 
 void ConditionVariable::notifyAll()
 {
 	ANKI_ASSERT(m_impl);
-	pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(m_impl);
+	pthread_cond_t* cond = static_cast<pthread_cond_t*>(m_impl);
 	pthread_cond_broadcast(cond);
 }
 
@@ -229,8 +230,8 @@ void ConditionVariable::wait(Mutex& amtx)
 {
 	ANKI_ASSERT(m_impl);
 	ANKI_ASSERT(amtx.m_impl);
-	pthread_cond_t* cond = reinterpret_cast<pthread_cond_t*>(m_impl);
-	pthread_mutex_t* mtx = reinterpret_cast<pthread_mutex_t*>(amtx.m_impl);
+	pthread_cond_t* cond = static_cast<pthread_cond_t*>(m_impl);
+	pthread_mutex_t* mtx = static_cast<pthread_mutex_t*>(amtx.m_impl);
 
 	I err = pthread_cond_wait(cond, mtx);
 	if(err)

tests/gr/Gr.cpp

@@ -1531,6 +1531,16 @@ ANKI_TEST(Gr, 3DTextures)
 	COMMON_END()
 }
 
+static RenderTargetDescription newRTDescr(CString name)
+{
+	RenderTargetDescription texInf(name);
+	texInf.m_width = texInf.m_height = 16;
+	texInf.m_usage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::SAMPLED_FRAGMENT;
+	texInf.m_format = PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
+	texInf.bake();
+	return texInf;
+}
+
 ANKI_TEST(Gr, RenderGraph)
 {
 	COMMON_BEGIN()
@@ -1541,16 +1551,16 @@ ANKI_TEST(Gr, RenderGraph)
 
 	const U GI_MIP_COUNT = 4;
 
-	TextureInitInfo texInf("dummy tex");
-	texInf.m_width = texInf.m_height = 16;
-	texInf.m_usage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::SAMPLED_FRAGMENT;
-	texInf.m_format = PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
-	TexturePtr dummyTex = gr->newInstance<Texture>(texInf);
+	TextureInitInfo texI("dummy");
+	texI.m_width = texI.m_height = 16;
+	texI.m_usage = TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE | TextureUsageBit::SAMPLED_FRAGMENT;
+	texI.m_format = PixelFormat(ComponentFormat::R8G8B8A8, TransformFormat::UNORM);
+	TexturePtr dummyTex = gr->newInstance<Texture>(texI);
 
 	// SM
-	RenderTargetHandle smScratchRt = descr.newRenderTarget("SM", texInf);
+	RenderTargetHandle smScratchRt = descr.newRenderTarget(newRTDescr("SM scratch"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("SM");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SM");
 		pass.newConsumer({smScratchRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
 		pass.newProducer({smScratchRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_READ_WRITE});
 	}
@@ -1558,18 +1568,18 @@ ANKI_TEST(Gr, RenderGraph)
 	// SM to exponential SM
 	RenderTargetHandle smExpRt = descr.importRenderTarget("ESM", dummyTex, TextureUsageBit::SAMPLED_FRAGMENT);
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("ESM");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("ESM");
 		pass.newConsumer({smScratchRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newConsumer({smExpRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newProducer({smExpRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 	}
 
 	// GI gbuff
-	RenderTargetHandle giGbuffNormRt = descr.newRenderTarget("GI GBuff norm", texInf);
-	RenderTargetHandle giGbuffDiffRt = descr.newRenderTarget("GI GBuff diff", texInf);
-	RenderTargetHandle giGbuffDepthRt = descr.newRenderTarget("GI GBuff depth", texInf);
+	RenderTargetHandle giGbuffNormRt = descr.newRenderTarget(newRTDescr("GI GBuff norm"));
+	RenderTargetHandle giGbuffDiffRt = descr.newRenderTarget(newRTDescr("GI GBuff diff"));
+	RenderTargetHandle giGbuffDepthRt = descr.newRenderTarget(newRTDescr("GI GBuff depth"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("GI gbuff");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("GI gbuff");
 		pass.newConsumer({giGbuffNormRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({giGbuffDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({giGbuffDiffRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
@@ -1583,7 +1593,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle giGiLightRt = descr.importRenderTarget("GI light", dummyTex, TextureUsageBit::SAMPLED_FRAGMENT);
 	for(U faceIdx = 0; faceIdx < 6; ++faceIdx)
 	{
-		GraphicsRenderPassInfo& pass =
+		GraphicsRenderPassDescription& pass =
 			descr.newGraphicsRenderPass(StringAuto(alloc).sprintf("GI lp%u", faceIdx).toCString());
 		pass.newConsumer(
 			{giGiLightRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE, TextureSurfaceInfo(0, 0, faceIdx, 0)});
@@ -1599,7 +1609,7 @@ ANKI_TEST(Gr, RenderGraph)
 	{
 		for(U faceIdx = 0; faceIdx < 6; ++faceIdx)
 		{
-			GraphicsRenderPassInfo& pass =
+			GraphicsRenderPassDescription& pass =
 				descr.newGraphicsRenderPass(StringAuto(alloc).sprintf("GI mip%u", faceIdx).toCString());
 
 			for(U mip = 0; mip < GI_MIP_COUNT; ++mip)
@@ -1612,12 +1622,12 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// Gbuffer
-	RenderTargetHandle gbuffRt0 = descr.newRenderTarget("GBuff RT0", texInf);
-	RenderTargetHandle gbuffRt1 = descr.newRenderTarget("GBuff RT1", texInf);
-	RenderTargetHandle gbuffRt2 = descr.newRenderTarget("GBuff RT2", texInf);
-	RenderTargetHandle gbuffDepth = descr.newRenderTarget("GBuff RT2", texInf);
+	RenderTargetHandle gbuffRt0 = descr.newRenderTarget(newRTDescr("GBuff RT0"));
+	RenderTargetHandle gbuffRt1 = descr.newRenderTarget(newRTDescr("GBuff RT1"));
+	RenderTargetHandle gbuffRt2 = descr.newRenderTarget(newRTDescr("GBuff RT2"));
+	RenderTargetHandle gbuffDepth = descr.newRenderTarget(newRTDescr("GBuff RT2"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("G-Buffer");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("G-Buffer");
 		pass.newConsumer({gbuffRt0, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({gbuffRt1, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({gbuffRt2, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
@@ -1630,68 +1640,68 @@ ANKI_TEST(Gr, RenderGraph)
 	}
 
 	// Half depth
-	RenderTargetHandle halfDepthRt = descr.newRenderTarget("Depth/2", texInf);
+	RenderTargetHandle halfDepthRt = descr.newRenderTarget(newRTDescr("Depth/2"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("HalfDepth");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("HalfDepth");
 		pass.newConsumer({gbuffDepth, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newConsumer({halfDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newProducer({halfDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 	}
 
 	// Quarter depth
-	RenderTargetHandle quarterDepthRt = descr.newRenderTarget("Depth/4", texInf);
+	RenderTargetHandle quarterDepthRt = descr.newRenderTarget(newRTDescr("Depth/4"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("QuarterDepth");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("QuarterDepth");
 		pass.newConsumer({quarterDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({halfDepthRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newProducer({quarterDepthRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 	}
 
 	// SSAO
-	RenderTargetHandle ssaoRt = descr.newRenderTarget("SSAO", texInf);
+	RenderTargetHandle ssaoRt = descr.newRenderTarget(newRTDescr("SSAO"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("SSAO main");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("SSAO main");
 		pass.newConsumer({ssaoRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({quarterDepthRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newConsumer({gbuffRt2, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newProducer({ssaoRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 
-		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget("SSAO tmp", texInf);
-		GraphicsRenderPassInfo& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
+		RenderTargetHandle ssaoVBlurRt = descr.newRenderTarget(newRTDescr("SSAO tmp"));
+		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("SSAO vblur");
 		pass2.newConsumer({ssaoRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass2.newConsumer({ssaoVBlurRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass2.newProducer({ssaoVBlurRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 
-		GraphicsRenderPassInfo& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
+		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("SSAO hblur");
 		pass3.newConsumer({ssaoRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass3.newProducer({ssaoRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass3.newConsumer({ssaoVBlurRt, TextureUsageBit::SAMPLED_FRAGMENT});
 	}
 
 	// Volumetric
-	RenderTargetHandle volRt = descr.newRenderTarget("Vol", texInf);
+	RenderTargetHandle volRt = descr.newRenderTarget(newRTDescr("Vol"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("Vol main");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Vol main");
 		pass.newConsumer({volRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({quarterDepthRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newProducer({volRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 
-		RenderTargetHandle volVBlurRt = descr.newRenderTarget("Vol tmp", texInf);
-		GraphicsRenderPassInfo& pass2 = descr.newGraphicsRenderPass("Vol vblur");
+		RenderTargetHandle volVBlurRt = descr.newRenderTarget(newRTDescr("Vol tmp"));
+		GraphicsRenderPassDescription& pass2 = descr.newGraphicsRenderPass("Vol vblur");
 		pass2.newConsumer({volRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass2.newConsumer({volVBlurRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass2.newProducer({volVBlurRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 
-		GraphicsRenderPassInfo& pass3 = descr.newGraphicsRenderPass("Vol hblur");
+		GraphicsRenderPassDescription& pass3 = descr.newGraphicsRenderPass("Vol hblur");
 		pass3.newConsumer({volRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass3.newProducer({volRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass3.newConsumer({volVBlurRt, TextureUsageBit::SAMPLED_FRAGMENT});
 	}
 
 	// Forward shading
-	RenderTargetHandle fsRt = descr.newRenderTarget("FS", texInf);
+	RenderTargetHandle fsRt = descr.newRenderTarget(newRTDescr("FS"));
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("Forward shading");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Forward shading");
 		pass.newConsumer({fsRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newProducer({fsRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer(
@@ -1702,7 +1712,7 @@ ANKI_TEST(Gr, RenderGraph)
 	// Light shading
 	RenderTargetHandle lightRt = descr.importRenderTarget("Light", dummyTex, TextureUsageBit::NONE);
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("Light shading");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Light shading");
 
 		pass.newConsumer({lightRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
 		pass.newConsumer({gbuffRt0, TextureUsageBit::SAMPLED_FRAGMENT});
@@ -1721,7 +1731,7 @@ ANKI_TEST(Gr, RenderGraph)
 	RenderTargetHandle taaHistoryRt = descr.importRenderTarget("TAA hist", dummyTex, TextureUsageBit::SAMPLED_FRAGMENT);
 	RenderTargetHandle taaRt = descr.importRenderTarget("TAA", dummyTex, TextureUsageBit::NONE);
 	{
-		GraphicsRenderPassInfo& pass = descr.newGraphicsRenderPass("Temporal AA");
+		GraphicsRenderPassDescription& pass = descr.newGraphicsRenderPass("Temporal AA");
 
 		pass.newConsumer({lightRt, TextureUsageBit::SAMPLED_FRAGMENT});
 		pass.newConsumer({taaRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});