Make the MainRenderer a singleton

AnKi/Core/App.cpp

@@ -120,8 +120,7 @@ void App::cleanup()
 
 	SceneGraph::freeSingleton();
 	ScriptManager::freeSingleton();
-	deleteInstance(m_mainPool, m_renderer);
-	m_renderer = nullptr;
+	MainRenderer::freeSingleton();
 	UiManager::freeSingleton();
 	GpuSceneMicroPatcher::freeSingleton();
 	ResourceManager::freeSingleton();
@@ -146,6 +145,7 @@ void App::cleanup()
 	m_cacheDir.destroy();
 
 	CoreMemoryPool::freeSingleton();
+	DefaultMemoryPool::freeSingleton();
 }
 
 Error App::init(AllocAlignedCallback allocCb, void* allocCbUserData)
@@ -167,9 +167,17 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	setSignalHandlers();
 
 	initMemoryCallbacks(allocCb, allocCbUserData);
-	CoreMemoryPool::allocateSingleton(allocCb, allocCbUserData);
 
-	m_mainPool.init(allocCb, allocCbUserData, "Core");
+	if(DefaultMemoryPool::isAllocated())
+	{
+		// Re-cerate it with the new callbacks
+
+		ANKI_ASSERT(DefaultMemoryPool::getSingleton().getAllocationCount() == 0);
+		DefaultMemoryPool::freeSingleton();
+		DefaultMemoryPool::allocateSingleton(allocCb, allocCbUserData);
+	}
+
+	CoreMemoryPool::allocateSingleton(allocCb, allocCbUserData);
 
 	ANKI_CHECK(initDirs());
 
@@ -261,8 +269,8 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	// Graphics API
 	//
 	GrManagerInitInfo grInit;
-	grInit.m_allocCallback = m_mainPool.getAllocationCallback();
-	grInit.m_allocCallbackUserData = m_mainPool.getAllocationCallbackUserData();
+	grInit.m_allocCallback = allocCb;
+	grInit.m_allocCallbackUserData = allocCbUserData;
 	grInit.m_cacheDirectory = m_cacheDir.toCString();
 	ANKI_CHECK(GrManager::allocateSingleton().init(grInit));
 
@@ -286,32 +294,29 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	// Physics
 	//
 	PhysicsWorld::allocateSingleton();
-	ANKI_CHECK(PhysicsWorld::getSingleton().init(m_mainPool.getAllocationCallback(),
-												 m_mainPool.getAllocationCallbackUserData()));
+	ANKI_CHECK(PhysicsWorld::getSingleton().init(allocCb, allocCbUserData));
 
 	//
 	// Resources
 	//
 #if !ANKI_OS_ANDROID
 	// Add the location of the executable where the shaders are supposed to be
-	StringRaii executableFname(&m_mainPool);
+	StringRaii executableFname(&CoreMemoryPool::getSingleton());
 	ANKI_CHECK(getApplicationPath(executableFname));
 	ANKI_CORE_LOGI("Executable path is: %s", executableFname.cstr());
-	StringRaii shadersPath(&m_mainPool);
+	StringRaii shadersPath(&CoreMemoryPool::getSingleton());
 	getParentFilepath(executableFname, shadersPath);
 	shadersPath.append(":");
 	shadersPath.append(ConfigSet::getSingleton().getRsrcDataPaths());
 	ConfigSet::getSingleton().setRsrcDataPaths(shadersPath);
 #endif
 
-	ANKI_CHECK(ResourceManager::allocateSingleton().init(m_mainPool.getAllocationCallback(),
-														 m_mainPool.getAllocationCallbackUserData()));
+	ANKI_CHECK(ResourceManager::allocateSingleton().init(allocCb, allocCbUserData));
 
 	//
 	// UI
 	//
-	ANKI_CHECK(UiManager::allocateSingleton().init(m_mainPool.getAllocationCallback(),
-												   m_mainPool.getAllocationCallbackUserData()));
+	ANKI_CHECK(UiManager::allocateSingleton().init(allocCb, allocCbUserData));
 
 	//
 	// GPU scene
@@ -324,21 +329,19 @@ Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 	MainRendererInitInfo renderInit;
 	renderInit.m_swapchainSize =
 		UVec2(NativeWindow::getSingleton().getWidth(), NativeWindow::getSingleton().getHeight());
-	renderInit.m_allocCallback = m_mainPool.getAllocationCallback();
-	renderInit.m_allocCallbackUserData = m_mainPool.getAllocationCallbackUserData();
-	m_renderer = newInstance<MainRenderer>(m_mainPool);
-	ANKI_CHECK(m_renderer->init(renderInit));
+	renderInit.m_allocCallback = allocCb;
+	renderInit.m_allocCallbackUserData = allocCbUserData;
+	ANKI_CHECK(MainRenderer::allocateSingleton().init(renderInit));
 
 	//
 	// Script
 	//
-	ScriptManager::allocateSingleton(m_mainPool.getAllocationCallback(), m_mainPool.getAllocationCallbackUserData());
+	ScriptManager::allocateSingleton(allocCb, allocCbUserData);
 
 	//
 	// Scene
 	//
-	ANKI_CHECK(SceneGraph::allocateSingleton().init(m_mainPool.getAllocationCallback(),
-													m_mainPool.getAllocationCallbackUserData()));
+	ANKI_CHECK(SceneGraph::allocateSingleton().init(allocCb, allocCbUserData));
 
 	//
 	// Misc
@@ -355,7 +358,7 @@ Error App::initDirs()
 {
 	// Settings path
 #if !ANKI_OS_ANDROID
-	StringRaii home(&m_mainPool);
+	StringRaii home(&CoreMemoryPool::getSingleton());
 	ANKI_CHECK(getHomeDirectory(home));
 
 	m_settingsDir.sprintf("%s/.anki", &home[0]);
@@ -380,7 +383,7 @@ Error App::initDirs()
 	if(ConfigSet::getSingleton().getCoreClearCaches() && cacheDirExists)
 	{
 		ANKI_CORE_LOGI("Will delete the cache dir and start fresh: %s", m_cacheDir.cstr());
-		ANKI_CHECK(removeDirectory(m_cacheDir.toCString(), m_mainPool));
+		ANKI_CHECK(removeDirectory(m_cacheDir.toCString(), CoreMemoryPool::getSingleton()));
 		ANKI_CHECK(createDirectory(m_cacheDir.toCString()));
 	}
 	else if(!cacheDirExists)
@@ -407,7 +410,7 @@ Error App::mainLoop()
 	constexpr U32 kBenchmarkFramesToGatherBeforeFlush = 60;
 	U32 benchmarkFramesGathered = 0;
 	File benchmarkCsvFile;
-	StringRaii benchmarkCsvFileFilename(&m_mainPool);
+	CoreString benchmarkCsvFileFilename;
 	if(benchmarkMode)
 	{
 		benchmarkCsvFileFilename.sprintf("%s/Benchmark.csv", m_settingsDir.cstr());
@@ -436,17 +439,18 @@ Error App::mainLoop()
 			SceneGraph::getSingleton().doVisibilityTests(rqueue);
 
 			// Inject stats UI
-			DynamicArrayRaii<UiQueueElement> newUiElementArr(&m_mainPool);
+			CoreDynamicArray<UiQueueElement> newUiElementArr;
 			injectUiElements(newUiElementArr, rqueue);
 
 			// Render
 			TexturePtr presentableTex = GrManager::getSingleton().acquireNextPresentableTexture();
-			m_renderer->setStatsEnabled(ConfigSet::getSingleton().getCoreDisplayStats() > 0 || benchmarkMode
+			MainRenderer::getSingleton().setStatsEnabled(ConfigSet::getSingleton().getCoreDisplayStats() > 0
+														 || benchmarkMode
 #if ANKI_ENABLE_TRACE
-										|| Tracer::getSingleton().getEnabled()
+														 || Tracer::getSingleton().getEnabled()
 #endif
 			);
-			ANKI_CHECK(m_renderer->render(rqueue, presentableTex));
+			ANKI_CHECK(MainRenderer::getSingleton().render(rqueue, presentableTex));
 
 			// Pause and sync async loader. That will force all tasks before the pause to finish in this frame.
 			ResourceManager::getSingleton().getAsyncLoader().pause();
@@ -494,7 +498,7 @@ Error App::mainLoop()
 			else
 			{
 				aggregatedCpuTime += frameTime - grTime;
-				aggregatedGpuTime += m_renderer->getStats().m_renderingGpuTime;
+				aggregatedGpuTime += MainRenderer::getSingleton().getStats().m_renderingGpuTime;
 				++benchmarkFramesGathered;
 				if(benchmarkFramesGathered >= kBenchmarkFramesToGatherBeforeFlush)
 				{
@@ -513,12 +517,12 @@ Error App::mainLoop()
 			{
 				StatsUiInput in;
 				in.m_cpuFrameTime = frameTime - grTime;
-				in.m_rendererTime = m_renderer->getStats().m_renderingCpuTime;
+				in.m_rendererTime = MainRenderer::getSingleton().getStats().m_renderingCpuTime;
 				in.m_sceneUpdateTime = SceneGraph::getSingleton().getStats().m_updateTime;
 				in.m_visibilityTestsTime = SceneGraph::getSingleton().getStats().m_visibilityTestsTime;
 				in.m_physicsTime = SceneGraph::getSingleton().getStats().m_physicsUpdate;
 
-				in.m_gpuFrameTime = m_renderer->getStats().m_renderingGpuTime;
+				in.m_gpuFrameTime = MainRenderer::getSingleton().getStats().m_renderingGpuTime;
 
 				if(MaliHwCounters::isAllocated())
 				{
@@ -586,7 +590,7 @@ Error App::mainLoop()
 	return Error::kNone;
 }
 
-void App::injectUiElements(DynamicArrayRaii<UiQueueElement>& newUiElementArr, RenderQueue& rqueue)
+void App::injectUiElements(CoreDynamicArray<UiQueueElement>& newUiElementArr, RenderQueue& rqueue)
 {
 	const U32 originalCount = rqueue.m_uis.getSize();
 	if(ConfigSet::getSingleton().getCoreDisplayStats() > 0 || m_consoleEnabled)

AnKi/Core/App.h

@@ -13,7 +13,6 @@
 namespace anki {
 
 // Forward
-class MainRenderer;
 class UiQueueElement;
 class RenderQueue;
 
@@ -37,11 +36,6 @@ public:
 		return m_cacheDir;
 	}
 
-	HeapMemoryPool& getMemoryPool()
-	{
-		return m_mainPool;
-	}
-
 	/// Run the main loop.
 	Error mainLoop();
 
@@ -52,11 +46,6 @@ public:
 		return Error::kNone;
 	}
 
-	MainRenderer& getMainRenderer()
-	{
-		return *m_renderer;
-	}
-
 	void setDisplayDeveloperConsole(Bool display)
 	{
 		m_consoleEnabled = display;
@@ -68,11 +57,6 @@ public:
 	}
 
 private:
-	HeapMemoryPool m_mainPool; // TODO glob: rm
-
-	// Sybsystems
-	MainRenderer* m_renderer = nullptr;
-
 	// Misc
 	UiImmediateModeBuilderPtr m_statsUi;
 	UiImmediateModeBuilderPtr m_console;
@@ -102,7 +86,7 @@ private:
 	void cleanup();
 
 	/// Inject a new UI element in the render queue for displaying various stuff.
-	void injectUiElements(DynamicArrayRaii<UiQueueElement>& elements, RenderQueue& rqueue);
+	void injectUiElements(CoreDynamicArray<UiQueueElement>& elements, RenderQueue& rqueue);
 
 	void setSignalHandlers();
 };

AnKi/Core/GpuMemoryPools.cpp

@@ -43,6 +43,11 @@ void GpuSceneMemoryPool::init()
 	BufferUsageBit buffUsage = BufferUsageBit::kAllStorage | BufferUsageBit::kTransferDestination;
 
 	m_pool.init(buffUsage, classes, poolSize, "GpuScene", true);
+
+	// Allocate something dummy to force creating the GPU buffer
+	SegregatedListsGpuMemoryPoolToken token;
+	allocate(16, 4, token);
+	deferredFree(token);
 }
 
 RebarStagingGpuMemoryPool::~RebarStagingGpuMemoryPool()

AnKi/Renderer/AccelerationStructureBuilder.h

@@ -16,15 +16,6 @@ namespace anki {
 class AccelerationStructureBuilder : public RendererObject
 {
 public:
-	AccelerationStructureBuilder(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~AccelerationStructureBuilder()
-	{
-	}
-
 	Error init()
 	{
 		return Error::kNone;

AnKi/Renderer/Bloom.cpp

@@ -12,8 +12,7 @@
 
 namespace anki {
 
-Bloom::Bloom(Renderer* r)
-	: RendererObject(r)
+Bloom::Bloom()
 {
 	registerDebugRenderTarget("Bloom");
 }
@@ -35,12 +34,12 @@ Error Bloom::initInternal()
 
 Error Bloom::initExposure()
 {
-	m_exposure.m_width = m_r->getDownscaleBlur().getPassWidth(kMaxU32) * 2;
-	m_exposure.m_height = m_r->getDownscaleBlur().getPassHeight(kMaxU32) * 2;
+	m_exposure.m_width = getRenderer().getDownscaleBlur().getPassWidth(kMaxU32) * 2;
+	m_exposure.m_height = getRenderer().getDownscaleBlur().getPassHeight(kMaxU32) * 2;
 
 	// Create RT info
-	m_exposure.m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_exposure.m_width, m_exposure.m_height, kRtPixelFormat, "Bloom Exp");
+	m_exposure.m_rtDescr = getRenderer().create2DRenderTargetDescription(m_exposure.m_width, m_exposure.m_height,
+																		 kRtPixelFormat, "Bloom Exp");
 	m_exposure.m_rtDescr.bake();
 
 	// init shaders
@@ -64,12 +63,12 @@ Error Bloom::initExposure()
 
 Error Bloom::initUpscale()
 {
-	m_upscale.m_width = m_r->getPostProcessResolution().x() / kBloomFraction;
-	m_upscale.m_height = m_r->getPostProcessResolution().y() / kBloomFraction;
+	m_upscale.m_width = getRenderer().getPostProcessResolution().x() / kBloomFraction;
+	m_upscale.m_height = getRenderer().getPostProcessResolution().y() / kBloomFraction;
 
 	// Create RT descr
-	m_upscale.m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_upscale.m_width, m_upscale.m_height, kRtPixelFormat, "Bloom Upscale");
+	m_upscale.m_rtDescr = getRenderer().create2DRenderTargetDescription(m_upscale.m_width, m_upscale.m_height,
+																		kRtPixelFormat, "Bloom Upscale");
 	m_upscale.m_rtDescr.bake();
 
 	// init shaders
@@ -108,14 +107,14 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 		// Set the render pass
 		TextureSubresourceInfo inputTexSubresource;
-		inputTexSubresource.m_firstMipmap = m_r->getDownscaleBlur().getMipmapCount() - 1;
+		inputTexSubresource.m_firstMipmap = getRenderer().getDownscaleBlur().getMipmapCount() - 1;
 
 		RenderPassDescriptionBase* prpass;
 		if(preferCompute)
 		{
 			ComputeRenderPassDescription& rpass = rgraph.newComputeRenderPass("Bloom Main");
 
-			rpass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
+			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
 									   inputTexSubresource);
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kImageComputeWrite);
 
@@ -126,7 +125,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			GraphicsRenderPassDescription& rpass = rgraph.newGraphicsRenderPass("Bloom Main");
 			rpass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_exposureRt});
 
-			rpass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment,
+			rpass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledFragment,
 									   inputTexSubresource);
 			rpass.newTextureDependency(m_runCtx.m_exposureRt, TextureUsageBit::kFramebufferWrite);
 
@@ -139,16 +138,16 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 			cmdb->bindShaderProgram(m_exposure.m_grProg);
 
 			TextureSubresourceInfo inputTexSubresource;
-			inputTexSubresource.m_firstMipmap = m_r->getDownscaleBlur().getMipmapCount() - 1;
+			inputTexSubresource.m_firstMipmap = getRenderer().getDownscaleBlur().getMipmapCount() - 1;
 
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
-			rgraphCtx.bindTexture(0, 1, m_r->getDownscaleBlur().getRt(), inputTexSubresource);
+			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+			rgraphCtx.bindTexture(0, 1, getRenderer().getDownscaleBlur().getRt(), inputTexSubresource);
 
 			const Vec4 uniforms(ConfigSet::getSingleton().getRBloomThreshold(),
 								ConfigSet::getSingleton().getRBloomScale(), 0.0f, 0.0f);
 			cmdb->setPushConstants(&uniforms, sizeof(uniforms));
 
-			rgraphCtx.bindImage(0, 2, m_r->getTonemapping().getRt());
+			rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -197,7 +196,7 @@ void Bloom::populateRenderGraph(RenderingContext& ctx)
 
 			cmdb->bindShaderProgram(m_upscale.m_grProg);
 
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_exposureRt);
 			cmdb->bindTexture(0, 2, m_upscale.m_lensDirtImage->getTextureView());
 

AnKi/Renderer/Bloom.h

@@ -18,7 +18,7 @@ namespace anki {
 class Bloom : public RendererObject
 {
 public:
-	Bloom(Renderer* r);
+	Bloom();
 
 	~Bloom();
 

AnKi/Renderer/ClusterBinning.cpp

@@ -18,8 +18,7 @@
 
 namespace anki {
 
-ClusterBinning::ClusterBinning(Renderer* r)
-	: RendererObject(r)
+ClusterBinning::ClusterBinning()
 {
 }
 
@@ -34,19 +33,19 @@ Error ClusterBinning::init()
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/ClusterBinning.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
-	variantInitInfo.addConstant("kTileSize", m_r->getTileSize());
-	variantInitInfo.addConstant("kTileCountX", m_r->getTileCounts().x());
-	variantInitInfo.addConstant("kTileCountY", m_r->getTileCounts().y());
-	variantInitInfo.addConstant("kZSplitCount", m_r->getZSplitCount());
-	variantInitInfo.addConstant("kRenderingSize",
-								UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));
+	variantInitInfo.addConstant("kTileSize", getRenderer().getTileSize());
+	variantInitInfo.addConstant("kTileCountX", getRenderer().getTileCounts().x());
+	variantInitInfo.addConstant("kTileCountY", getRenderer().getTileCounts().y());
+	variantInitInfo.addConstant("kZSplitCount", getRenderer().getZSplitCount());
+	variantInitInfo.addConstant(
+		"kRenderingSize", UVec2(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y()));
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 
-	m_tileCount = m_r->getTileCounts().x() * m_r->getTileCounts().y();
-	m_clusterCount = m_tileCount + m_r->getZSplitCount();
+	m_tileCount = getRenderer().getTileCounts().x() * getRenderer().getTileCounts().y();
+	m_clusterCount = m_tileCount + getRenderer().getZSplitCount();
 
 	return Error::kNone;
 }
@@ -71,7 +70,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Cluster Binning");
 
-	pass.newBufferDependency(m_r->getPackVisibleClusteredObjects().getClusteredObjectsRenderGraphHandle(),
+	pass.newBufferDependency(getRenderer().getPackVisibleClusteredObjects().getClusteredObjectsRenderGraphHandle(),
 							 BufferUsageBit::kStorageComputeRead);
 
 	pass.newBufferDependency(m_runCtx.m_rebarHandle, BufferUsageBit::kStorageComputeWrite);
@@ -86,7 +85,7 @@ void ClusterBinning::populateRenderGraph(RenderingContext& ctx)
 
 		for(ClusteredObjectType type : EnumIterable<ClusteredObjectType>())
 		{
-			m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, U32(type) + 2, type);
+			getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, U32(type) + 2, type);
 		}
 
 		const U32 sampleCount = 4;
@@ -178,10 +177,11 @@ void ClusterBinning::writeClustererBuffersTask()
 			RebarStagingGpuMemoryPool::getSingleton().getBufferMappedAddress()
 			+ m_runCtx.m_clusteredShadingUniformsToken.m_offset);
 
-		unis.m_renderingSize = Vec2(F32(m_r->getInternalResolution().x()), F32(m_r->getInternalResolution().y()));
+		unis.m_renderingSize =
+			Vec2(F32(getRenderer().getInternalResolution().x()), F32(getRenderer().getInternalResolution().y()));
 
 		unis.m_time = F32(HighRezTimer::getCurrentTime());
-		unis.m_frame = m_r->getFrameCount() & kMaxU32;
+		unis.m_frame = getRenderer().getFrameCount() & kMaxU32;
 
 		Plane nearPlane;
 		extractClipPlane(rqueue.m_viewProjectionMatrix, FrustumPlaneType::kNear, nearPlane);
@@ -190,14 +190,15 @@ void ClusterBinning::writeClustererBuffersTask()
 		unis.m_far = rqueue.m_cameraFar;
 		unis.m_cameraPosition = rqueue.m_cameraTransform.getTranslationPart().xyz();
 
-		unis.m_tileCounts = m_r->getTileCounts();
-		unis.m_zSplitCount = m_r->getZSplitCount();
-		unis.m_zSplitCountOverFrustumLength = F32(m_r->getZSplitCount()) / (rqueue.m_cameraFar - rqueue.m_cameraNear);
+		unis.m_tileCounts = getRenderer().getTileCounts();
+		unis.m_zSplitCount = getRenderer().getZSplitCount();
+		unis.m_zSplitCountOverFrustumLength =
+			F32(getRenderer().getZSplitCount()) / (rqueue.m_cameraFar - rqueue.m_cameraNear);
 		unis.m_zSplitMagic.x() =
-			(rqueue.m_cameraNear - rqueue.m_cameraFar) / (rqueue.m_cameraNear * F32(m_r->getZSplitCount()));
-		unis.m_zSplitMagic.y() = rqueue.m_cameraFar / (rqueue.m_cameraNear * F32(m_r->getZSplitCount()));
-		unis.m_tileSize = m_r->getTileSize();
-		unis.m_lightVolumeLastZSplit = m_r->getVolumetricLightingAccumulation().getFinalZSplit();
+			(rqueue.m_cameraNear - rqueue.m_cameraFar) / (rqueue.m_cameraNear * F32(getRenderer().getZSplitCount()));
+		unis.m_zSplitMagic.y() = rqueue.m_cameraFar / (rqueue.m_cameraNear * F32(getRenderer().getZSplitCount()));
+		unis.m_tileSize = getRenderer().getTileSize();
+		unis.m_lightVolumeLastZSplit = getRenderer().getVolumetricLightingAccumulation().getFinalZSplit();
 
 		unis.m_objectCountsUpTo[ClusteredObjectType::kPointLight].x() = rqueue.m_pointLights.getSize();
 		unis.m_objectCountsUpTo[ClusteredObjectType::kSpotLight].x() =
@@ -214,7 +215,7 @@ void ClusterBinning::writeClustererBuffersTask()
 			unis.m_objectCountsUpTo[ClusteredObjectType::kGlobalIlluminationProbe - 1].x()
 			+ rqueue.m_giProbes.getSize();
 
-		unis.m_reflectionProbesMipCount = F32(m_r->getProbeReflections().getReflectionTextureMipmapCount());
+		unis.m_reflectionProbesMipCount = F32(getRenderer().getProbeReflections().getReflectionTextureMipmapCount());
 
 		unis.m_matrices = ctx.m_matrices;
 		unis.m_previousMatrices = ctx.m_prevMatrices;

AnKi/Renderer/ClusterBinning.h

@@ -16,7 +16,7 @@ namespace anki {
 class ClusterBinning : public RendererObject
 {
 public:
-	ClusterBinning(Renderer* r);
+	ClusterBinning();
 
 	~ClusterBinning();
 

AnKi/Renderer/Common.h

@@ -13,12 +13,6 @@
 
 namespace anki {
 
-#define ANKI_R_LOGI(...) ANKI_LOG("REND", kNormal, __VA_ARGS__)
-#define ANKI_R_LOGE(...) ANKI_LOG("REND", kError, __VA_ARGS__)
-#define ANKI_R_LOGW(...) ANKI_LOG("REND", kWarning, __VA_ARGS__)
-#define ANKI_R_LOGF(...) ANKI_LOG("REND", kFatal, __VA_ARGS__)
-#define ANKI_R_LOGV(...) ANKI_LOG("REND", kVerbose, __VA_ARGS__)
-
 // Forward
 #define ANKI_RENDERER_OBJECT_DEF(a, b) class a;
 #include <AnKi/Renderer/RendererObject.defs.h>
@@ -26,23 +20,33 @@ namespace anki {
 
 class Renderer;
 class RendererObject;
-class DebugDrawer;
-
 class RenderQueue;
-class RenderableQueueElement;
-class PointLightQueueElement;
-class DirectionalLightQueueElement;
-class SpotLightQueueElement;
-class ReflectionProbeQueueElement;
-class DecalQueueElement;
-class ResourceManager;
-class RebarStagingGpuMemoryPool;
-class UiManager;
-class ShaderProgramResourceVariant;
 
 /// @addtogroup renderer
 /// @{
 
+#define ANKI_R_LOGI(...) ANKI_LOG("REND", kNormal, __VA_ARGS__)
+#define ANKI_R_LOGE(...) ANKI_LOG("REND", kError, __VA_ARGS__)
+#define ANKI_R_LOGW(...) ANKI_LOG("REND", kWarning, __VA_ARGS__)
+#define ANKI_R_LOGF(...) ANKI_LOG("REND", kFatal, __VA_ARGS__)
+#define ANKI_R_LOGV(...) ANKI_LOG("REND", kVerbose, __VA_ARGS__)
+
+class RendererMemoryPool : public HeapMemoryPool, public MakeSingleton<RendererMemoryPool>
+{
+	template<typename>
+	friend class MakeSingleton;
+
+private:
+	RendererMemoryPool(AllocAlignedCallback allocCb, void* allocCbUserData)
+		: HeapMemoryPool(allocCb, allocCbUserData, "RendererMemPool")
+	{
+	}
+
+	~RendererMemoryPool() = default;
+};
+
+ANKI_DEFINE_SUBMODULE_UTIL_CONTAINERS(Renderer, RendererMemoryPool)
+
 /// Don't create second level command buffers if they contain more drawcalls than this constant.
 constexpr U32 kMinDrawcallsPerSecondaryCommandBuffer = 16;
 
@@ -72,11 +76,6 @@ constexpr U32 kDownscaleBurDownTo = 32;
 inline constexpr Array<Format, kGBufferColorRenderTargetCount> kGBufferColorRenderTargetFormats = {
 	{Format::kR8G8B8A8_Unorm, Format::kR8G8B8A8_Unorm, Format::kA2B10G10R10_Unorm_Pack32, Format::kR16G16_Snorm}};
 
-class RendererExternalSubsystems
-{
-public:
-};
-
 /// Rendering context.
 class RenderingContext
 {

AnKi/Renderer/Dbg.cpp

@@ -18,8 +18,7 @@
 
 namespace anki {
 
-Dbg::Dbg(Renderer* r)
-	: RendererObject(r)
+Dbg::Dbg()
 {
 }
 
@@ -32,8 +31,9 @@ Error Dbg::init()
 	ANKI_R_LOGV("Initializing DBG");
 
 	// RT descr
-	m_rtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-													 Format::kR8G8B8A8_Unorm, "Dbg");
+	m_rtDescr = getRenderer().create2DRenderTargetDescription(getRenderer().getInternalResolution().x(),
+															  getRenderer().getInternalResolution().y(),
+															  Format::kR8G8B8A8_Unorm, "Dbg");
 	m_rtDescr.bake();
 
 	// Create FB descr
@@ -62,12 +62,13 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 	// Set common state
-	cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 	cmdb->setDepthWrite(false);
 
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
 
-	rgraphCtx.bindTexture(0, 2, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getDepthRt(),
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 	cmdb->setDepthCompareOperation((m_depthTestOn) ? CompareOperation::kLess : CompareOperation::kAlways);
@@ -144,8 +145,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view,
 										   ConstWeakArray<Vec3>(&tsl, 1), Vec4(1.0f), m_ditheredDepthTestOn,
-										   m_giProbeImage->getTextureView(), m_r->getSamplers().m_trilinearRepeatAniso,
-										   Vec2(0.75f), cmdb);
+										   m_giProbeImage->getTextureView(),
+										   getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -159,7 +160,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 
 			m_drawer.drawBillboardTexture(ctx.m_matrices.m_projection, ctx.m_matrices.m_view, el.m_worldPosition,
 										  color.xyz1(), m_ditheredDepthTestOn, m_pointLightImage->getTextureView(),
-										  m_r->getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										  getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
 		}
 
 		for(const SpotLightQueueElement& el : ctx.m_renderQueue->m_spotLights)
@@ -170,7 +171,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			m_drawer.drawBillboardTexture(ctx.m_matrices.m_projection, ctx.m_matrices.m_view,
 										  el.m_worldTransform.getTranslationPart().xyz(), color.xyz1(),
 										  m_ditheredDepthTestOn, m_spotLightImage->getTextureView(),
-										  m_r->getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										  getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -196,8 +197,8 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			const Vec3 pos = el.m_obbCenter;
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view,
 										   ConstWeakArray<Vec3>(&pos, 1), Vec4(1.0f), m_ditheredDepthTestOn,
-										   m_decalImage->getTextureView(), m_r->getSamplers().m_trilinearRepeatAniso,
-										   Vec2(0.75f), cmdb);
+										   m_decalImage->getTextureView(),
+										   getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -223,7 +224,7 @@ void Dbg::run(RenderPassWorkContext& rgraphCtx, const RenderingContext& ctx)
 			m_drawer.drawBillboardTextures(ctx.m_matrices.m_projection, ctx.m_matrices.m_view,
 										   ConstWeakArray<Vec3>(&el.m_worldPosition, 1), Vec4(1.0f),
 										   m_ditheredDepthTestOn, m_reflectionImage->getTextureView(),
-										   m_r->getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
+										   getRenderer().getSamplers().m_trilinearRepeatAniso, Vec2(0.75f), cmdb);
 		}
 	}
 
@@ -258,10 +259,10 @@ void Dbg::populateRenderGraph(RenderingContext& ctx)
 					 run(rgraphCtx, ctx);
 				 });
 
-	pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rt}, m_r->getGBuffer().getDepthRt());
+	pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rt}, getRenderer().getGBuffer().getDepthRt());
 
 	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
-	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(),
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(),
 							  TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead);
 }
 

AnKi/Renderer/Dbg.h

@@ -20,7 +20,7 @@ namespace anki {
 class Dbg : public RendererObject
 {
 public:
-	Dbg(Renderer* r);
+	Dbg();
 
 	~Dbg();
 

AnKi/Renderer/DepthDownscale.cpp

@@ -33,14 +33,12 @@ DepthDownscale::~DepthDownscale()
 	{
 		m_clientBuffer->unmap();
 	}
-
-	m_fbDescrs.destroy(getMemoryPool());
 }
 
 Error DepthDownscale::initInternal()
 {
-	const U32 width = m_r->getInternalResolution().x() >> 1;
-	const U32 height = m_r->getInternalResolution().y() >> 1;
+	const U32 width = getRenderer().getInternalResolution().x() >> 1;
+	const U32 height = getRenderer().getInternalResolution().y() >> 1;
 
 	m_mipCount = computeMaxMipmapCount2d(width, height, hHierachicalZMinHeight);
 
@@ -65,9 +63,10 @@ Error DepthDownscale::initInternal()
 			usage |= TextureUsageBit::kFramebufferWrite;
 		}
 
-		TextureInitInfo texInit = m_r->create2DRenderTargetInitInfo(width, height, Format::kR32_Sfloat, usage, "HiZ");
+		TextureInitInfo texInit =
+			getRenderer().create2DRenderTargetInitInfo(width, height, Format::kR32_Sfloat, usage, "HiZ");
 		texInit.m_mipmapCount = U8(m_mipCount);
-		m_hizTex = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kSampledFragment);
+		m_hizTex = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Progs
@@ -140,7 +139,7 @@ Error DepthDownscale::initInternal()
 
 	if(!preferCompute)
 	{
-		m_fbDescrs.create(getMemoryPool(), m_mipCount);
+		m_fbDescrs.create(m_mipCount);
 		for(U32 mip = 0; mip < m_mipCount; ++mip)
 		{
 			FramebufferDescription& fbDescr = m_fbDescrs[mip];
@@ -190,7 +189,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("HiZ");
 
-		pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute,
+		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute,
 								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		for(U32 mip = 0; mip < m_mipCount; ++mip)
@@ -217,7 +216,7 @@ void DepthDownscale::populateRenderGraph(RenderingContext& ctx)
 
 			if(mip == 0)
 			{
-				pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
+				pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
 										  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 			}
 			else
@@ -259,14 +258,15 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 	varAU2(dispatchThreadGroupCountXY);
 	varAU2(workGroupOffset); // needed if Left and Top are not 0,0
 	varAU2(numWorkGroupsAndMips);
-	varAU4(rectInfo) = initAU4(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	varAU4(rectInfo) =
+		initAU4(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 	SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo);
 	SpdSetup(dispatchThreadGroupCountXY, workGroupOffset, numWorkGroupsAndMips, rectInfo, m_mipCount);
 
 	DepthDownscaleUniforms pc;
 	pc.m_workgroupCount = numWorkGroupsAndMips[0];
 	pc.m_mipmapCount = numWorkGroupsAndMips[1];
-	pc.m_srcTexSizeOverOne = 1.0f / Vec2(m_r->getInternalResolution());
+	pc.m_srcTexSizeOverOne = 1.0f / Vec2(getRenderer().getInternalResolution());
 	pc.m_lastMipWidth = m_lastMipSize.x();
 
 	cmdb->setPushConstants(&pc, sizeof(pc));
@@ -304,8 +304,9 @@ void DepthDownscale::runCompute(RenderPassWorkContext& rgraphCtx)
 	cmdb->bindStorageBuffer(0, 2, m_counterBuffer, 0, kMaxPtrSize);
 	cmdb->bindStorageBuffer(0, 3, m_clientBuffer, 0, kMaxPtrSize);
 
-	cmdb->bindSampler(0, 4, m_r->getSamplers().m_trilinearClamp);
-	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	cmdb->bindSampler(0, 4, getRenderer().getSamplers().m_trilinearClamp);
+	rgraphCtx.bindTexture(0, 5, getRenderer().getGBuffer().getDepthRt(),
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 	cmdb->dispatchCompute(dispatchThreadGroupCountXY[0], dispatchThreadGroupCountXY[1], 1);
 }
@@ -316,10 +317,10 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 
 	if(mip == 0)
 	{
-		rgraphCtx.bindTexture(0, 0, m_r->getGBuffer().getDepthRt(),
+		rgraphCtx.bindTexture(0, 0, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
 		cmdb->bindShaderProgram(m_firstMipGrProg);
 	}
@@ -335,7 +336,7 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 		}
 		else
 		{
-			cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 		}
 
 		cmdb->bindShaderProgram(m_grProg);
@@ -346,7 +347,7 @@ void DepthDownscale::runGraphics(U32 mip, RenderPassWorkContext& rgraphCtx)
 	const UVec4 pc((mip != m_mipCount - 1) ? 0 : m_lastMipSize.x());
 	cmdb->setPushConstants(&pc, sizeof(pc));
 
-	const UVec2 size = (m_r->getInternalResolution() / 2) >> mip;
+	const UVec2 size = (getRenderer().getInternalResolution() / 2) >> mip;
 	cmdb->setViewport(0, 0, size.x(), size.y());
 	cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 }

AnKi/Renderer/DepthDownscale.h

@@ -18,10 +18,7 @@ namespace anki {
 class DepthDownscale : public RendererObject
 {
 public:
-	DepthDownscale(Renderer* r)
-		: RendererObject(r)
-	{
-	}
+	DepthDownscale() = default;
 
 	~DepthDownscale();
 
@@ -69,7 +66,7 @@ private:
 
 	SamplerPtr m_reductionSampler;
 
-	DynamicArray<FramebufferDescription> m_fbDescrs;
+	RendererDynamicArray<FramebufferDescription> m_fbDescrs;
 
 	UVec2 m_lastMipSize;
 	U32 m_mipCount = 0;

AnKi/Renderer/DownscaleBlur.cpp

@@ -11,11 +11,6 @@
 
 namespace anki {
 
-DownscaleBlur::~DownscaleBlur()
-{
-	m_fbDescrs.destroy(getMemoryPool());
-}
-
 Error DownscaleBlur::init()
 {
 	const Error err = initInternal();
@@ -29,18 +24,18 @@ Error DownscaleBlur::init()
 
 Error DownscaleBlur::initInternal()
 {
-	m_passCount = computeMaxMipmapCount2d(m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(),
-										  kDownscaleBurDownTo)
+	m_passCount = computeMaxMipmapCount2d(getRenderer().getPostProcessResolution().x(),
+										  getRenderer().getPostProcessResolution().y(), kDownscaleBurDownTo)
 				  - 1;
 
-	const UVec2 rez = m_r->getPostProcessResolution() / 2;
+	const UVec2 rez = getRenderer().getPostProcessResolution() / 2;
 	ANKI_R_LOGV("Initializing downscale pyramid. Resolution %ux%u, mip count %u", rez.x(), rez.y(), m_passCount);
 
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 
 	// Create the miped texture
 	TextureInitInfo texinit =
-		m_r->create2DRenderTargetDescription(rez.x(), rez.y(), m_r->getHdrFormat(), "DownscaleBlur");
+		getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), getRenderer().getHdrFormat(), "DownscaleBlur");
 	texinit.m_usage = TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute;
 	if(preferCompute)
 	{
@@ -51,12 +46,12 @@ Error DownscaleBlur::initInternal()
 		texinit.m_usage |= TextureUsageBit::kFramebufferWrite;
 	}
 	texinit.m_mipmapCount = U8(m_passCount);
-	m_rtTex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledCompute);
+	m_rtTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledCompute);
 
 	// FB descr
 	if(!preferCompute)
 	{
-		m_fbDescrs.create(getMemoryPool(), m_passCount);
+		m_fbDescrs.create(m_passCount);
 		for(U32 pass = 0; pass < m_passCount; ++pass)
 		{
 			m_fbDescrs[pass].m_colorAttachmentCount = 1;
@@ -90,8 +85,9 @@ void DownscaleBlur::populateRenderGraph(RenderingContext& ctx)
 	// Create passes
 	static constexpr Array<CString, 8> passNames = {"DownBlur #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 =
-		(m_r->getScale().hasUpscaledHdrRt()) ? m_r->getScale().getUpscaledHdrRt() : m_r->getScale().getTonemappedRt();
+	const RenderTargetHandle inRt = (getRenderer().getScale().hasUpscaledHdrRt())
+										? getRenderer().getScale().getUpscaledHdrRt()
+										: getRenderer().getScale().getTonemappedRt();
 	if(ConfigSet::getSingleton().getRPreferCompute())
 	{
 		for(U32 i = 0; i < m_passCount; ++i)
@@ -162,7 +158,7 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	const U32 vpWidth = m_rtTex->getWidth() >> passIdx;
 	const U32 vpHeight = m_rtTex->getHeight() >> passIdx;
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
 
 	if(passIdx > 0)
 	{
@@ -172,14 +168,15 @@ void DownscaleBlur::run(U32 passIdx, RenderPassWorkContext& rgraphCtx)
 	}
 	else
 	{
-		const RenderTargetHandle inRt = (m_r->getScale().hasUpscaledHdrRt()) ? m_r->getScale().getUpscaledHdrRt()
-																			 : m_r->getScale().getTonemappedRt();
+		const RenderTargetHandle inRt = (getRenderer().getScale().hasUpscaledHdrRt())
+											? getRenderer().getScale().getUpscaledHdrRt()
+											: getRenderer().getScale().getTonemappedRt();
 		rgraphCtx.bindColorTexture(0, 1, inRt);
 	}
 
-	rgraphCtx.bindImage(0, 2, m_r->getTonemapping().getRt());
+	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
 
-	const Bool revertTonemap = passIdx == 0 && !m_r->getScale().hasUpscaledHdrRt();
+	const Bool revertTonemap = passIdx == 0 && !getRenderer().getScale().hasUpscaledHdrRt();
 	const UVec4 fbSize(vpWidth, vpHeight, revertTonemap, 0);
 	cmdb->setPushConstants(&fbSize, sizeof(fbSize));
 

AnKi/Renderer/DownscaleBlur.h

@@ -16,12 +16,9 @@ namespace anki {
 class DownscaleBlur : public RendererObject
 {
 public:
-	DownscaleBlur(Renderer* r)
-		: RendererObject(r)
-	{
-	}
+	DownscaleBlur() = default;
 
-	~DownscaleBlur();
+	~DownscaleBlur() = default;
 
 	Error init();
 
@@ -56,7 +53,7 @@ private:
 
 	TexturePtr m_rtTex;
 
-	DynamicArray<FramebufferDescription> m_fbDescrs;
+	RendererDynamicArray<FramebufferDescription> m_fbDescrs;
 
 	ShaderProgramResourcePtr m_prog;
 	ShaderProgramPtr m_grProg;

AnKi/Renderer/Drawer.h

@@ -13,6 +13,7 @@ namespace anki {
 
 // Forward
 class Renderer;
+class RenderableQueueElement;
 
 /// @addtogroup renderer
 /// @{
@@ -36,10 +37,7 @@ class RenderableDrawer
 	friend class RenderTask;
 
 public:
-	RenderableDrawer(Renderer* r)
-		: m_r(r)
-	{
-	}
+	RenderableDrawer() = default;
 
 	~RenderableDrawer();
 
@@ -49,8 +47,6 @@ public:
 private:
 	class Context;
 
-	Renderer* m_r;
-
 	void flushDrawcall(Context& ctx);
 
 	void drawSingle(const RenderableQueueElement* renderEl, Context& ctx);

AnKi/Renderer/FinalComposite.cpp

@@ -19,15 +19,6 @@
 
 namespace anki {
 
-FinalComposite::FinalComposite(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-FinalComposite::~FinalComposite()
-{
-}
-
 Error FinalComposite::initInternal()
 {
 	ANKI_R_LOGV("Initializing final composite");
@@ -44,7 +35,7 @@ Error FinalComposite::initInternal()
 	variantInitInfo.addMutation("FILM_GRAIN", (ConfigSet::getSingleton().getRFilmGrainStrength() > 0.0) ? 1 : 0);
 	variantInitInfo.addMutation("BLOOM_ENABLED", 1);
 	variantInitInfo.addConstant("kLutSize", U32(kLutSize));
-	variantInitInfo.addConstant("kFramebufferSize", m_r->getPostProcessResolution());
+	variantInitInfo.addConstant("kFramebufferSize", getRenderer().getPostProcessResolution());
 	variantInitInfo.addConstant("kMotionBlurSamples", ConfigSet::getSingleton().getRMotionBlurSamples());
 
 	for(U32 dbg = 0; dbg < 2; ++dbg)
@@ -102,17 +93,17 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 
 	if(ConfigSet::getSingleton().getRDbg())
 	{
-		pass.newTextureDependency(m_r->getDbg().getRt(), TextureUsageBit::kSampledFragment);
+		pass.newTextureDependency(getRenderer().getDbg().getRt(), TextureUsageBit::kSampledFragment);
 	}
 
-	pass.newTextureDependency(m_r->getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(m_r->getBloom().getRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment);
-	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getScale().getTonemappedRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getBloom().getRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment);
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr debugProgram;
-	const Bool hasDebugRt = m_r->getCurrentDebugRenderTarget(dbgRts, debugProgram);
+	const Bool hasDebugRt = getRenderer().getCurrentDebugRenderTarget(dbgRts, debugProgram);
 	if(hasDebugRt)
 	{
 		for(const RenderTargetHandle& handle : dbgRts)
@@ -132,7 +123,7 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 
 	Array<RenderTargetHandle, kMaxDebugRenderTargets> dbgRts;
 	ShaderProgramPtr optionalDebugProgram;
-	const Bool hasDebugRt = m_r->getCurrentDebugRenderTarget(dbgRts, optionalDebugProgram);
+	const Bool hasDebugRt = getRenderer().getCurrentDebugRenderTarget(dbgRts, optionalDebugProgram);
 
 	// Bind program
 	if(hasDebugRt && optionalDebugProgram.isCreated())
@@ -151,30 +142,30 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 	// Bind stuff
 	if(!hasDebugRt)
 	{
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
-		cmdb->bindSampler(0, 2, m_r->getSamplers().m_trilinearRepeat);
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+		cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat);
 
-		rgraphCtx.bindColorTexture(0, 3, m_r->getScale().getTonemappedRt());
+		rgraphCtx.bindColorTexture(0, 3, getRenderer().getScale().getTonemappedRt());
 
-		rgraphCtx.bindColorTexture(0, 4, m_r->getBloom().getRt());
+		rgraphCtx.bindColorTexture(0, 4, getRenderer().getBloom().getRt());
 		cmdb->bindTexture(0, 5, m_lut->getTextureView());
-		rgraphCtx.bindColorTexture(0, 6, m_r->getMotionVectors().getMotionVectorsRt());
-		rgraphCtx.bindTexture(0, 7, m_r->getGBuffer().getDepthRt(),
+		rgraphCtx.bindColorTexture(0, 6, getRenderer().getMotionVectors().getMotionVectorsRt());
+		rgraphCtx.bindTexture(0, 7, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(dbgEnabled)
 		{
-			rgraphCtx.bindColorTexture(0, 8, m_r->getDbg().getRt());
+			rgraphCtx.bindColorTexture(0, 8, getRenderer().getDbg().getRt());
 		}
 
 		const UVec4 pc(0, 0, floatBitsToUint(ConfigSet::getSingleton().getRFilmGrainStrength()),
-					   m_r->getFrameCount() & kMaxU32);
+					   getRenderer().getFrameCount() & kMaxU32);
 		cmdb->setPushConstants(&pc, sizeof(pc));
 	}
 	else
 	{
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 
 		U32 count = 1;
 		for(const RenderTargetHandle& handle : dbgRts)
@@ -186,11 +177,12 @@ void FinalComposite::run(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx
 		}
 	}
 
-	cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+	cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y());
 	drawQuad(cmdb);
 
 	// Draw UI
-	m_r->getUiStage().draw(m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(), ctx, cmdb);
+	getRenderer().getUiStage().draw(getRenderer().getPostProcessResolution().x(),
+									getRenderer().getPostProcessResolution().y(), ctx, cmdb);
 }
 
 } // end namespace anki

AnKi/Renderer/FinalComposite.h

@@ -17,8 +17,9 @@ namespace anki {
 class FinalComposite : public RendererObject
 {
 public:
-	FinalComposite(Renderer* r);
-	~FinalComposite();
+	FinalComposite() = default;
+
+	~FinalComposite() = default;
 
 	Error init();
 

AnKi/Renderer/ForwardShading.cpp

@@ -19,10 +19,6 @@
 
 namespace anki {
 
-ForwardShading::~ForwardShading()
-{
-}
-
 void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
@@ -38,34 +34,37 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 		cmdb->setBlendFactors(0, BlendFactor::kSrcAlpha, BlendFactor::kOneMinusSrcAlpha);
 
 		const U32 set = U32(MaterialSet::kGlobal);
-		cmdb->bindSampler(set, U32(MaterialBinding::kLinearClampSampler), m_r->getSamplers().m_trilinearClamp);
-		cmdb->bindSampler(set, U32(MaterialBinding::kShadowSampler), m_r->getSamplers().m_trilinearClampShadow);
+		cmdb->bindSampler(set, U32(MaterialBinding::kLinearClampSampler), getRenderer().getSamplers().m_trilinearClamp);
+		cmdb->bindSampler(set, U32(MaterialBinding::kShadowSampler),
+						  getRenderer().getSamplers().m_trilinearClampShadow);
 
-		rgraphCtx.bindTexture(set, U32(MaterialBinding::kDepthRt), m_r->getDepthDownscale().getHiZRt(),
+		rgraphCtx.bindTexture(set, U32(MaterialBinding::kDepthRt), getRenderer().getDepthDownscale().getHiZRt(),
 							  kHiZHalfSurface);
 		rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kLightVolume),
-								   m_r->getVolumetricLightingAccumulation().getRt());
+								   getRenderer().getVolumetricLightingAccumulation().getRt());
 
 		bindUniforms(cmdb, set, U32(MaterialBinding::kClusterShadingUniforms),
-					 m_r->getClusterBinning().getClusteredUniformsRebarToken());
-		m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
+					 getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+		getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
 			cmdb, set, U32(MaterialBinding::kClusterShadingLights), ClusteredObjectType::kPointLight);
-		m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
+		getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
 			cmdb, set, U32(MaterialBinding::kClusterShadingLights) + 1, ClusteredObjectType::kSpotLight);
 		rgraphCtx.bindColorTexture(set, U32(MaterialBinding::kClusterShadingLights) + 2,
-								   m_r->getShadowMapping().getShadowmapRt());
-		bindStorage(cmdb, set, U32(MaterialBinding::kClusters), m_r->getClusterBinning().getClustersRebarToken());
+								   getRenderer().getShadowMapping().getShadowmapRt());
+		bindStorage(cmdb, set, U32(MaterialBinding::kClusters),
+					getRenderer().getClusterBinning().getClustersRebarToken());
 
 		RenderableDrawerArguments args;
 		args.m_viewMatrix = ctx.m_matrices.m_view;
 		args.m_cameraTransform = ctx.m_matrices.m_cameraTransform;
 		args.m_viewProjectionMatrix = ctx.m_matrices.m_viewProjectionJitter;
 		args.m_previousViewProjectionMatrix = ctx.m_prevMatrices.m_viewProjectionJitter; // Not sure about that
-		args.m_sampler = m_r->getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
+		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
 
 		// Start drawing
-		m_r->getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + start,
-										ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + end, cmdb);
+		getRenderer().getSceneDrawer().drawRange(args,
+												 ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + start,
+												 ctx.m_renderQueue->m_forwardShadingRenderables.getBegin() + end, cmdb);
 
 		// Restore state
 		cmdb->setDepthWrite(true);
@@ -74,18 +73,20 @@ void ForwardShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 
 	if(threadId == threadCount - 1 && ctx.m_renderQueue->m_lensFlares.getSize())
 	{
-		m_r->getLensFlare().runDrawFlares(ctx, cmdb);
+		getRenderer().getLensFlare().runDrawFlares(ctx, cmdb);
 	}
 }
 
 void ForwardShading::setDependencies(const RenderingContext& ctx, GraphicsRenderPassDescription& pass)
 {
-	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledFragment, kHiZHalfSurface);
-	pass.newTextureDependency(m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledFragment);
+	pass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledFragment,
+							  kHiZHalfSurface);
+	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(),
+							  TextureUsageBit::kSampledFragment);
 
 	if(ctx.m_renderQueue->m_lensFlares.getSize())
 	{
-		pass.newBufferDependency(m_r->getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::kIndirectDraw);
+		pass.newBufferDependency(getRenderer().getLensFlare().getIndirectDrawBuffer(), BufferUsageBit::kIndirectDraw);
 	}
 }
 

AnKi/Renderer/ForwardShading.h

@@ -16,12 +16,9 @@ namespace anki {
 class ForwardShading : public RendererObject
 {
 public:
-	ForwardShading(Renderer* r)
-		: RendererObject(r)
-	{
-	}
+	ForwardShading() = default;
 
-	~ForwardShading();
+	~ForwardShading() = default;
 
 	Error init()
 	{

AnKi/Renderer/GBuffer.cpp

@@ -31,28 +31,28 @@ Error GBuffer::init()
 
 Error GBuffer::initInternal()
 {
-	ANKI_R_LOGV("Initializing GBuffer. Resolution %ux%u", m_r->getInternalResolution().x(),
-				m_r->getInternalResolution().y());
+	ANKI_R_LOGV("Initializing GBuffer. Resolution %ux%u", getRenderer().getInternalResolution().x(),
+				getRenderer().getInternalResolution().y());
 
 	// RTs
 	static constexpr Array<const char*, 2> depthRtNames = {{"GBuffer depth #0", "GBuffer depth #1"}};
 	for(U32 i = 0; i < 2; ++i)
 	{
 		const TextureUsageBit usage = TextureUsageBit::kAllSampled | TextureUsageBit::kAllFramebuffer;
-		TextureInitInfo texinit =
-			m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-											  m_r->getDepthNoStencilFormat(), usage, depthRtNames[i]);
+		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+			getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
+			getRenderer().getDepthNoStencilFormat(), usage, depthRtNames[i]);
 
-		m_depthRts[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_depthRts[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	static constexpr Array<const char*, kGBufferColorRenderTargetCount> rtNames = {
 		{"GBuffer rt0", "GBuffer rt1", "GBuffer rt2", "GBuffer rt3"}};
 	for(U i = 0; i < kGBufferColorRenderTargetCount; ++i)
 	{
-		m_colorRtDescrs[i] =
-			m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-												 kGBufferColorRenderTargetFormats[i], rtNames[i]);
+		m_colorRtDescrs[i] = getRenderer().create2DRenderTargetDescription(
+			getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
+			kGBufferColorRenderTargetFormats[i], rtNames[i]);
 		m_colorRtDescrs[i].bake();
 	}
 
@@ -78,8 +78,8 @@ Error GBuffer::initInternal()
 
 	if(GrManager::getSingleton().getDeviceCapabilities().m_vrs && ConfigSet::getSingleton().getRVrs())
 	{
-		m_fbDescr.m_shadingRateAttachmentTexelWidth = m_r->getVrsSriGeneration().getSriTexelDimension();
-		m_fbDescr.m_shadingRateAttachmentTexelHeight = m_r->getVrsSriGeneration().getSriTexelDimension();
+		m_fbDescr.m_shadingRateAttachmentTexelWidth = getRenderer().getVrsSriGeneration().getSriTexelDimension();
+		m_fbDescr.m_shadingRateAttachmentTexelHeight = getRenderer().getVrsSriGeneration().getSriTexelDimension();
 	}
 
 	m_fbDescr.bake();
@@ -103,7 +103,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	ANKI_ASSERT(end != start);
 
 	// Set some state, leave the rest to default
-	cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
 	const I32 earlyZStart = max(I32(start), 0);
 	const I32 earlyZEnd = min(I32(end), I32(earlyZCount));
@@ -125,7 +125,7 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 	args.m_cameraTransform = ctx.m_matrices.m_cameraTransform;
 	args.m_viewProjectionMatrix = ctx.m_matrices.m_viewProjectionJitter;
 	args.m_previousViewProjectionMatrix = ctx.m_matrices.m_jitter * ctx.m_prevMatrices.m_viewProjection;
-	args.m_sampler = m_r->getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
+	args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias;
 
 	// First do early Z (if needed)
 	if(earlyZStart < earlyZEnd)
@@ -136,8 +136,8 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 		}
 
 		ANKI_ASSERT(earlyZStart < earlyZEnd && earlyZEnd <= I32(earlyZCount));
-		m_r->getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_earlyZRenderables.getBegin() + earlyZStart,
-										ctx.m_renderQueue->m_earlyZRenderables.getBegin() + earlyZEnd, cmdb);
+		getRenderer().getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_earlyZRenderables.getBegin() + earlyZStart,
+												 ctx.m_renderQueue->m_earlyZRenderables.getBegin() + earlyZEnd, cmdb);
 
 		// Restore state for the color write
 		if(colorStart < colorEnd)
@@ -155,8 +155,8 @@ void GBuffer::runInThread(const RenderingContext& ctx, RenderPassWorkContext& rg
 		cmdb->setDepthCompareOperation(CompareOperation::kLessEqual);
 
 		ANKI_ASSERT(colorStart < colorEnd && colorEnd <= I32(ctx.m_renderQueue->m_renderables.getSize()));
-		m_r->getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_renderables.getBegin() + colorStart,
-										ctx.m_renderQueue->m_renderables.getBegin() + colorEnd, cmdb);
+		getRenderer().getSceneDrawer().drawRange(args, ctx.m_renderQueue->m_renderables.getBegin() + colorStart,
+												 ctx.m_renderQueue->m_renderables.getBegin() + colorEnd, cmdb);
 	}
 }
 
@@ -176,8 +176,8 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 
 		if(enableVrs)
 		{
-			m_fbDescr.m_shadingRateAttachmentTexelWidth = m_r->getVrsSriGeneration().getSriTexelDimension();
-			m_fbDescr.m_shadingRateAttachmentTexelHeight = m_r->getVrsSriGeneration().getSriTexelDimension();
+			m_fbDescr.m_shadingRateAttachmentTexelWidth = getRenderer().getVrsSriGeneration().getSriTexelDimension();
+			m_fbDescr.m_shadingRateAttachmentTexelHeight = getRenderer().getVrsSriGeneration().getSriTexelDimension();
 		}
 		else
 		{
@@ -200,21 +200,21 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 	{
 		// Already imported once
 		m_runCtx.m_crntFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::kNone);
-		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(m_r->getFrameCount() + 1) & 1]);
+			rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1], TextureUsageBit::kNone);
+		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1]);
 	}
 	else
 	{
 		m_runCtx.m_crntFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[m_r->getFrameCount() & 1], TextureUsageBit::kNone);
-		m_runCtx.m_prevFrameDepthRt =
-			rgraph.importRenderTarget(m_depthRts[(m_r->getFrameCount() + 1) & 1], TextureUsageBit::kSampledFragment);
+			rgraph.importRenderTarget(m_depthRts[getRenderer().getFrameCount() & 1], TextureUsageBit::kNone);
+		m_runCtx.m_prevFrameDepthRt = rgraph.importRenderTarget(m_depthRts[(getRenderer().getFrameCount() + 1) & 1],
+																TextureUsageBit::kSampledFragment);
 	}
 
 	RenderTargetHandle sriRt;
 	if(enableVrs)
 	{
-		sriRt = m_r->getVrsSriGeneration().getSriRt();
+		sriRt = getRenderer().getVrsSriGeneration().getSriRt();
 	}
 
 	// Create pass
@@ -241,7 +241,7 @@ void GBuffer::populateRenderGraph(RenderingContext& ctx)
 		pass.newTextureDependency(sriRt, TextureUsageBit::kFramebufferShadingRate);
 	}
 
-	pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 							 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 }
 

AnKi/Renderer/GBuffer.h

@@ -17,8 +17,7 @@ namespace anki {
 class GBuffer : public RendererObject
 {
 public:
-	GBuffer(Renderer* r)
-		: RendererObject(r)
+	GBuffer()
 	{
 		registerDebugRenderTarget("GBufferNormals");
 		registerDebugRenderTarget("GBufferAlbedo");

AnKi/Renderer/GBufferPost.cpp

@@ -12,10 +12,6 @@
 
 namespace anki {
 
-GBufferPost::~GBufferPost()
-{
-}
-
 Error GBufferPost::init()
 {
 	const Error err = initInternal();
@@ -34,9 +30,9 @@ Error GBufferPost::initInternal()
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/GBufferPost.ankiprogbin", m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
-	variantInitInfo.addConstant("kTileCount", m_r->getTileCounts());
-	variantInitInfo.addConstant("kZSplitCount", m_r->getZSplitCount());
-	variantInitInfo.addConstant("kTileSize", m_r->getTileSize());
+	variantInitInfo.addConstant("kTileCount", getRenderer().getTileCounts());
+	variantInitInfo.addConstant("kZSplitCount", getRenderer().getZSplitCount());
+	variantInitInfo.addConstant("kTileSize", getRenderer().getTileSize());
 
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
@@ -68,13 +64,14 @@ void GBufferPost::populateRenderGraph(RenderingContext& ctx)
 		run(rgraphCtx);
 	});
 
-	rpass.setFramebufferInfo(m_fbDescr, {m_r->getGBuffer().getColorRt(0), m_r->getGBuffer().getColorRt(1)});
+	rpass.setFramebufferInfo(m_fbDescr,
+							 {getRenderer().getGBuffer().getColorRt(0), getRenderer().getGBuffer().getColorRt(1)});
 
-	rpass.newTextureDependency(m_r->getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer);
-	rpass.newTextureDependency(m_r->getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer);
-	rpass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
+	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), TextureUsageBit::kAllFramebuffer);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), TextureUsageBit::kAllFramebuffer);
+	rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledFragment,
 							   TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-	rpass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+	rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 							  BufferUsageBit::kStorageFragmentRead);
 }
 
@@ -82,24 +79,25 @@ void GBufferPost::run(RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 	cmdb->bindShaderProgram(m_grProg);
 
 	cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
 	cmdb->setBlendFactors(1, BlendFactor::kOne, BlendFactor::kSrcAlpha, BlendFactor::kZero, BlendFactor::kOne);
 
 	// Bind all
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 
-	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	rgraphCtx.bindTexture(0, 1, getRenderer().getGBuffer().getDepthRt(),
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	cmdb->bindSampler(0, 2, m_r->getSamplers().m_trilinearRepeat);
+	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeat);
 
-	bindUniforms(cmdb, 0, 3, m_r->getClusterBinning().getClusteredUniformsRebarToken());
+	bindUniforms(cmdb, 0, 3, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 4, ClusteredObjectType::kDecal);
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 4, ClusteredObjectType::kDecal);
 
-	bindStorage(cmdb, 0, 5, m_r->getClusterBinning().getClustersRebarToken());
+	bindStorage(cmdb, 0, 5, getRenderer().getClusterBinning().getClustersRebarToken());
 
 	cmdb->bindAllBindless(1);
 

AnKi/Renderer/GBufferPost.h

@@ -16,13 +16,6 @@ namespace anki {
 class GBufferPost : public RendererObject
 {
 public:
-	GBufferPost(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~GBufferPost();
-
 	Error init();
 
 	/// Populate the rendergraph.

AnKi/Renderer/GenericCompute.cpp

@@ -10,10 +10,6 @@
 
 namespace anki {
 
-GenericCompute::~GenericCompute()
-{
-}
-
 void GenericCompute::populateRenderGraph(RenderingContext& ctx)
 {
 	if(ctx.m_renderQueue->m_genericGpuComputeJobs.getSize() == 0)
@@ -27,7 +23,7 @@ void GenericCompute::populateRenderGraph(RenderingContext& ctx)
 		run(ctx, rgraphCtx);
 	});
 
-	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute);
 }
 
 void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
@@ -44,7 +40,7 @@ void GenericCompute::run(const RenderingContext& ctx, RenderPassWorkContext& rgr
 	elementCtx.m_cameraTransform = ctx.m_matrices.m_cameraTransform;
 
 	// Bind some state
-	rgraphCtx.bindColorTexture(0, 0, m_r->getDepthDownscale().getHiZRt());
+	rgraphCtx.bindColorTexture(0, 0, getRenderer().getDepthDownscale().getHiZRt());
 
 	for(const GenericGpuComputeJobQueueElement& element : ctx.m_renderQueue->m_genericGpuComputeJobs)
 	{

AnKi/Renderer/GenericCompute.h

@@ -17,13 +17,6 @@ namespace anki {
 class GenericCompute : public RendererObject
 {
 public:
-	GenericCompute(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~GenericCompute();
-
 	Error init()
 	{
 		return Error::kNone;

AnKi/Renderer/IndirectDiffuse.cpp

@@ -16,10 +16,6 @@
 
 namespace anki {
 
-IndirectDiffuse::~IndirectDiffuse()
-{
-}
-
 Error IndirectDiffuse::init()
 {
 	const Error err = initInternal();
@@ -32,8 +28,9 @@ Error IndirectDiffuse::init()
 
 Error IndirectDiffuse::initInternal()
 {
-	const UVec2 size = m_r->getInternalResolution() / 2;
-	ANKI_ASSERT((m_r->getInternalResolution() % 2) == UVec2(0u) && "Needs to be dividable for proper upscaling");
+	const UVec2 size = getRenderer().getInternalResolution() / 2;
+	ANKI_ASSERT((getRenderer().getInternalResolution() % 2) == UVec2(0u)
+				&& "Needs to be dividable for proper upscaling");
 
 	ANKI_R_LOGV("Initializing indirect diffuse. Resolution %ux%u", size.x(), size.y());
 
@@ -43,11 +40,11 @@ Error IndirectDiffuse::initInternal()
 	TextureUsageBit usage = TextureUsageBit::kAllSampled;
 
 	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
-	TextureInitInfo texInit =
-		m_r->create2DRenderTargetInitInfo(size.x(), size.y(), m_r->getHdrFormat(), usage, "IndirectDiffuse #1");
-	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+	TextureInitInfo texInit = getRenderer().create2DRenderTargetInitInfo(
+		size.x(), size.y(), getRenderer().getHdrFormat(), usage, "IndirectDiffuse #1");
+	m_rts[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 	texInit.setName("IndirectDiffuse #2");
-	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+	m_rts[1] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 
 	if(!preferCompute)
 	{
@@ -65,7 +62,7 @@ Error IndirectDiffuse::initInternal()
 
 		const UVec2 rez = (size + m_vrs.m_sriTexelDimension - 1) / m_vrs.m_sriTexelDimension;
 		m_vrs.m_rtHandle =
-			m_r->create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR8_Uint, "IndirectDiffuseVrsSri");
+			getRenderer().create2DRenderTargetDescription(rez.x(), rez.y(), Format::kR8_Uint, "IndirectDiffuseVrsSri");
 		m_vrs.m_rtHandle.bake();
 
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource(
@@ -174,18 +171,18 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("IndirectDiffuse VRS SRI gen");
 
 		pass.newTextureDependency(m_runCtx.m_sriRt, TextureUsageBit::kImageComputeWrite);
-		pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
+		pass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
 								  kHiZHalfSurface);
 
 		pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
-			const UVec2 viewport = m_r->getInternalResolution() / 2u;
+			const UVec2 viewport = getRenderer().getInternalResolution() / 2u;
 
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 			cmdb->bindShaderProgram(m_vrs.m_grProg);
 
-			rgraphCtx.bindTexture(0, 0, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-			cmdb->bindSampler(0, 1, m_r->getSamplers().m_nearestNearestClamp);
+			rgraphCtx.bindTexture(0, 0, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_sriRt);
 
 			class
@@ -208,7 +205,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 	// SSGI+probes
 	{
 		// Create RTs
-		const U32 readRtIdx = m_r->getFrameCount() & 1;
+		const U32 readRtIdx = getRenderer().getFrameCount() & 1;
 		const U32 writeRtIdx = !readRtIdx;
 		if(m_rtsImportedOnce) [[likely]]
 		{
@@ -250,39 +247,40 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kWrite], writeUsage);
 
-		if(m_r->getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
+		if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
 		{
-			prpass->newTextureDependency(m_r->getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(), readUsage);
+			prpass->newTextureDependency(getRenderer().getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(),
+										 readUsage);
 		}
 
-		prpass->newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
+		prpass->newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		prpass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
-		prpass->newTextureDependency(m_r->getDownscaleBlur().getRt(), readUsage);
-		prpass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
-		prpass->newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), readUsage);
+		prpass->newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
+		prpass->newTextureDependency(getRenderer().getDownscaleBlur().getRt(), readUsage);
+		prpass->newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
+		prpass->newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(), readUsage);
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[kRead], readUsage);
 
 		prpass->setWork([this, &ctx, enableVrs](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 			cmdb->bindShaderProgram(m_main.m_grProg);
 
-			bindUniforms(cmdb, 0, 0, m_r->getClusterBinning().getClusteredUniformsRebarToken());
-			m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
+			bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+			getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
 				cmdb, 0, 1, ClusteredObjectType::kGlobalIlluminationProbe);
-			bindStorage(cmdb, 0, 2, m_r->getClusterBinning().getClustersRebarToken());
+			bindStorage(cmdb, 0, 2, getRenderer().getClusterBinning().getClustersRebarToken());
 
-			cmdb->bindSampler(0, 3, m_r->getSamplers().m_trilinearClamp);
-			rgraphCtx.bindColorTexture(0, 4, m_r->getGBuffer().getColorRt(2));
+			cmdb->bindSampler(0, 3, getRenderer().getSamplers().m_trilinearClamp);
+			rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
 
 			TextureSubresourceInfo hizSubresource;
 			hizSubresource.m_mipmapCount = 1;
-			rgraphCtx.bindTexture(0, 5, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
-			rgraphCtx.bindColorTexture(0, 6, m_r->getDownscaleBlur().getRt());
+			rgraphCtx.bindTexture(0, 5, getRenderer().getDepthDownscale().getHiZRt(), hizSubresource);
+			rgraphCtx.bindColorTexture(0, 6, getRenderer().getDownscaleBlur().getRt());
 			rgraphCtx.bindColorTexture(0, 7, m_runCtx.m_mainRtHandles[kRead]);
-			rgraphCtx.bindColorTexture(0, 8, m_r->getMotionVectors().getMotionVectorsRt());
-			rgraphCtx.bindColorTexture(0, 9, m_r->getMotionVectors().getHistoryLengthRt());
+			rgraphCtx.bindColorTexture(0, 8, getRenderer().getMotionVectors().getMotionVectorsRt());
+			rgraphCtx.bindColorTexture(0, 9, getRenderer().getMotionVectors().getHistoryLengthRt());
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -293,7 +291,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			// Bind uniforms
 			IndirectDiffuseUniforms unis;
-			unis.m_viewportSize = m_r->getInternalResolution() / 2u;
+			unis.m_viewportSize = getRenderer().getInternalResolution() / 2u;
 			unis.m_viewportSizef = Vec2(unis.m_viewportSize);
 			const Mat4& pmat = ctx.m_matrices.m_projection;
 			unis.m_projectionMat = Vec4(pmat(0, 0), pmat(1, 1), pmat(2, 2), pmat(2, 3));
@@ -352,18 +350,18 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount = 1;
-		prpass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
+		prpass->newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
 		prpass->newTextureDependency(m_runCtx.m_mainRtHandles[!readIdx], writeUsage);
 
 		prpass->setWork([this, &ctx, dir, readIdx](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 			cmdb->bindShaderProgram(m_denoise.m_grProgs[dir]);
 
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_mainRtHandles[readIdx]);
 			TextureSubresourceInfo hizSubresource;
 			hizSubresource.m_mipmapCount = 1;
-			rgraphCtx.bindTexture(0, 2, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
+			rgraphCtx.bindTexture(0, 2, getRenderer().getDepthDownscale().getHiZRt(), hizSubresource);
 
 			if(ConfigSet::getSingleton().getRPreferCompute())
 			{
@@ -372,7 +370,7 @@ void IndirectDiffuse::populateRenderGraph(RenderingContext& ctx)
 
 			IndirectDiffuseDenoiseUniforms unis;
 			unis.m_invertedViewProjectionJitterMat = ctx.m_matrices.m_invertedViewProjectionJitter;
-			unis.m_viewportSize = m_r->getInternalResolution() / 2u;
+			unis.m_viewportSize = getRenderer().getInternalResolution() / 2u;
 			unis.m_viewportSizef = Vec2(unis.m_viewportSize);
 			unis.m_sampleCountDiv2 = F32(ConfigSet::getSingleton().getRIndirectDiffuseDenoiseSampleCount());
 			unis.m_sampleCountDiv2 = max(1.0f, std::round(unis.m_sampleCountDiv2 / 2.0f));

AnKi/Renderer/IndirectDiffuse.h

@@ -18,15 +18,12 @@ namespace anki {
 class IndirectDiffuse : public RendererObject
 {
 public:
-	IndirectDiffuse(Renderer* r)
-		: RendererObject(r)
+	IndirectDiffuse()
 	{
 		registerDebugRenderTarget("IndirectDiffuse");
 		registerDebugRenderTarget("IndirectDiffuseVrsSri");
 	}
 
-	~IndirectDiffuse();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/IndirectDiffuseProbes.cpp

@@ -36,10 +36,6 @@ public:
 	}
 };
 
-IndirectDiffuseProbes::~IndirectDiffuseProbes()
-{
-}
-
 RenderTargetHandle IndirectDiffuseProbes::getCurrentlyRefreshedVolumeRt() const
 {
 	ANKI_ASSERT(m_giCtx && m_giCtx->m_irradianceVolume.isValid());
@@ -78,7 +74,7 @@ Error IndirectDiffuseProbes::initGBuffer()
 {
 	// Create RT descriptions
 	{
-		RenderTargetDescription texinit = m_r->create2DRenderTargetDescription(
+		RenderTargetDescription texinit = getRenderer().create2DRenderTargetDescription(
 			m_tileSize * 6, m_tileSize, kGBufferColorRenderTargetFormats[0], "GI GBuffer");
 
 		// Create color RT descriptions
@@ -86,13 +82,12 @@ Error IndirectDiffuseProbes::initGBuffer()
 		{
 			texinit.m_format = kGBufferColorRenderTargetFormats[i];
 			m_gbuffer.m_colorRtDescrs[i] = texinit;
-			m_gbuffer.m_colorRtDescrs[i].setName(
-				StringRaii(&getMemoryPool()).sprintf("GI GBuff Col #%u", i).toCString());
+			m_gbuffer.m_colorRtDescrs[i].setName(RendererString().sprintf("GI GBuff Col #%u", i).toCString());
 			m_gbuffer.m_colorRtDescrs[i].bake();
 		}
 
 		// Create depth RT
-		texinit.m_format = m_r->getDepthNoStencilFormat();
+		texinit.m_format = getRenderer().getDepthNoStencilFormat();
 		texinit.setName("GI GBuff Depth");
 		m_gbuffer.m_depthRtDescr = texinit;
 		m_gbuffer.m_depthRtDescr.bake();
@@ -123,8 +118,8 @@ Error IndirectDiffuseProbes::initShadowMapping()
 	ANKI_ASSERT(resolution > 8);
 
 	// RT descr
-	m_shadowMapping.m_rtDescr =
-		m_r->create2DRenderTargetDescription(resolution * 6, resolution, m_r->getDepthNoStencilFormat(), "GI SM");
+	m_shadowMapping.m_rtDescr = getRenderer().create2DRenderTargetDescription(
+		resolution * 6, resolution, getRenderer().getDepthNoStencilFormat(), "GI SM");
 	m_shadowMapping.m_rtDescr.bake();
 
 	// FB descr
@@ -141,8 +136,8 @@ Error IndirectDiffuseProbes::initLightShading()
 {
 	// Init RT descr
 	{
-		m_lightShading.m_rtDescr =
-			m_r->create2DRenderTargetDescription(m_tileSize * 6, m_tileSize, m_r->getHdrFormat(), "GI LS");
+		m_lightShading.m_rtDescr = getRenderer().create2DRenderTargetDescription(m_tileSize * 6, m_tileSize,
+																				 getRenderer().getHdrFormat(), "GI LS");
 		m_lightShading.m_rtDescr.bake();
 	}
 
@@ -238,7 +233,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(giCtx->m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 	}
 
@@ -278,7 +273,7 @@ void IndirectDiffuseProbes::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(giCtx->m_shadowsRt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 	}
 	else
@@ -372,10 +367,10 @@ void IndirectDiffuseProbes::runGBufferInThread(RenderPassWorkContext& rgraphCtx,
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = rqueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = m_r->getSamplers().m_trilinearRepeat;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat;
 
-			m_r->getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart,
-											rqueue.m_renderables.getBegin() + localEnd, cmdb);
+			getRenderer().getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart,
+													 rqueue.m_renderables.getBegin() + localEnd, cmdb);
 		}
 
 		drawcallCount += faceDrawcallCount;
@@ -428,10 +423,10 @@ void IndirectDiffuseProbes::runShadowmappingInThread(RenderPassWorkContext& rgra
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = cascadeRenderQueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = m_r->getSamplers().m_trilinearRepeatAniso;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
 
-			m_r->getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
-											cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);
+			getRenderer().getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
+													 cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);
 		}
 	}
 
@@ -498,7 +493,7 @@ void IndirectDiffuseProbes::runIrradiance(RenderPassWorkContext& rgraphCtx, Inte
 	cmdb->bindShaderProgram(m_irradiance.m_grProg);
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 	rgraphCtx.bindColorTexture(0, 1, giCtx.m_lightShadingRt);
 
 	for(U32 i = 0; i < kGBufferColorRenderTargetCount - 1; ++i)

AnKi/Renderer/IndirectDiffuseProbes.h

@@ -21,14 +21,6 @@ namespace anki {
 class IndirectDiffuseProbes : public RendererObject
 {
 public:
-	IndirectDiffuseProbes(Renderer* r)
-		: RendererObject(r)
-		, m_lightShading(r)
-	{
-	}
-
-	~IndirectDiffuseProbes();
-
 	Error init();
 
 	/// Populate the rendergraph.
@@ -62,11 +54,6 @@ private:
 		RenderTargetDescription m_rtDescr;
 		FramebufferDescription m_fbDescr;
 		TraditionalDeferredLightShading m_deferred;
-
-		LS(Renderer* r)
-			: m_deferred(r)
-		{
-		}
 	} m_lightShading; ///< Light shading.
 
 	class

AnKi/Renderer/IndirectSpecular.cpp

@@ -18,10 +18,6 @@
 
 namespace anki {
 
-IndirectSpecular::~IndirectSpecular()
-{
-}
-
 Error IndirectSpecular::init()
 {
 	const Error err = initInternal();
@@ -34,7 +30,7 @@ Error IndirectSpecular::init()
 
 Error IndirectSpecular::initInternal()
 {
-	const UVec2 size = m_r->getInternalResolution() / 2;
+	const UVec2 size = getRenderer().getInternalResolution() / 2;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 
 	ANKI_R_LOGV("Initializing indirect specular. Resolution %ux%u", size.x(), size.y());
@@ -47,10 +43,10 @@ Error IndirectSpecular::initInternal()
 	usage |= (preferCompute) ? TextureUsageBit::kImageComputeWrite : TextureUsageBit::kFramebufferWrite;
 
 	TextureInitInfo texInit =
-		m_r->create2DRenderTargetInitInfo(size.x(), size.y(), m_r->getHdrFormat(), usage, "SSR #1");
-	m_rts[0] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+		getRenderer().create2DRenderTargetInitInfo(size.x(), size.y(), getRenderer().getHdrFormat(), usage, "SSR #1");
+	m_rts[0] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 	texInit.setName("SSR #2");
-	m_rts[1] = m_r->createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
+	m_rts[1] = getRenderer().createAndClearRenderTarget(texInit, TextureUsageBit::kAllSampled);
 
 	m_fbDescr.m_colorAttachmentCount = 1;
 	m_fbDescr.bake();
@@ -80,7 +76,7 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 	const Bool fbDescrHasVrs = m_fbDescr.m_shadingRateAttachmentTexelWidth > 0;
 
 	// Create/import RTs
-	const U32 readRtIdx = m_r->getFrameCount() & 1;
+	const U32 readRtIdx = getRenderer().getFrameCount() & 1;
 	const U32 writeRtIdx = !readRtIdx;
 	if(m_rtsImportedOnce) [[likely]]
 	{
@@ -101,8 +97,8 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 
 		if(enableVrs)
 		{
-			m_fbDescr.m_shadingRateAttachmentTexelWidth = m_r->getVrsSriGeneration().getSriTexelDimension();
-			m_fbDescr.m_shadingRateAttachmentTexelHeight = m_r->getVrsSriGeneration().getSriTexelDimension();
+			m_fbDescr.m_shadingRateAttachmentTexelWidth = getRenderer().getVrsSriGeneration().getSriTexelDimension();
+			m_fbDescr.m_shadingRateAttachmentTexelHeight = getRenderer().getVrsSriGeneration().getSriTexelDimension();
 		}
 		else
 		{
@@ -130,7 +126,7 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 		{
 			GraphicsRenderPassDescription& pass = rgraph.newGraphicsRenderPass("SSR");
 			pass.setFramebufferInfo(m_fbDescr, {m_runCtx.m_rts[kWrite]}, {},
-									(enableVrs) ? m_r->getVrsSriGeneration().getDownscaledSriRt()
+									(enableVrs) ? getRenderer().getVrsSriGeneration().getDownscaledSriRt()
 												: RenderTargetHandle());
 
 			ppass = &pass;
@@ -139,28 +135,29 @@ void IndirectSpecular::populateRenderGraph(RenderingContext& ctx)
 
 			if(enableVrs)
 			{
-				ppass->newTextureDependency(m_r->getVrsSriGeneration().getDownscaledSriRt(),
+				ppass->newTextureDependency(getRenderer().getVrsSriGeneration().getDownscaledSriRt(),
 											TextureUsageBit::kFramebufferShadingRate);
 			}
 		}
 
 		ppass->newTextureDependency(m_runCtx.m_rts[kWrite], writeUsage);
 		ppass->newTextureDependency(m_runCtx.m_rts[kRead], readUsage);
-		ppass->newTextureDependency(m_r->getGBuffer().getColorRt(1), readUsage);
-		ppass->newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
+		ppass->newTextureDependency(getRenderer().getGBuffer().getColorRt(1), readUsage);
+		ppass->newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
 
 		TextureSubresourceInfo hizSubresource;
 		hizSubresource.m_mipmapCount =
-			min(ConfigSet::getSingleton().getRSsrDepthLod() + 1, m_r->getDepthDownscale().getMipmapCount());
-		ppass->newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
+			min(ConfigSet::getSingleton().getRSsrDepthLod() + 1, getRenderer().getDepthDownscale().getMipmapCount());
+		ppass->newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), readUsage, hizSubresource);
 
-		if(m_r->getProbeReflections().getHasCurrentlyRefreshedReflectionRt())
+		if(getRenderer().getProbeReflections().getHasCurrentlyRefreshedReflectionRt())
 		{
-			ppass->newTextureDependency(m_r->getProbeReflections().getCurrentlyRefreshedReflectionRt(), readUsage);
+			ppass->newTextureDependency(getRenderer().getProbeReflections().getCurrentlyRefreshedReflectionRt(),
+										readUsage);
 		}
 
-		ppass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
-		ppass->newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), readUsage);
+		ppass->newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
+		ppass->newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(), readUsage);
 
 		ppass->setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) {
 			run(ctx, rgraphCtx);
@@ -174,16 +171,17 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	cmdb->bindShaderProgram(m_grProg);
 
 	const U32 depthLod =
-		min(ConfigSet::getSingleton().getRSsrDepthLod(), m_r->getDepthDownscale().getMipmapCount() - 1);
+		min(ConfigSet::getSingleton().getRSsrDepthLod(), getRenderer().getDepthDownscale().getMipmapCount() - 1);
 
 	// Bind uniforms
 	SsrUniforms* unis = allocateAndBindUniforms<SsrUniforms*>(sizeof(SsrUniforms), cmdb, 0, 0);
-	unis->m_depthBufferSize = m_r->getInternalResolution() >> (depthLod + 1);
-	unis->m_framebufferSize = UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()) / 2;
-	unis->m_frameCount = m_r->getFrameCount() & kMaxU32;
-	unis->m_depthMipCount = m_r->getDepthDownscale().getMipmapCount();
+	unis->m_depthBufferSize = getRenderer().getInternalResolution() >> (depthLod + 1);
+	unis->m_framebufferSize =
+		UVec2(getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y()) / 2;
+	unis->m_frameCount = getRenderer().getFrameCount() & kMaxU32;
+	unis->m_depthMipCount = getRenderer().getDepthDownscale().getMipmapCount();
 	unis->m_maxSteps = ConfigSet::getSingleton().getRSsrMaxSteps();
-	unis->m_lightBufferMipCount = m_r->getDownscaleBlur().getMipmapCount();
+	unis->m_lightBufferMipCount = getRenderer().getDownscaleBlur().getMipmapCount();
 	unis->m_firstStepPixels = ConfigSet::getSingleton().getRSsrFirstStepPixels();
 	unis->m_prevViewProjMatMulInvViewProjMat =
 		ctx.m_prevMatrices.m_viewProjection * ctx.m_matrices.m_viewProjectionJitter.getInverse();
@@ -193,27 +191,28 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	unis->m_roughnessCutoff = ConfigSet::getSingleton().getRSsrRoughnessCutoff();
 
 	// Bind all
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
-	rgraphCtx.bindColorTexture(0, 2, m_r->getGBuffer().getColorRt(1));
-	rgraphCtx.bindColorTexture(0, 3, m_r->getGBuffer().getColorRt(2));
+	rgraphCtx.bindColorTexture(0, 2, getRenderer().getGBuffer().getColorRt(1));
+	rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(2));
 
 	TextureSubresourceInfo hizSubresource;
 	hizSubresource.m_mipmapCount = depthLod + 1;
-	rgraphCtx.bindTexture(0, 4, m_r->getDepthDownscale().getHiZRt(), hizSubresource);
+	rgraphCtx.bindTexture(0, 4, getRenderer().getDepthDownscale().getHiZRt(), hizSubresource);
 
-	rgraphCtx.bindColorTexture(0, 5, m_r->getDownscaleBlur().getRt());
+	rgraphCtx.bindColorTexture(0, 5, getRenderer().getDownscaleBlur().getRt());
 
 	rgraphCtx.bindColorTexture(0, 6, m_runCtx.m_rts[kRead]);
-	rgraphCtx.bindColorTexture(0, 7, m_r->getMotionVectors().getMotionVectorsRt());
-	rgraphCtx.bindColorTexture(0, 8, m_r->getMotionVectors().getHistoryLengthRt());
+	rgraphCtx.bindColorTexture(0, 7, getRenderer().getMotionVectors().getMotionVectorsRt());
+	rgraphCtx.bindColorTexture(0, 8, getRenderer().getMotionVectors().getHistoryLengthRt());
 
-	cmdb->bindSampler(0, 9, m_r->getSamplers().m_trilinearRepeat);
+	cmdb->bindSampler(0, 9, getRenderer().getSamplers().m_trilinearRepeat);
 	cmdb->bindTexture(0, 10, m_noiseImage->getTextureView());
 
-	bindUniforms(cmdb, 0, 11, m_r->getClusterBinning().getClusteredUniformsRebarToken());
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 12, ClusteredObjectType::kReflectionProbe);
-	bindStorage(cmdb, 0, 13, m_r->getClusterBinning().getClustersRebarToken());
+	bindUniforms(cmdb, 0, 11, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 12,
+																			 ClusteredObjectType::kReflectionProbe);
+	bindStorage(cmdb, 0, 13, getRenderer().getClusterBinning().getClustersRebarToken());
 
 	cmdb->bindAllBindless(1);
 
@@ -221,11 +220,13 @@ void IndirectSpecular::run(const RenderingContext& ctx, RenderPassWorkContext& r
 	{
 		rgraphCtx.bindImage(0, 14, m_runCtx.m_rts[kWrite], TextureSubresourceInfo());
 
-		dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
+		dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2,
+						  getRenderer().getInternalResolution().y() / 2);
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
+		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x() / 2,
+						  getRenderer().getInternalResolution().y() / 2);
 
 		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}

AnKi/Renderer/IndirectSpecular.h

@@ -16,14 +16,11 @@ namespace anki {
 class IndirectSpecular : public RendererObject
 {
 public:
-	IndirectSpecular(Renderer* r)
-		: RendererObject(r)
+	IndirectSpecular()
 	{
 		registerDebugRenderTarget("SSR");
 	}
 
-	~IndirectSpecular();
-
 	Error init();
 
 	/// Populate the rendergraph.

AnKi/Renderer/LensFlare.cpp

@@ -12,10 +12,6 @@
 
 namespace anki {
 
-LensFlare::~LensFlare()
-{
-}
-
 Error LensFlare::init()
 {
 	const Error err = initInternal();
@@ -69,8 +65,8 @@ Error LensFlare::initOcclusion()
 															m_updateIndirectBuffProg));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_updateIndirectBuffProg);
-	variantInitInfo.addConstant(
-		"kInDepthMapSize", UVec2(m_r->getInternalResolution().x() / 2 / 2, m_r->getInternalResolution().y() / 2 / 2));
+	variantInitInfo.addConstant("kInDepthMapSize", UVec2(getRenderer().getInternalResolution().x() / 2 / 2,
+														 getRenderer().getInternalResolution().y() / 2 / 2));
 	const ShaderProgramResourceVariant* variant;
 	m_updateIndirectBuffProg->getOrCreateVariant(variantInitInfo, variant);
 	m_updateIndirectBuffGrProg = variant->getProgram();
@@ -98,8 +94,8 @@ void LensFlare::updateIndirectInfo(const RenderingContext& ctx, RenderPassWorkCo
 
 	rgraphCtx.bindStorageBuffer(0, 1, m_runCtx.m_indirectBuffHandle);
 	// Bind neareset because you don't need high quality
-	cmdb->bindSampler(0, 2, m_r->getSamplers().m_nearestNearestClamp);
-	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), kHiZQuarterSurface);
+	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp);
+	rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getHiZRt(), kHiZQuarterSurface);
 	cmdb->dispatchCompute(count, 1, 1);
 }
 
@@ -124,7 +120,7 @@ void LensFlare::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newBufferDependency(m_runCtx.m_indirectBuffHandle, BufferUsageBit::kStorageComputeWrite);
-		rpass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
+		rpass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledCompute,
 								   kHiZQuarterSurface);
 	}
 }
@@ -169,7 +165,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 		Vec2 posNdc = posClip.xy() / posClip.w();
 
 		// First flare
-		sprites[c].m_posScale = Vec4(posNdc, flareEl.m_firstFlareSize * Vec2(1.0f, m_r->getAspectRatio()));
+		sprites[c].m_posScale = Vec4(posNdc, flareEl.m_firstFlareSize * Vec2(1.0f, getRenderer().getAspectRatio()));
 		sprites[c].m_depthPad3 = Vec4(0.0f);
 		const F32 alpha = flareEl.m_colorMultiplier.w() * (1.0f - pow(absolute(posNdc.x()), 6.0f))
 						  * (1.0f - pow(absolute(posNdc.y()), 6.0f)); // Fade the flare on the edges
@@ -178,7 +174,7 @@ void LensFlare::runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmd
 
 		// Render
 		ANKI_ASSERT(flareEl.m_textureView);
-		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearRepeat);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearRepeat);
 		cmdb->bindTexture(0, 2, TextureViewPtr(const_cast<TextureView*>(flareEl.m_textureView)));
 
 		cmdb->drawArraysIndirect(PrimitiveTopology::kTriangleStrip, 1, i * sizeof(DrawIndirectInfo), m_indirectBuff);

AnKi/Renderer/LensFlare.h

@@ -18,13 +18,6 @@ namespace anki {
 class LensFlare : public RendererObject
 {
 public:
-	LensFlare(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~LensFlare();
-
 	Error init();
 
 	void runDrawFlares(const RenderingContext& ctx, CommandBufferPtr& cmdb);

AnKi/Renderer/LightShading.cpp

@@ -23,16 +23,6 @@
 
 namespace anki {
 
-LightShading::LightShading(Renderer* r)
-	: RendererObject(r)
-{
-	registerDebugRenderTarget("LightShading");
-}
-
-LightShading::~LightShading()
-{
-}
-
 Error LightShading::init()
 {
 	ANKI_R_LOGV("Initializing light shading");
@@ -69,9 +59,9 @@ Error LightShading::initLightShading()
 		ResourceManager::getSingleton().loadResource("ShaderBinaries/LightShading.ankiprogbin", m_lightShading.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_lightShading.m_prog);
-	variantInitInfo.addConstant("kTileCount", m_r->getTileCounts());
-	variantInitInfo.addConstant("kZSplitCount", m_r->getZSplitCount());
-	variantInitInfo.addConstant("kTileSize", m_r->getTileSize());
+	variantInitInfo.addConstant("kTileCount", getRenderer().getTileCounts());
+	variantInitInfo.addConstant("kZSplitCount", getRenderer().getZSplitCount());
+	variantInitInfo.addConstant("kTileSize", getRenderer().getTileSize());
 	const ShaderProgramResourceVariant* variant;
 
 	variantInitInfo.addMutation("USE_SHADOW_LAYERS", 0);
@@ -83,8 +73,9 @@ Error LightShading::initLightShading()
 	m_lightShading.m_grProg[1] = variant->getProgram();
 
 	// Create RT descr
-	m_lightShading.m_rtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), m_r->getHdrFormat(), "Light Shading");
+	m_lightShading.m_rtDescr = getRenderer().create2DRenderTargetDescription(
+		getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
+		getRenderer().getHdrFormat(), "Light Shading");
 	m_lightShading.m_rtDescr.bake();
 
 	// Create FB descr
@@ -95,8 +86,10 @@ Error LightShading::initLightShading()
 
 	if(GrManager::getSingleton().getDeviceCapabilities().m_vrs && ConfigSet::getSingleton().getRVrs())
 	{
-		m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelWidth = m_r->getVrsSriGeneration().getSriTexelDimension();
-		m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelHeight = m_r->getVrsSriGeneration().getSriTexelDimension();
+		m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelWidth =
+			getRenderer().getVrsSriGeneration().getSriTexelDimension();
+		m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelHeight =
+			getRenderer().getVrsSriGeneration().getSriTexelDimension();
 	}
 
 	m_lightShading.m_fbDescr.bake();
@@ -135,8 +128,8 @@ Error LightShading::initApplyFog()
 															m_applyFog.m_prog));
 
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_applyFog.m_prog);
-	variantInitInfo.addConstant("kZSplitCount", m_r->getZSplitCount());
-	variantInitInfo.addConstant("kFinalZSplit", m_r->getVolumetricFog().getFinalClusterInZ());
+	variantInitInfo.addConstant("kZSplitCount", getRenderer().getZSplitCount());
+	variantInitInfo.addConstant("kFinalZSplit", getRenderer().getVolumetricFog().getFinalClusterInZ());
 
 	const ShaderProgramResourceVariant* variant;
 	m_applyFog.m_prog->getOrCreateVariant(variantInitInfo, variant);
@@ -159,7 +152,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
 	const Bool enableVrs =
 		GrManager::getSingleton().getDeviceCapabilities().m_vrs && ConfigSet::getSingleton().getRVrs();
@@ -172,33 +165,35 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 	// Do light shading first
 	if(rgraphCtx.m_currentSecondLevelCommandBufferIndex == 0)
 	{
-		cmdb->bindShaderProgram(m_lightShading.m_grProg[m_r->getRtShadowsEnabled()]);
+		cmdb->bindShaderProgram(m_lightShading.m_grProg[getRenderer().getRtShadowsEnabled()]);
 		cmdb->setDepthWrite(false);
 
 		// Bind all
-		bindUniforms(cmdb, 0, 0, m_r->getClusterBinning().getClusteredUniformsRebarToken());
-
-		m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1, ClusteredObjectType::kPointLight);
-		m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 2, ClusteredObjectType::kSpotLight);
-		rgraphCtx.bindColorTexture(0, 3, m_r->getShadowMapping().getShadowmapRt());
-
-		bindStorage(cmdb, 0, 4, m_r->getClusterBinning().getClustersRebarToken());
-
-		cmdb->bindSampler(0, 5, m_r->getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 6, m_r->getSamplers().m_trilinearClamp);
-		rgraphCtx.bindColorTexture(0, 7, m_r->getGBuffer().getColorRt(0));
-		rgraphCtx.bindColorTexture(0, 8, m_r->getGBuffer().getColorRt(1));
-		rgraphCtx.bindColorTexture(0, 9, m_r->getGBuffer().getColorRt(2));
-		rgraphCtx.bindTexture(0, 10, m_r->getGBuffer().getDepthRt(),
+		bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+
+		getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1,
+																				 ClusteredObjectType::kPointLight);
+		getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 2,
+																				 ClusteredObjectType::kSpotLight);
+		rgraphCtx.bindColorTexture(0, 3, getRenderer().getShadowMapping().getShadowmapRt());
+
+		bindStorage(cmdb, 0, 4, getRenderer().getClusterBinning().getClustersRebarToken());
+
+		cmdb->bindSampler(0, 5, getRenderer().getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClamp);
+		rgraphCtx.bindColorTexture(0, 7, getRenderer().getGBuffer().getColorRt(0));
+		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(1));
+		rgraphCtx.bindColorTexture(0, 9, getRenderer().getGBuffer().getColorRt(2));
+		rgraphCtx.bindTexture(0, 10, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-		if(m_r->getRtShadowsEnabled())
+		if(getRenderer().getRtShadowsEnabled())
 		{
-			rgraphCtx.bindColorTexture(0, 11, m_r->getRtShadows().getRt());
+			rgraphCtx.bindColorTexture(0, 11, getRenderer().getRtShadows().getRt());
 		}
 		else
 		{
-			rgraphCtx.bindColorTexture(0, 12, m_r->getShadowmapsResolve().getRt());
+			rgraphCtx.bindColorTexture(0, 12, getRenderer().getShadowmapsResolve().getRt());
 		}
 
 		// Draw
@@ -211,19 +206,19 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb->setDepthWrite(false);
 		cmdb->bindShaderProgram(m_applyIndirect.m_grProg);
 
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
-		rgraphCtx.bindColorTexture(0, 2, m_r->getIndirectDiffuse().getRt());
-		rgraphCtx.bindColorTexture(0, 3, m_r->getIndirectSpecular().getRt());
-		rgraphCtx.bindColorTexture(0, 4, m_r->getDepthDownscale().getHiZRt());
-		rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(),
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+		rgraphCtx.bindColorTexture(0, 2, getRenderer().getIndirectDiffuse().getRt());
+		rgraphCtx.bindColorTexture(0, 3, getRenderer().getIndirectSpecular().getRt());
+		rgraphCtx.bindColorTexture(0, 4, getRenderer().getDepthDownscale().getHiZRt());
+		rgraphCtx.bindTexture(0, 5, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-		rgraphCtx.bindColorTexture(0, 6, m_r->getGBuffer().getColorRt(0));
-		rgraphCtx.bindColorTexture(0, 7, m_r->getGBuffer().getColorRt(1));
-		rgraphCtx.bindColorTexture(0, 8, m_r->getGBuffer().getColorRt(2));
-		cmdb->bindTexture(0, 9, m_r->getProbeReflections().getIntegrationLut());
+		rgraphCtx.bindColorTexture(0, 6, getRenderer().getGBuffer().getColorRt(0));
+		rgraphCtx.bindColorTexture(0, 7, getRenderer().getGBuffer().getColorRt(1));
+		rgraphCtx.bindColorTexture(0, 8, getRenderer().getGBuffer().getColorRt(2));
+		cmdb->bindTexture(0, 9, getRenderer().getProbeReflections().getIntegrationLut());
 
-		bindUniforms(cmdb, 0, 10, m_r->getClusterBinning().getClusteredUniformsRebarToken());
+		bindUniforms(cmdb, 0, 10, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
 		const Vec4 pc(ctx.m_renderQueue->m_cameraNear, ctx.m_renderQueue->m_cameraFar, 0.0f, 0.0f);
 		cmdb->setPushConstants(&pc, sizeof(pc));
@@ -267,7 +262,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 
 			cmdb->setPushConstants(&pc, sizeof(pc));
 
-			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearRepeatAnisoResolutionScalingBias);
+			cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeatAnisoResolutionScalingBias);
 			cmdb->bindTexture(0, 1,
 							  TextureViewPtr(const_cast<TextureView*>(ctx.m_renderQueue->m_skybox.m_skyboxTexture)));
 		}
@@ -284,12 +279,12 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb->bindShaderProgram(m_applyFog.m_grProg);
 
 		// Bind all
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-		cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
-		rgraphCtx.bindTexture(0, 2, m_r->getGBuffer().getDepthRt(),
+		rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-		rgraphCtx.bindColorTexture(0, 3, m_r->getVolumetricFog().getRt());
+		rgraphCtx.bindColorTexture(0, 3, getRenderer().getVolumetricFog().getRt());
 
 		class PushConsts
 		{
@@ -318,7 +313,7 @@ void LightShading::run(const RenderingContext& ctx, RenderPassWorkContext& rgrap
 		cmdb->setVrsRate(VrsRate::k2x2);
 	}
 
-	m_r->getForwardShading().run(ctx, rgraphCtx);
+	getRenderer().getForwardShading().run(ctx, rgraphCtx);
 
 	if(enableVrs)
 	{
@@ -342,9 +337,9 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 		if(enableVrs)
 		{
 			m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelWidth =
-				m_r->getVrsSriGeneration().getSriTexelDimension();
+				getRenderer().getVrsSriGeneration().getSriTexelDimension();
 			m_lightShading.m_fbDescr.m_shadingRateAttachmentTexelHeight =
-				m_r->getVrsSriGeneration().getSriTexelDimension();
+				getRenderer().getVrsSriGeneration().getSriTexelDimension();
 		}
 		else
 		{
@@ -361,7 +356,7 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 	RenderTargetHandle sriRt;
 	if(enableVrs)
 	{
-		sriRt = m_r->getVrsSriGeneration().getSriRt();
+		sriRt = getRenderer().getVrsSriGeneration().getSriRt();
 	}
 
 	// Create pass
@@ -371,7 +366,7 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 				 [this, &ctx](RenderPassWorkContext& rgraphCtx) {
 					 run(ctx, rgraphCtx);
 				 });
-	pass.setFramebufferInfo(m_lightShading.m_fbDescr, {m_runCtx.m_rt}, m_r->getGBuffer().getDepthRt(), sriRt);
+	pass.setFramebufferInfo(m_lightShading.m_fbDescr, {m_runCtx.m_rt}, getRenderer().getGBuffer().getDepthRt(), sriRt);
 
 	const TextureUsageBit readUsage = TextureUsageBit::kSampledFragment;
 
@@ -383,34 +378,34 @@ void LightShading::populateRenderGraph(RenderingContext& ctx)
 
 	// Light shading
 	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
-	pass.newTextureDependency(m_r->getGBuffer().getColorRt(0), readUsage);
-	pass.newTextureDependency(m_r->getGBuffer().getColorRt(1), readUsage);
-	pass.newTextureDependency(m_r->getGBuffer().getColorRt(2), readUsage);
-	pass.newTextureDependency(m_r->getGBuffer().getDepthRt(),
+	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(0), readUsage);
+	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(1), readUsage);
+	pass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), readUsage);
+	pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(),
 							  TextureUsageBit::kSampledFragment | TextureUsageBit::kFramebufferRead,
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-	pass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), readUsage);
-	if(m_r->getRtShadowsEnabled())
+	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), readUsage);
+	if(getRenderer().getRtShadowsEnabled())
 	{
-		pass.newTextureDependency(m_r->getRtShadows().getRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getRtShadows().getRt(), readUsage);
 	}
 	else
 	{
-		pass.newTextureDependency(m_r->getShadowmapsResolve().getRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getShadowmapsResolve().getRt(), readUsage);
 	}
-	pass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 							 BufferUsageBit::kStorageFragmentRead);
 
 	// Apply indirect
-	pass.newTextureDependency(m_r->getIndirectDiffuse().getRt(), readUsage);
-	pass.newTextureDependency(m_r->getDepthDownscale().getHiZRt(), readUsage);
-	pass.newTextureDependency(m_r->getIndirectSpecular().getRt(), readUsage);
+	pass.newTextureDependency(getRenderer().getIndirectDiffuse().getRt(), readUsage);
+	pass.newTextureDependency(getRenderer().getDepthDownscale().getHiZRt(), readUsage);
+	pass.newTextureDependency(getRenderer().getIndirectSpecular().getRt(), readUsage);
 
 	// Fog
-	pass.newTextureDependency(m_r->getVolumetricFog().getRt(), readUsage);
+	pass.newTextureDependency(getRenderer().getVolumetricFog().getRt(), readUsage);
 
 	// For forward shading
-	m_r->getForwardShading().setDependencies(ctx, pass);
+	getRenderer().getForwardShading().setDependencies(ctx, pass);
 }
 
 void LightShading::getDebugRenderTarget([[maybe_unused]] CString rtName,

AnKi/Renderer/LightShading.h

@@ -17,9 +17,10 @@ namespace anki {
 class LightShading : public RendererObject
 {
 public:
-	LightShading(Renderer* r);
-
-	~LightShading();
+	LightShading()
+	{
+		registerDebugRenderTarget("LightShading");
+	}
 
 	Error init();
 

AnKi/Renderer/MainRenderer.cpp

@@ -26,11 +26,16 @@ MainRenderer::MainRenderer()
 MainRenderer::~MainRenderer()
 {
 	ANKI_R_LOGI("Destroying main renderer");
+
+	deleteInstance(RendererMemoryPool::getSingleton(), m_r);
+
+	RendererMemoryPool::freeSingleton();
 }
 
 Error MainRenderer::init(const MainRendererInitInfo& inf)
 {
-	m_pool.init(inf.m_allocCallback, inf.m_allocCallbackUserData, "MainRenderer");
+	RendererMemoryPool::allocateSingleton(inf.m_allocCallback, inf.m_allocCallbackUserData);
+
 	m_framePool.init(inf.m_allocCallback, inf.m_allocCallbackUserData, 10_MB, 1.0f);
 
 	// Init renderer and manipulate the width/height
@@ -40,8 +45,8 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 	ANKI_R_LOGI("Initializing main renderer. Swapchain resolution %ux%u", m_swapchainResolution.x(),
 				m_swapchainResolution.y());
 
-	m_r.reset(newInstance<Renderer>(m_pool));
-	ANKI_CHECK(m_r->init(inf, &m_pool, m_swapchainResolution));
+	m_r = newInstance<Renderer>(RendererMemoryPool::getSingleton());
+	ANKI_CHECK(m_r->init(m_swapchainResolution));
 
 	// Init other
 	if(!m_rDrawToDefaultFb)

AnKi/Renderer/MainRenderer.h

@@ -23,7 +23,7 @@ public:
 	Second m_renderingGpuSubmitTimestamp ANKI_DEBUG_CODE(= -1.0);
 };
 
-class MainRendererInitInfo : public RendererExternalSubsystems
+class MainRendererInitInfo
 {
 public:
 	UVec2 m_swapchainSize = UVec2(0u);
@@ -33,13 +33,12 @@ public:
 };
 
 /// Main onscreen renderer
-class MainRenderer
+class MainRenderer : public MakeSingleton<MainRenderer>
 {
-public:
-	MainRenderer();
-
-	~MainRenderer();
+	template<typename>
+	friend class MakeSingleton;
 
+public:
 	Error init(const MainRendererInitInfo& inf);
 
 	Error render(RenderQueue& rqueue, TexturePtr presentTex);
@@ -69,10 +68,9 @@ public:
 	}
 
 private:
-	HeapMemoryPool m_pool;
 	StackMemoryPool m_framePool;
 
-	UniquePtr<Renderer> m_r;
+	Renderer* m_r = nullptr;
 	Bool m_rDrawToDefaultFb = false;
 
 	ShaderProgramResourcePtr m_blitProg;
@@ -93,6 +91,10 @@ private:
 		const RenderingContext* m_ctx = nullptr;
 		Atomic<U32> m_secondaryTaskId = {0};
 	} m_runCtx;
+
+	MainRenderer();
+
+	~MainRenderer();
 };
 /// @}
 

AnKi/Renderer/MotionVectors.cpp

@@ -11,10 +11,6 @@
 
 namespace anki {
 
-MotionVectors::~MotionVectors()
-{
-}
-
 Error MotionVectors::init()
 {
 	const Error err = initInternal();
@@ -35,15 +31,16 @@ Error MotionVectors::initInternal()
 																: "ShaderBinaries/MotionVectorsRaster.ankiprogbin",
 															m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
-	variantInitInfo.addConstant("kFramebufferSize",
-								UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));
+	variantInitInfo.addConstant("kFramebufferSize", UVec2(getRenderer().getInternalResolution().x(),
+														  getRenderer().getInternalResolution().y()));
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
 	m_grProg = variant->getProgram();
 
 	// RTs
-	m_motionVectorsRtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(), Format::kR16G16_Sfloat, "MotionVectors");
+	m_motionVectorsRtDescr = getRenderer().create2DRenderTargetDescription(getRenderer().getInternalResolution().x(),
+																		   getRenderer().getInternalResolution().y(),
+																		   Format::kR16G16_Sfloat, "MotionVectors");
 	m_motionVectorsRtDescr.bake();
 
 	TextureUsageBit historyLengthUsage = TextureUsageBit::kAllSampled;
@@ -56,12 +53,14 @@ Error MotionVectors::initInternal()
 		historyLengthUsage |= TextureUsageBit::kFramebufferWrite;
 	}
 
-	TextureInitInfo historyLengthTexInit =
-		m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-										  Format::kR8_Unorm, historyLengthUsage, "MotionVectorsHistoryLen#1");
-	m_historyLengthTextures[0] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
+	TextureInitInfo historyLengthTexInit = getRenderer().create2DRenderTargetInitInfo(
+		getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(), Format::kR8_Unorm,
+		historyLengthUsage, "MotionVectorsHistoryLen#1");
+	m_historyLengthTextures[0] =
+		getRenderer().createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
 	historyLengthTexInit.setName("MotionVectorsHistoryLen#2");
-	m_historyLengthTextures[1] = m_r->createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
+	m_historyLengthTextures[1] =
+		getRenderer().createAndClearRenderTarget(historyLengthTexInit, TextureUsageBit::kAllSampled);
 
 	m_fbDescr.m_colorAttachmentCount = 2;
 	m_fbDescr.bake();
@@ -75,7 +74,7 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 
 	m_runCtx.m_motionVectorsRtHandle = rgraph.newRenderTarget(m_motionVectorsRtDescr);
 
-	const U32 writeHistoryLenTexIdx = m_r->getFrameCount() & 1;
+	const U32 writeHistoryLenTexIdx = getRenderer().getFrameCount() & 1;
 	const U32 readHistoryLenTexIdx = !writeHistoryLenTexIdx;
 
 	if(m_historyLengthTexturesImportedOnce) [[likely]]
@@ -122,9 +121,9 @@ void MotionVectors::populateRenderGraph(RenderingContext& ctx)
 	ppass->newTextureDependency(m_runCtx.m_motionVectorsRtHandle, writeUsage);
 	ppass->newTextureDependency(m_runCtx.m_historyLengthWriteRtHandle, writeUsage);
 	ppass->newTextureDependency(m_runCtx.m_historyLengthReadRtHandle, readUsage);
-	ppass->newTextureDependency(m_r->getGBuffer().getColorRt(3), readUsage);
-	ppass->newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage);
-	ppass->newTextureDependency(m_r->getGBuffer().getPreviousFrameDepthRt(), readUsage);
+	ppass->newTextureDependency(getRenderer().getGBuffer().getColorRt(3), readUsage);
+	ppass->newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage);
+	ppass->newTextureDependency(getRenderer().getGBuffer().getPreviousFrameDepthRt(), readUsage);
 }
 
 void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
@@ -133,11 +132,12 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 
 	cmdb->bindShaderProgram(m_grProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
-	rgraphCtx.bindTexture(0, 1, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-	rgraphCtx.bindTexture(0, 2, m_r->getGBuffer().getPreviousFrameDepthRt(),
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+	rgraphCtx.bindTexture(0, 1, getRenderer().getGBuffer().getDepthRt(),
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	rgraphCtx.bindTexture(0, 2, getRenderer().getGBuffer().getPreviousFrameDepthRt(),
 						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-	rgraphCtx.bindColorTexture(0, 3, m_r->getGBuffer().getColorRt(3));
+	rgraphCtx.bindColorTexture(0, 3, getRenderer().getGBuffer().getColorRt(3));
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_historyLengthReadRtHandle);
 
 	class Uniforms
@@ -161,11 +161,12 @@ void MotionVectors::run(const RenderingContext& ctx, RenderPassWorkContext& rgra
 
 	if(ConfigSet::getSingleton().getRPreferCompute())
 	{
-		dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+		dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x(),
+						  getRenderer().getInternalResolution().y());
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+		cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 
 		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}

AnKi/Renderer/MotionVectors.h

@@ -17,15 +17,12 @@ namespace anki {
 class MotionVectors : public RendererObject
 {
 public:
-	MotionVectors(Renderer* renderer)
-		: RendererObject(renderer)
+	MotionVectors()
 	{
 		registerDebugRenderTarget("MotionVectors");
 		registerDebugRenderTarget("MotionVectorsHistoryLength");
 	}
 
-	~MotionVectors();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/PackVisibleClusteredObjects.cpp

@@ -12,15 +12,6 @@
 
 namespace anki {
 
-PackVisibleClusteredObjects::PackVisibleClusteredObjects(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-PackVisibleClusteredObjects::~PackVisibleClusteredObjects()
-{
-}
-
 Error PackVisibleClusteredObjects::init()
 {
 	ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/PackVisibleClusteredObjects.ankiprogbin",
@@ -148,7 +139,7 @@ void PackVisibleClusteredObjects::populateRenderGraph(RenderingContext& ctx)
 
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("PackClusterObjects");
 
-	pass.newBufferDependency(m_r->getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
+	pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(), BufferUsageBit::kStorageComputeRead);
 
 	m_allClustererObjectsHandle = rgraph.importBuffer(m_allClustererObjects, BufferUsageBit::kNone);
 	pass.newBufferDependency(m_allClustererObjectsHandle, BufferUsageBit::kStorageComputeWrite);

AnKi/Renderer/PackVisibleClusteredObjects.h

@@ -17,10 +17,6 @@ namespace anki {
 class PackVisibleClusteredObjects : public RendererObject
 {
 public:
-	PackVisibleClusteredObjects(Renderer* r);
-
-	~PackVisibleClusteredObjects();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/ProbeReflections.cpp

@@ -16,16 +16,6 @@
 
 namespace anki {
 
-ProbeReflections::ProbeReflections(Renderer* r)
-	: RendererObject(r)
-	, m_lightShading(r)
-{
-}
-
-ProbeReflections::~ProbeReflections()
-{
-}
-
 Error ProbeReflections::init()
 {
 	const Error err = initInternal();
@@ -66,7 +56,7 @@ Error ProbeReflections::initGBuffer()
 
 	// Create RT descriptions
 	{
-		RenderTargetDescription texinit = m_r->create2DRenderTargetDescription(
+		RenderTargetDescription texinit = getRenderer().create2DRenderTargetDescription(
 			m_gbuffer.m_tileSize * 6, m_gbuffer.m_tileSize, kGBufferColorRenderTargetFormats[0], "CubeRefl GBuffer");
 
 		// Create color RT descriptions
@@ -74,13 +64,12 @@ Error ProbeReflections::initGBuffer()
 		{
 			texinit.m_format = kGBufferColorRenderTargetFormats[i];
 			m_gbuffer.m_colorRtDescrs[i] = texinit;
-			m_gbuffer.m_colorRtDescrs[i].setName(
-				StringRaii(&getMemoryPool()).sprintf("CubeRefl GBuff Col #%u", i).toCString());
+			m_gbuffer.m_colorRtDescrs[i].setName(RendererString().sprintf("CubeRefl GBuff Col #%u", i).toCString());
 			m_gbuffer.m_colorRtDescrs[i].bake();
 		}
 
 		// Create depth RT
-		texinit.m_format = m_r->getDepthNoStencilFormat();
+		texinit.m_format = getRenderer().getDepthNoStencilFormat();
 		texinit.setName("CubeRefl GBuff Depth");
 		m_gbuffer.m_depthRtDescr = texinit;
 		m_gbuffer.m_depthRtDescr.bake();
@@ -179,8 +168,8 @@ Error ProbeReflections::initShadowMapping()
 	ANKI_ASSERT(resolution > 8);
 
 	// RT descr
-	m_shadowMapping.m_rtDescr =
-		m_r->create2DRenderTargetDescription(resolution * 6, resolution, m_r->getDepthNoStencilFormat(), "CubeRefl SM");
+	m_shadowMapping.m_rtDescr = getRenderer().create2DRenderTargetDescription(
+		resolution * 6, resolution, getRenderer().getDepthNoStencilFormat(), "CubeRefl SM");
 	m_shadowMapping.m_rtDescr.bake();
 
 	// FB descr
@@ -228,10 +217,10 @@ void ProbeReflections::runGBuffer(RenderPassWorkContext& rgraphCtx)
 			args.m_cameraTransform = rqueue.m_cameraTransform;
 			args.m_viewProjectionMatrix = rqueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care about prev mats
-			args.m_sampler = m_r->getSamplers().m_trilinearRepeat;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeat;
 
-			m_r->getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart,
-											rqueue.m_renderables.getBegin() + localEnd, cmdb);
+			getRenderer().getSceneDrawer().drawRange(args, rqueue.m_renderables.getBegin() + localStart,
+													 rqueue.m_renderables.getBegin() + localEnd, cmdb);
 		}
 	}
 
@@ -307,7 +296,7 @@ void ProbeReflections::runIrradiance(RenderPassWorkContext& rgraphCtx)
 	cmdb->bindShaderProgram(m_irradiance.m_grProg);
 
 	// Bind stuff
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 
 	TextureSubresourceInfo subresource;
 	subresource.m_faceCount = 6;
@@ -328,7 +317,7 @@ void ProbeReflections::runIrradianceToRefl(RenderPassWorkContext& rgraphCtx)
 	cmdb->bindShaderProgram(m_irradianceToRefl.m_grProg);
 
 	// Bind resources
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[0], 0);
 	rgraphCtx.bindColorTexture(0, 1, m_ctx.m_gbufferColorRts[1], 1);
@@ -400,7 +389,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(m_ctx.m_gbufferDepthRt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 	}
 
@@ -447,7 +436,7 @@ void ProbeReflections::populateRenderGraph(RenderingContext& rctx)
 		TextureSubresourceInfo subresource(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(m_ctx.m_shadowMapRt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 	}
 	else
@@ -592,10 +581,10 @@ void ProbeReflections::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 			args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 			args.m_viewProjectionMatrix = cascadeRenderQueue.m_viewProjectionMatrix;
 			args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-			args.m_sampler = m_r->getSamplers().m_trilinearRepeatAniso;
+			args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
 
-			m_r->getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
-											cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);
+			getRenderer().getSceneDrawer().drawRange(args, cascadeRenderQueue.m_renderables.getBegin() + localStart,
+													 cascadeRenderQueue.m_renderables.getBegin() + localEnd, cmdb);
 		}
 	}
 }

AnKi/Renderer/ProbeReflections.h

@@ -20,10 +20,6 @@ class ProbeReflections : public RendererObject
 	friend class IrTask;
 
 public:
-	ProbeReflections(Renderer* r);
-
-	~ProbeReflections();
-
 	Error init();
 
 	/// Populate the rendergraph.
@@ -72,11 +68,6 @@ private:
 		U32 m_mipCount = 0;
 		Array<FramebufferDescription, 6> m_fbDescr;
 		TraditionalDeferredLightShading m_deferred;
-
-		LS(Renderer* r)
-			: m_deferred(r)
-		{
-		}
 	} m_lightShading; ///< Light shading.
 
 	class

AnKi/Renderer/Renderer.cpp

@@ -80,27 +80,17 @@ static Vec2 generateJitter(U32 frame)
 }
 
 Renderer::Renderer()
-	: m_sceneDrawer(this)
 {
 }
 
 Renderer::~Renderer()
 {
-	for(DebugRtInfo& info : m_debugRts)
-	{
-		info.m_rtName.destroy(getMemoryPool());
-	}
-	m_debugRts.destroy(getMemoryPool());
-	m_currentDebugRtName.destroy(getMemoryPool());
 }
 
-Error Renderer::init(const RendererExternalSubsystems& subsystems, HeapMemoryPool* pool, UVec2 swapchainSize)
+Error Renderer::init(UVec2 swapchainSize)
 {
 	ANKI_TRACE_SCOPED_EVENT(RInit);
 
-	m_subsystems = subsystems;
-	m_pool = pool;
-
 	const Error err = initInternal(swapchainSize);
 	if(err)
 	{
@@ -164,97 +154,99 @@ Error Renderer::initInternal(UVec2 swapchainResolution)
 	}
 
 	// Init the stages. Careful with the order!!!!!!!!!!
-	m_genericCompute.reset(newInstance<GenericCompute>(*m_pool, this));
+	m_genericCompute.reset(newInstance<GenericCompute>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_genericCompute->init());
 
-	m_volumetricLightingAccumulation.reset(newInstance<VolumetricLightingAccumulation>(*m_pool, this));
+	m_volumetricLightingAccumulation.reset(
+		newInstance<VolumetricLightingAccumulation>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_volumetricLightingAccumulation->init());
 
-	m_indirectDiffuseProbes.reset(newInstance<IndirectDiffuseProbes>(*m_pool, this));
+	m_indirectDiffuseProbes.reset(newInstance<IndirectDiffuseProbes>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_indirectDiffuseProbes->init());
 
-	m_probeReflections.reset(newInstance<ProbeReflections>(*m_pool, this));
+	m_probeReflections.reset(newInstance<ProbeReflections>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_probeReflections->init());
 
-	m_vrsSriGeneration.reset(newInstance<VrsSriGeneration>(*m_pool, this));
+	m_vrsSriGeneration.reset(newInstance<VrsSriGeneration>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_vrsSriGeneration->init());
 
-	m_scale.reset(newInstance<Scale>(*m_pool, this));
+	m_scale.reset(newInstance<Scale>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_scale->init());
 
-	m_gbuffer.reset(newInstance<GBuffer>(*m_pool, this));
+	m_gbuffer.reset(newInstance<GBuffer>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_gbuffer->init());
 
-	m_gbufferPost.reset(newInstance<GBufferPost>(*m_pool, this));
+	m_gbufferPost.reset(newInstance<GBufferPost>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_gbufferPost->init());
 
-	m_shadowMapping.reset(newInstance<ShadowMapping>(*m_pool, this));
+	m_shadowMapping.reset(newInstance<ShadowMapping>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_shadowMapping->init());
 
-	m_volumetricFog.reset(newInstance<VolumetricFog>(*m_pool, this));
+	m_volumetricFog.reset(newInstance<VolumetricFog>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_volumetricFog->init());
 
-	m_lightShading.reset(newInstance<LightShading>(*m_pool, this));
+	m_lightShading.reset(newInstance<LightShading>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_lightShading->init());
 
-	m_depthDownscale.reset(newInstance<DepthDownscale>(*m_pool, this));
+	m_depthDownscale.reset(newInstance<DepthDownscale>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_depthDownscale->init());
 
-	m_forwardShading.reset(newInstance<ForwardShading>(*m_pool, this));
+	m_forwardShading.reset(newInstance<ForwardShading>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_forwardShading->init());
 
-	m_lensFlare.reset(newInstance<LensFlare>(*m_pool, this));
+	m_lensFlare.reset(newInstance<LensFlare>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_lensFlare->init());
 
-	m_downscaleBlur.reset(newInstance<DownscaleBlur>(*m_pool, this));
+	m_downscaleBlur.reset(newInstance<DownscaleBlur>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_downscaleBlur->init());
 
-	m_indirectSpecular.reset(newInstance<IndirectSpecular>(*m_pool, this));
+	m_indirectSpecular.reset(newInstance<IndirectSpecular>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_indirectSpecular->init());
 
-	m_tonemapping.reset(newInstance<Tonemapping>(*m_pool, this));
+	m_tonemapping.reset(newInstance<Tonemapping>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_tonemapping->init());
 
-	m_temporalAA.reset(newInstance<TemporalAA>(*m_pool, this));
+	m_temporalAA.reset(newInstance<TemporalAA>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_temporalAA->init());
 
-	m_bloom.reset(newInstance<Bloom>(*m_pool, this));
+	m_bloom.reset(newInstance<Bloom>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_bloom->init());
 
-	m_finalComposite.reset(newInstance<FinalComposite>(*m_pool, this));
+	m_finalComposite.reset(newInstance<FinalComposite>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_finalComposite->init());
 
-	m_dbg.reset(newInstance<Dbg>(*m_pool, this));
+	m_dbg.reset(newInstance<Dbg>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_dbg->init());
 
-	m_uiStage.reset(newInstance<UiStage>(*m_pool, this));
+	m_uiStage.reset(newInstance<UiStage>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_uiStage->init());
 
-	m_indirectDiffuse.reset(newInstance<IndirectDiffuse>(*m_pool, this));
+	m_indirectDiffuse.reset(newInstance<IndirectDiffuse>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_indirectDiffuse->init());
 
 	if(GrManager::getSingleton().getDeviceCapabilities().m_rayTracingEnabled
 	   && ConfigSet::getSingleton().getSceneRayTracedShadows())
 	{
-		m_accelerationStructureBuilder.reset(newInstance<AccelerationStructureBuilder>(*m_pool, this));
+		m_accelerationStructureBuilder.reset(
+			newInstance<AccelerationStructureBuilder>(RendererMemoryPool::getSingleton()));
 		ANKI_CHECK(m_accelerationStructureBuilder->init());
 
-		m_rtShadows.reset(newInstance<RtShadows>(*m_pool, this));
+		m_rtShadows.reset(newInstance<RtShadows>(RendererMemoryPool::getSingleton()));
 		ANKI_CHECK(m_rtShadows->init());
 	}
 	else
 	{
-		m_shadowmapsResolve.reset(newInstance<ShadowmapsResolve>(*m_pool, this));
+		m_shadowmapsResolve.reset(newInstance<ShadowmapsResolve>(RendererMemoryPool::getSingleton()));
 		ANKI_CHECK(m_shadowmapsResolve->init());
 	}
 
-	m_motionVectors.reset(newInstance<MotionVectors>(*m_pool, this));
+	m_motionVectors.reset(newInstance<MotionVectors>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_motionVectors->init());
 
-	m_clusterBinning.reset(newInstance<ClusterBinning>(*m_pool, this));
+	m_clusterBinning.reset(newInstance<ClusterBinning>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_clusterBinning->init());
 
-	m_packVisibleClustererObjects.reset(newInstance<PackVisibleClusteredObjects>(*m_pool, this));
+	m_packVisibleClustererObjects.reset(newInstance<PackVisibleClusteredObjects>(RendererMemoryPool::getSingleton()));
 	ANKI_CHECK(m_packVisibleClustererObjects->init());
 
 	// Init samplers
@@ -624,9 +616,9 @@ void Renderer::registerDebugRenderTarget(RendererObject* obj, CString rtName)
 	ANKI_ASSERT(obj);
 	DebugRtInfo inf;
 	inf.m_obj = obj;
-	inf.m_rtName.create(getMemoryPool(), rtName);
+	inf.m_rtName = rtName;
 
-	m_debugRts.emplaceBack(getMemoryPool(), std::move(inf));
+	m_debugRts.emplaceBack(std::move(inf));
 }
 
 Bool Renderer::getCurrentDebugRenderTarget(Array<RenderTargetHandle, kMaxDebugRenderTargets>& handles,
@@ -653,11 +645,11 @@ Bool Renderer::getCurrentDebugRenderTarget(Array<RenderTargetHandle, kMaxDebugRe
 
 void Renderer::setCurrentDebugRenderTarget(CString rtName)
 {
-	m_currentDebugRtName.destroy(getMemoryPool());
+	m_currentDebugRtName.destroy();
 
 	if(!rtName.isEmpty() && rtName.getLength() > 0)
 	{
-		m_currentDebugRtName.create(getMemoryPool(), rtName);
+		m_currentDebugRtName = rtName;
 	}
 }
 

AnKi/Renderer/Renderer.h

@@ -67,7 +67,7 @@ public:
 	}
 
 	/// Init the renderer.
-	Error init(const RendererExternalSubsystems& subsystems, HeapMemoryPool* pool, UVec2 swapchainSize);
+	Error init(UVec2 swapchainSize);
 
 	/// This function does all the rendering stages and produces a final result.
 	Error populateRenderGraph(RenderingContext& ctx);
@@ -126,16 +126,6 @@ public:
 		return m_samplers;
 	}
 
-	RendererExternalSubsystems& getExternalSubsystems()
-	{
-		return m_subsystems;
-	}
-
-	HeapMemoryPool& getMemoryPool() const
-	{
-		return *m_pool;
-	}
-
 	U32 getTileSize() const
 	{
 		return m_tileSize;
@@ -180,12 +170,9 @@ public:
 	/// @}
 
 private:
-	RendererExternalSubsystems m_subsystems;
-	mutable HeapMemoryPool* m_pool = nullptr;
-
 	/// @name Rendering stages
 	/// @{
-#define ANKI_RENDERER_OBJECT_DEF(a, b) UniquePtr<a> m_##b;
+#define ANKI_RENDERER_OBJECT_DEF(a, b) UniquePtr<a, SingletonMemoryPoolDeleter<RendererMemoryPool>> m_##b;
 #include <AnKi/Renderer/RendererObject.defs.h>
 #undef ANKI_RENDERER_OBJECT_DEF
 	/// @}
@@ -221,10 +208,10 @@ private:
 	{
 	public:
 		RendererObject* m_obj;
-		String m_rtName;
+		RendererString m_rtName;
 	};
-	DynamicArray<DebugRtInfo> m_debugRts;
-	String m_currentDebugRtName;
+	RendererDynamicArray<DebugRtInfo> m_debugRts;
+	RendererString m_currentDebugRtName;
 
 	class
 	{

AnKi/Renderer/RendererObject.cpp

@@ -5,24 +5,15 @@
 
 #include <AnKi/Renderer/RendererObject.h>
 #include <AnKi/Renderer/Renderer.h>
+#include <AnKi/Renderer/MainRenderer.h>
 #include <AnKi/Util/Enum.h>
 #include <AnKi/Util/ThreadHive.h>
 
 namespace anki {
 
-RendererExternalSubsystems& RendererObject::getExternalSubsystems()
+Renderer& RendererObject::getRenderer()
 {
-	return m_r->getExternalSubsystems();
-}
-
-const RendererExternalSubsystems& RendererObject::getExternalSubsystems() const
-{
-	return m_r->getExternalSubsystems();
-}
-
-HeapMemoryPool& RendererObject::getMemoryPool() const
-{
-	return m_r->getMemoryPool();
+	return MainRenderer::getSingleton().getOffscreenRenderer();
 }
 
 void* RendererObject::allocateRebarStagingMemory(PtrSize size, RebarGpuMemoryToken& token)
@@ -39,7 +30,8 @@ void RendererObject::bindUniforms(CommandBufferPtr& cmdb, U32 set, U32 binding,
 	}
 	else
 	{
-		cmdb->bindUniformBuffer(set, binding, m_r->getDummyBuffer(), 0, m_r->getDummyBuffer()->getSize());
+		cmdb->bindUniformBuffer(set, binding, getRenderer().getDummyBuffer(), 0,
+								getRenderer().getDummyBuffer()->getSize());
 	}
 }
 
@@ -52,7 +44,8 @@ void RendererObject::bindStorage(CommandBufferPtr& cmdb, U32 set, U32 binding, c
 	}
 	else
 	{
-		cmdb->bindStorageBuffer(set, binding, m_r->getDummyBuffer(), 0, m_r->getDummyBuffer()->getSize());
+		cmdb->bindStorageBuffer(set, binding, getRenderer().getDummyBuffer(), 0,
+								getRenderer().getDummyBuffer()->getSize());
 	}
 }
 
@@ -74,7 +67,7 @@ U32 RendererObject::computeNumberOfSecondLevelCommandBuffers(U32 drawcallCount)
 
 void RendererObject::registerDebugRenderTarget(CString rtName)
 {
-	m_r->registerDebugRenderTarget(this, rtName);
+	getRenderer().registerDebugRenderTarget(this, rtName);
 }
 
 } // end namespace anki

AnKi/Renderer/RendererObject.h

@@ -25,16 +25,9 @@ class ResourceManager;
 class RendererObject
 {
 public:
-	RendererObject(Renderer* r)
-		: m_r(r)
-	{
-	}
+	RendererObject() = default;
 
-	virtual ~RendererObject()
-	{
-	}
-
-	HeapMemoryPool& getMemoryPool() const;
+	virtual ~RendererObject() = default;
 
 	virtual void getDebugRenderTarget([[maybe_unused]] CString rtName,
 									  [[maybe_unused]] Array<RenderTargetHandle, kMaxDebugRenderTargets>& handles,
@@ -44,11 +37,7 @@ public:
 	}
 
 protected:
-	Renderer* m_r; ///< Know your father
-
-	ANKI_PURE RendererExternalSubsystems& getExternalSubsystems();
-
-	ANKI_PURE const RendererExternalSubsystems& getExternalSubsystems() const;
+	static Renderer& getRenderer();
 
 	void* allocateRebarStagingMemory(PtrSize size, RebarGpuMemoryToken& token);
 

AnKi/Renderer/RtShadows.cpp

@@ -20,10 +20,6 @@
 
 namespace anki {
 
-RtShadows::~RtShadows()
-{
-}
-
 Error RtShadows::init()
 {
 	const Error err = initInternal();
@@ -74,8 +70,8 @@ Error RtShadows::initInternal()
 		ANKI_CHECK(
 			ResourceManager::getSingleton().loadResource("ShaderBinaries/RtShadowsDenoise.ankiprogbin", m_denoiseProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_denoiseProg);
-		variantInitInfo.addConstant("kOutImageSize",
-									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
+		variantInitInfo.addConstant("kOutImageSize", UVec2(getRenderer().getInternalResolution().x() / 2,
+														   getRenderer().getInternalResolution().y() / 2));
 		variantInitInfo.addConstant("kMinSampleCount", 8u);
 		variantInitInfo.addConstant("kMaxSampleCount", 32u);
 		variantInitInfo.addMutation("BLUR_ORIENTATION", 0);
@@ -95,8 +91,8 @@ Error RtShadows::initInternal()
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/RtShadowsSvgfVariance.ankiprogbin",
 																m_svgfVarianceProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_svgfVarianceProg);
-		variantInitInfo.addConstant("kFramebufferSize",
-									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
+		variantInitInfo.addConstant("kFramebufferSize", UVec2(getRenderer().getInternalResolution().x() / 2,
+															  getRenderer().getInternalResolution().y() / 2));
 
 		const ShaderProgramResourceVariant* variant;
 		m_svgfVarianceProg->getOrCreateVariant(variantInitInfo, variant);
@@ -109,8 +105,8 @@ Error RtShadows::initInternal()
 		ANKI_CHECK(ResourceManager::getSingleton().loadResource("ShaderBinaries/RtShadowsSvgfAtrous.ankiprogbin",
 																m_svgfAtrousProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_svgfAtrousProg);
-		variantInitInfo.addConstant("kFramebufferSize",
-									UVec2(m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2));
+		variantInitInfo.addConstant("kFramebufferSize", UVec2(getRenderer().getInternalResolution().x() / 2,
+															  getRenderer().getInternalResolution().y() / 2));
 		variantInitInfo.addMutation("LAST_PASS", 0);
 
 		const ShaderProgramResourceVariant* variant;
@@ -127,8 +123,8 @@ Error RtShadows::initInternal()
 		ANKI_CHECK(
 			ResourceManager::getSingleton().loadResource("ShaderBinaries/RtShadowsUpscale.ankiprogbin", m_upscaleProg));
 		ShaderProgramResourceVariantInitInfo variantInitInfo(m_upscaleProg);
-		variantInitInfo.addConstant("kOutImageSize",
-									UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));
+		variantInitInfo.addConstant("kOutImageSize", UVec2(getRenderer().getInternalResolution().x(),
+														   getRenderer().getInternalResolution().y()));
 
 		const ShaderProgramResourceVariant* variant;
 		m_upscaleProg->getOrCreateVariant(variantInitInfo, variant);
@@ -141,47 +137,49 @@ Error RtShadows::initInternal()
 
 	// Quarter rez shadow RT
 	{
-		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Uint,
+		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2,
+			Format::kR32G32_Uint,
 			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows History");
-		m_historyRt = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_historyRt = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Temp shadow RT
 	{
-		m_intermediateShadowsRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
-																			m_r->getInternalResolution().y() / 2,
-																			Format::kR32G32_Uint, "RtShadows Tmp");
+		m_intermediateShadowsRtDescr = getRenderer().create2DRenderTargetDescription(
+			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2,
+			Format::kR32G32_Uint, "RtShadows Tmp");
 		m_intermediateShadowsRtDescr.bake();
 	}
 
 	// Moments RT
 	{
-		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(
-			m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, Format::kR32G32_Sfloat,
+		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+			getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2,
+			Format::kR32G32_Sfloat,
 			TextureUsageBit::kAllSampled | TextureUsageBit::kImageTraceRaysWrite | TextureUsageBit::kImageComputeWrite,
 			"RtShadows Moments #1");
-		m_momentsRts[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_momentsRts[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 		texinit.setName("RtShadows Moments #2");
-		m_momentsRts[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_momentsRts[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
 	// Variance RT
 	if(m_useSvgf)
 	{
-		m_varianceRtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x() / 2,
-																 m_r->getInternalResolution().y() / 2,
-																 Format::kR32_Sfloat, "RtShadows Variance");
+		m_varianceRtDescr = getRenderer().create2DRenderTargetDescription(getRenderer().getInternalResolution().x() / 2,
+																		  getRenderer().getInternalResolution().y() / 2,
+																		  Format::kR32_Sfloat, "RtShadows Variance");
 		m_varianceRtDescr.bake();
 	}
 
 	// Final RT
 	{
-		m_upscaledRtDescr =
-			m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-												 Format::kR32G32_Uint, "RtShadows Upscaled");
+		m_upscaledRtDescr = getRenderer().create2DRenderTargetDescription(getRenderer().getInternalResolution().x(),
+																		  getRenderer().getInternalResolution().y(),
+																		  Format::kR32G32_Uint, "RtShadows Upscaled");
 		m_upscaledRtDescr.bake();
 	}
 
@@ -199,7 +197,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
 	buildSbt(ctx);
-	const U32 prevRtIdx = m_r->getFrameCount() & 1;
+	const U32 prevRtIdx = getRenderer().getFrameCount() & 1;
 
 	// Import RTs
 	{
@@ -245,8 +243,8 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 	}
 
 #define ANKI_DEPTH_DEP \
-	m_r->getDepthDownscale().getHiZRt(), TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute, \
-		kHiZHalfSurface
+	getRenderer().getDepthDownscale().getHiZRt(), \
+		TextureUsageBit::kSampledTraceRays | TextureUsageBit::kSampledCompute, kHiZHalfSurface
 
 	// RT shadows pass
 	{
@@ -258,17 +256,19 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledTraceRays);
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kImageTraceRaysWrite);
 		rpass.newAccelerationStructureDependency(
-			m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle(),
+			getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle(),
 			AccelerationStructureUsageBit::kTraceRaysRead);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledTraceRays);
-		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(),
+								   TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(),
+								   TextureUsageBit::kSampledTraceRays);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledTraceRays);
 
 		rpass.newTextureDependency(m_runCtx.m_prevMomentsRt, TextureUsageBit::kSampledTraceRays);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kImageTraceRaysWrite);
 
-		rpass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 								  BufferUsageBit::kStorageTraceRaysRead);
 	}
 
@@ -282,9 +282,10 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(),
+								   TextureUsageBit::kSampledCompute);
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite);
 	}
@@ -299,9 +300,10 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(),
+								   TextureUsageBit::kSampledCompute);
 
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kImageComputeWrite);
 	}
@@ -316,9 +318,10 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[0], TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(m_runCtx.m_currentMomentsRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_r->getMotionVectors().getHistoryLengthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getMotionVectors().getHistoryLengthRt(),
+								   TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
-		rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 
 		rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[1], TextureUsageBit::kImageComputeWrite);
 		rpass.newTextureDependency(m_runCtx.m_varianceRts[1], TextureUsageBit::kImageComputeWrite);
@@ -340,7 +343,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 			});
 
 			rpass.newTextureDependency(ANKI_DEPTH_DEP);
-			rpass.newTextureDependency(m_r->getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
+			rpass.newTextureDependency(getRenderer().getGBuffer().getColorRt(2), TextureUsageBit::kSampledCompute);
 			rpass.newTextureDependency(m_runCtx.m_intermediateShadowsRts[readRtIdx], TextureUsageBit::kSampledCompute);
 			rpass.newTextureDependency(m_runCtx.m_varianceRts[readRtIdx], TextureUsageBit::kSampledCompute);
 
@@ -366,7 +369,7 @@ void RtShadows::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newTextureDependency(m_runCtx.m_historyRt, TextureUsageBit::kSampledCompute);
-		rpass.newTextureDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), TextureUsageBit::kSampledCompute);
 		rpass.newTextureDependency(ANKI_DEPTH_DEP);
 
 		rpass.newTextureDependency(m_runCtx.m_upscaledRt, TextureUsageBit::kImageComputeWrite);
@@ -462,7 +465,7 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 	// More globals
 	cmdb->bindAllBindless(U32(MaterialSet::kBindless));
 	cmdb->bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler),
-					  m_r->getSamplers().m_trilinearRepeat);
+					  getRenderer().getSamplers().m_trilinearRepeat);
 	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene),
 							GpuSceneMemoryPool::getSingleton().getBuffer(), 0, kMaxPtrSize);
 
@@ -474,27 +477,29 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 
 	constexpr U32 kSet = 2;
 
-	bindUniforms(cmdb, kSet, 0, m_r->getClusterBinning().getClusteredUniformsRebarToken());
+	bindUniforms(cmdb, kSet, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
 
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, kSet, 1, ClusteredObjectType::kPointLight);
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, kSet, 2, ClusteredObjectType::kSpotLight);
-	rgraphCtx.bindColorTexture(kSet, 3, m_r->getShadowMapping().getShadowmapRt());
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, kSet, 1,
+																			 ClusteredObjectType::kPointLight);
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, kSet, 2,
+																			 ClusteredObjectType::kSpotLight);
+	rgraphCtx.bindColorTexture(kSet, 3, getRenderer().getShadowMapping().getShadowmapRt());
 
-	bindStorage(cmdb, kSet, 4, m_r->getClusterBinning().getClustersRebarToken());
+	bindStorage(cmdb, kSet, 4, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindSampler(kSet, 5, m_r->getSamplers().m_trilinearRepeat);
+	cmdb->bindSampler(kSet, 5, getRenderer().getSamplers().m_trilinearRepeat);
 
 	rgraphCtx.bindImage(kSet, 6, m_runCtx.m_intermediateShadowsRts[0]);
 
 	rgraphCtx.bindColorTexture(kSet, 7, m_runCtx.m_historyRt);
-	cmdb->bindSampler(kSet, 8, m_r->getSamplers().m_trilinearClamp);
-	cmdb->bindSampler(kSet, 9, m_r->getSamplers().m_nearestNearestClamp);
-	rgraphCtx.bindTexture(kSet, 10, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-	rgraphCtx.bindColorTexture(kSet, 11, m_r->getMotionVectors().getMotionVectorsRt());
-	rgraphCtx.bindColorTexture(kSet, 12, m_r->getMotionVectors().getHistoryLengthRt());
-	rgraphCtx.bindColorTexture(kSet, 13, m_r->getGBuffer().getColorRt(2));
-	rgraphCtx.bindAccelerationStructure(kSet, 14,
-										m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle());
+	cmdb->bindSampler(kSet, 8, getRenderer().getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(kSet, 9, getRenderer().getSamplers().m_nearestNearestClamp);
+	rgraphCtx.bindTexture(kSet, 10, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindColorTexture(kSet, 11, getRenderer().getMotionVectors().getMotionVectorsRt());
+	rgraphCtx.bindColorTexture(kSet, 12, getRenderer().getMotionVectors().getHistoryLengthRt());
+	rgraphCtx.bindColorTexture(kSet, 13, getRenderer().getGBuffer().getColorRt(2));
+	rgraphCtx.bindAccelerationStructure(
+		kSet, 14, getRenderer().getAccelerationStructureBuilder().getAccelerationStructureHandle());
 	rgraphCtx.bindColorTexture(kSet, 15, m_runCtx.m_prevMomentsRt);
 	rgraphCtx.bindImage(kSet, 16, m_runCtx.m_currentMomentsRt);
 	cmdb->bindTexture(kSet, 17, m_blueNoiseImage->getTextureView());
@@ -507,7 +512,7 @@ void RtShadows::run(RenderPassWorkContext& rgraphCtx)
 	cmdb->setPushConstants(&unis, sizeof(unis));
 
 	cmdb->traceRays(m_runCtx.m_sbtBuffer, m_runCtx.m_sbtOffset, m_sbtRecordSize, m_runCtx.m_hitGroupCount, 1,
-					m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2, 1);
+					getRenderer().getInternalResolution().x() / 2, getRenderer().getInternalResolution().y() / 2, 1);
 }
 
 void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
@@ -516,13 +521,13 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 
 	cmdb->bindShaderProgram((m_runCtx.m_denoiseOrientation == 0) ? m_grDenoiseHorizontalProg : m_grDenoiseVerticalProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[m_runCtx.m_denoiseOrientation]);
-	rgraphCtx.bindTexture(0, 3, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-	rgraphCtx.bindColorTexture(0, 4, m_r->getGBuffer().getColorRt(2));
+	rgraphCtx.bindTexture(0, 3, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindColorTexture(0, 4, getRenderer().getGBuffer().getColorRt(2));
 	rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_currentMomentsRt);
-	rgraphCtx.bindColorTexture(0, 6, m_r->getMotionVectors().getHistoryLengthRt());
+	rgraphCtx.bindColorTexture(0, 6, getRenderer().getMotionVectors().getHistoryLengthRt());
 
 	rgraphCtx.bindImage(
 		0, 7, (m_runCtx.m_denoiseOrientation == 0) ? m_runCtx.m_intermediateShadowsRts[1] : m_runCtx.m_historyRt);
@@ -532,7 +537,8 @@ void RtShadows::runDenoise(const RenderingContext& ctx, RenderPassWorkContext& r
 	unis.time = F32(GlobalFrameIndex::getSingleton().m_value);
 	cmdb->setPushConstants(&unis, sizeof(unis));
 
-	dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
+	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2,
+					  getRenderer().getInternalResolution().y() / 2);
 
 	m_runCtx.m_denoiseOrientation = !m_runCtx.m_denoiseOrientation;
 }
@@ -543,13 +549,13 @@ void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkConte
 
 	cmdb->bindShaderProgram(m_svgfVarianceGrProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_intermediateShadowsRts[0]);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_currentMomentsRt);
-	rgraphCtx.bindColorTexture(0, 4, m_r->getMotionVectors().getHistoryLengthRt());
-	rgraphCtx.bindTexture(0, 5, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindColorTexture(0, 4, getRenderer().getMotionVectors().getHistoryLengthRt());
+	rgraphCtx.bindTexture(0, 5, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 
 	rgraphCtx.bindImage(0, 6, m_runCtx.m_intermediateShadowsRts[1]);
 	rgraphCtx.bindImage(0, 7, m_runCtx.m_varianceRts[1]);
@@ -557,7 +563,8 @@ void RtShadows::runSvgfVariance(const RenderingContext& ctx, RenderPassWorkConte
 	const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
 	cmdb->setPushConstants(&invProjMat, sizeof(invProjMat));
 
-	dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
+	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2,
+					  getRenderer().getInternalResolution().y() / 2);
 }
 
 void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
@@ -576,10 +583,10 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 		cmdb->bindShaderProgram(m_svgfAtrousGrProg);
 	}
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
-	rgraphCtx.bindTexture(0, 2, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindTexture(0, 2, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
 	rgraphCtx.bindColorTexture(0, 3, m_runCtx.m_intermediateShadowsRts[readRtIdx]);
 	rgraphCtx.bindColorTexture(0, 4, m_runCtx.m_varianceRts[readRtIdx]);
 
@@ -596,7 +603,8 @@ void RtShadows::runSvgfAtrous(const RenderingContext& ctx, RenderPassWorkContext
 	const Mat4& invProjMat = ctx.m_matrices.m_projectionJitter.getInverse();
 	cmdb->setPushConstants(&invProjMat, sizeof(invProjMat));
 
-	dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x() / 2, m_r->getInternalResolution().y() / 2);
+	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x() / 2,
+					  getRenderer().getInternalResolution().y() / 2);
 
 	++m_runCtx.m_atrousPassIdx;
 }
@@ -607,15 +615,16 @@ void RtShadows::runUpscale(RenderPassWorkContext& rgraphCtx)
 
 	cmdb->bindShaderProgram(m_upscaleGrProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
 
 	rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
 	rgraphCtx.bindImage(0, 3, m_runCtx.m_upscaledRt);
-	rgraphCtx.bindTexture(0, 4, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-	rgraphCtx.bindTexture(0, 5, m_r->getGBuffer().getDepthRt(), TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
+	rgraphCtx.bindTexture(0, 4, getRenderer().getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindTexture(0, 5, getRenderer().getGBuffer().getDepthRt(),
+						  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
-	dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+	dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 }
 
 void RtShadows::buildSbt(RenderingContext& ctx)
@@ -671,7 +680,7 @@ void RtShadows::buildSbt(RenderingContext& ctx)
 
 Bool RtShadows::findShadowLayer(U64 lightUuid, U32& layerIdx, Bool& rejectHistoryBuffer)
 {
-	const U64 crntFrame = m_r->getFrameCount();
+	const U64 crntFrame = getRenderer().getFrameCount();
 	layerIdx = kMaxU32;
 	U32 nextBestLayerIdx = kMaxU32;
 	U64 nextBestLayerFame = crntFrame;

AnKi/Renderer/RtShadows.h

@@ -19,16 +19,13 @@ namespace anki {
 class RtShadows : public RendererObject
 {
 public:
-	RtShadows(Renderer* r)
-		: RendererObject(r)
+	RtShadows()
 	{
 		registerDebugRenderTarget("RtShadows");
 		registerDebugRenderTarget("RtShadows1");
 		registerDebugRenderTarget("RtShadows2");
 	}
 
-	~RtShadows();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/Scale.cpp

@@ -32,13 +32,9 @@
 
 namespace anki {
 
-Scale::~Scale()
-{
-}
-
 Error Scale::init()
 {
-	const Bool needsScaling = m_r->getPostProcessResolution() != m_r->getInternalResolution();
+	const Bool needsScaling = getRenderer().getPostProcessResolution() != getRenderer().getInternalResolution();
 	const Bool needsSharpening = ConfigSet::getSingleton().getRSharpness() > 0.0f;
 	if(!needsScaling && !needsSharpening)
 	{
@@ -108,8 +104,8 @@ Error Scale::init()
 	else if(m_upscalingMethod == UpscalingMethod::kGr)
 	{
 		GrUpscalerInitInfo inf;
-		inf.m_sourceTextureResolution = m_r->getInternalResolution();
-		inf.m_targetTextureResolution = m_r->getPostProcessResolution();
+		inf.m_sourceTextureResolution = getRenderer().getInternalResolution();
+		inf.m_targetTextureResolution = getRenderer().getPostProcessResolution();
 		inf.m_upscalerType = GrUpscalerType::kDlss2;
 		inf.m_qualityMode = GrUpscalerQualityMode(dlssQuality - 1);
 
@@ -145,7 +141,7 @@ Error Scale::init()
 	Format format;
 	if(m_upscalingMethod == UpscalingMethod::kGr)
 	{
-		format = m_r->getHdrFormat();
+		format = getRenderer().getHdrFormat();
 	}
 	else if(GrManager::getSingleton().getDeviceCapabilities().m_unalignedBbpTextureFormats)
 	{
@@ -156,8 +152,8 @@ Error Scale::init()
 		format = Format::kR8G8B8A8_Unorm;
 	}
 
-	m_upscaleAndSharpenRtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(), format, "Scaling");
+	m_upscaleAndSharpenRtDescr = getRenderer().create2DRenderTargetDescription(
+		getRenderer().getPostProcessResolution().x(), getRenderer().getPostProcessResolution().y(), format, "Scaling");
 	m_upscaleAndSharpenRtDescr.bake();
 
 	if(m_neeedsTonemapping)
@@ -165,8 +161,9 @@ Error Scale::init()
 		const Format fmt = (GrManager::getSingleton().getDeviceCapabilities().m_unalignedBbpTextureFormats)
 							   ? Format::kR8G8B8_Unorm
 							   : Format::kR8G8B8A8_Unorm;
-		m_tonemapedRtDescr = m_r->create2DRenderTargetDescription(
-			m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y(), fmt, "Tonemapped");
+		m_tonemapedRtDescr = getRenderer().create2DRenderTargetDescription(getRenderer().getPostProcessResolution().x(),
+																		   getRenderer().getPostProcessResolution().y(),
+																		   fmt, "Tonemapped");
 		m_tonemapedRtDescr.bake();
 	}
 
@@ -180,10 +177,10 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 {
 	if(m_upscalingMethod == UpscalingMethod::kNone && m_sharpenMethod == SharpenMethod::kNone)
 	{
-		m_runCtx.m_upscaledTonemappedRt = m_r->getTemporalAA().getTonemappedRt();
-		m_runCtx.m_upscaledHdrRt = m_r->getTemporalAA().getHdrRt();
-		m_runCtx.m_sharpenedRt = m_r->getTemporalAA().getTonemappedRt();
-		m_runCtx.m_tonemappedRt = m_r->getTemporalAA().getTonemappedRt();
+		m_runCtx.m_upscaledTonemappedRt = getRenderer().getTemporalAA().getTonemappedRt();
+		m_runCtx.m_upscaledHdrRt = getRenderer().getTemporalAA().getHdrRt();
+		m_runCtx.m_sharpenedRt = getRenderer().getTemporalAA().getTonemappedRt();
+		m_runCtx.m_tonemappedRt = getRenderer().getTemporalAA().getTonemappedRt();
 		return;
 	}
 
@@ -202,9 +199,9 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 		const TextureUsageBit readUsage = TextureUsageBit::kAllSampled & TextureUsageBit::kAllCompute;
 		const TextureUsageBit writeUsage = TextureUsageBit::kAllImage & TextureUsageBit::kAllCompute;
 
-		pass.newTextureDependency(m_r->getLightShading().getRt(), readUsage);
-		pass.newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
-		pass.newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage,
+		pass.newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
+		pass.newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage,
 								  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 		pass.newTextureDependency(m_runCtx.m_upscaledHdrRt, writeUsage);
 
@@ -216,7 +213,7 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 	{
 		m_runCtx.m_upscaledTonemappedRt = rgraph.newRenderTarget(m_upscaleAndSharpenRtDescr);
 		m_runCtx.m_upscaledHdrRt = {};
-		const RenderTargetHandle inRt = m_r->getTemporalAA().getTonemappedRt();
+		const RenderTargetHandle inRt = getRenderer().getTemporalAA().getTonemappedRt();
 		const RenderTargetHandle outRt = m_runCtx.m_upscaledTonemappedRt;
 
 		if(preferCompute)
@@ -245,8 +242,8 @@ void Scale::populateRenderGraph(RenderingContext& ctx)
 	{
 		ANKI_ASSERT(m_upscalingMethod == UpscalingMethod::kNone);
 		// Pretend that it got scaled
-		m_runCtx.m_upscaledTonemappedRt = m_r->getTemporalAA().getTonemappedRt();
-		m_runCtx.m_upscaledHdrRt = m_r->getTemporalAA().getHdrRt();
+		m_runCtx.m_upscaledTonemappedRt = getRenderer().getTemporalAA().getTonemappedRt();
+		m_runCtx.m_upscaledHdrRt = getRenderer().getTemporalAA().getHdrRt();
 	}
 
 	// Step 2: Tonemapping
@@ -324,12 +321,12 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 {
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
-	const RenderTargetHandle inRt = m_r->getTemporalAA().getTonemappedRt();
+	const RenderTargetHandle inRt = getRenderer().getTemporalAA().getTonemappedRt();
 	const RenderTargetHandle outRt = m_runCtx.m_upscaledTonemappedRt;
 
 	cmdb->bindShaderProgram(m_scaleGrProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -350,12 +347,12 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 			UVec2 m_padding;
 		} pc;
 
-		const Vec2 inRez(m_r->getInternalResolution());
-		const Vec2 outRez(m_r->getPostProcessResolution());
+		const Vec2 inRez(getRenderer().getInternalResolution());
+		const Vec2 outRez(getRenderer().getPostProcessResolution());
 		FsrEasuCon(&pc.m_fsrConsts0[0], &pc.m_fsrConsts1[0], &pc.m_fsrConsts2[0], &pc.m_fsrConsts3[0], inRez.x(),
 				   inRez.y(), inRez.x(), inRez.y(), outRez.x(), outRez.y());
 
-		pc.m_viewportSize = m_r->getPostProcessResolution();
+		pc.m_viewportSize = getRenderer().getPostProcessResolution();
 
 		cmdb->setPushConstants(&pc, sizeof(pc));
 	}
@@ -367,19 +364,21 @@ void Scale::runFsrOrBilinearScaling(RenderPassWorkContext& rgraphCtx)
 			Vec2 m_viewportSize;
 			UVec2 m_viewportSizeU;
 		} pc;
-		pc.m_viewportSize = Vec2(m_r->getPostProcessResolution());
-		pc.m_viewportSizeU = m_r->getPostProcessResolution();
+		pc.m_viewportSize = Vec2(getRenderer().getPostProcessResolution());
+		pc.m_viewportSizeU = getRenderer().getPostProcessResolution();
 
 		cmdb->setPushConstants(&pc, sizeof(pc));
 	}
 
 	if(preferCompute)
 	{
-		dispatchPPCompute(cmdb, 8, 8, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
@@ -393,7 +392,7 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 
 	cmdb->bindShaderProgram(m_sharpenGrProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
 	if(preferCompute)
@@ -417,35 +416,38 @@ void Scale::runRcasSharpening(RenderPassWorkContext& rgraphCtx)
 	sharpness = 3.0f - sharpness; // [3, 0], RCAS translates 0 to max sharpness
 	FsrRcasCon(&pc.m_fsrConsts0[0], sharpness);
 
-	pc.m_viewportSize = m_r->getPostProcessResolution();
+	pc.m_viewportSize = getRenderer().getPostProcessResolution();
 
 	cmdb->setPushConstants(&pc, sizeof(pc));
 
 	if(preferCompute)
 	{
-		dispatchPPCompute(cmdb, 8, 8, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }
 
 void Scale::runGrUpscaling(RenderingContext& ctx, RenderPassWorkContext& rgraphCtx)
 {
-	const Vec2 srcRes(m_r->getInternalResolution());
-	const Bool reset = m_r->getFrameCount() == 0;
+	const Vec2 srcRes(getRenderer().getInternalResolution());
+	const Bool reset = getRenderer().getFrameCount() == 0;
 	const Vec2 mvScale = srcRes; // UV space to Pixel space factor
 	// In [-texSize / 2, texSize / 2] -> sub-pixel space {-0.5, 0.5}
 	const Vec2 jitterOffset = ctx.m_matrices.m_jitter.getTranslationPart().xy() * srcRes * 0.5f;
 
 	CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
-	TextureViewPtr srcView = rgraphCtx.createTextureView(m_r->getLightShading().getRt());
-	TextureViewPtr motionVectorsView = rgraphCtx.createTextureView(m_r->getMotionVectors().getMotionVectorsRt());
-	TextureViewPtr depthView = rgraphCtx.createTextureView(m_r->getGBuffer().getDepthRt());
-	TextureViewPtr exposureView = rgraphCtx.createTextureView(m_r->getTonemapping().getRt());
+	TextureViewPtr srcView = rgraphCtx.createTextureView(getRenderer().getLightShading().getRt());
+	TextureViewPtr motionVectorsView =
+		rgraphCtx.createTextureView(getRenderer().getMotionVectors().getMotionVectorsRt());
+	TextureViewPtr depthView = rgraphCtx.createTextureView(getRenderer().getGBuffer().getDepthRt());
+	TextureViewPtr exposureView = rgraphCtx.createTextureView(getRenderer().getTonemapping().getRt());
 	TextureViewPtr dstView = rgraphCtx.createTextureView(m_runCtx.m_upscaledHdrRt);
 
 	cmdb->upscale(m_grUpscaler, srcView, dstView, motionVectorsView, depthView, exposureView, reset, jitterOffset,
@@ -461,10 +463,10 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 
 	cmdb->bindShaderProgram(m_tonemapGrProg);
 
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 	rgraphCtx.bindColorTexture(0, 1, inRt);
 
-	rgraphCtx.bindImage(0, 2, m_r->getTonemapping().getRt());
+	rgraphCtx.bindImage(0, 2, getRenderer().getTonemapping().getRt());
 
 	if(preferCompute)
 	{
@@ -474,16 +476,18 @@ void Scale::runTonemapping(RenderPassWorkContext& rgraphCtx)
 			Vec2 m_viewportSizeOverOne;
 			UVec2 m_viewportSize;
 		} pc;
-		pc.m_viewportSizeOverOne = 1.0f / Vec2(m_r->getPostProcessResolution());
-		pc.m_viewportSize = m_r->getPostProcessResolution();
+		pc.m_viewportSizeOverOne = 1.0f / Vec2(getRenderer().getPostProcessResolution());
+		pc.m_viewportSize = getRenderer().getPostProcessResolution();
 		cmdb->setPushConstants(&pc, sizeof(pc));
 		rgraphCtx.bindImage(0, 3, outRt);
 
-		dispatchPPCompute(cmdb, 8, 8, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		dispatchPPCompute(cmdb, 8, 8, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 	}
 	else
 	{
-		cmdb->setViewport(0, 0, m_r->getPostProcessResolution().x(), m_r->getPostProcessResolution().y());
+		cmdb->setViewport(0, 0, getRenderer().getPostProcessResolution().x(),
+						  getRenderer().getPostProcessResolution().y());
 		cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 	}
 }

AnKi/Renderer/Scale.h

@@ -16,13 +16,6 @@ namespace anki {
 class Scale : public RendererObject
 {
 public:
-	Scale(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~Scale();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/ShadowMapping.cpp

@@ -32,10 +32,6 @@ public:
 	U32 m_renderQueueElementsLod;
 };
 
-ShadowMapping::~ShadowMapping()
-{
-}
-
 Error ShadowMapping::init()
 {
 	const Error err = initInternal();
@@ -60,16 +56,16 @@ Error ShadowMapping::initInternal()
 		// RT
 		const TextureUsageBit usage =
 			TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute | TextureUsageBit::kAllFramebuffer;
-		TextureInitInfo texinit = m_r->create2DRenderTargetInitInfo(m_tileResolution * m_tileCountBothAxis,
-																	m_tileResolution * m_tileCountBothAxis,
-																	Format::kD16_Unorm, usage, "ShadowAtlas");
+		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(m_tileResolution * m_tileCountBothAxis,
+																			 m_tileResolution * m_tileCountBothAxis,
+																			 Format::kD16_Unorm, usage, "ShadowAtlas");
 		ClearValue clearVal;
 		clearVal.m_colorf[0] = 1.0f;
-		m_atlasTex = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clearVal);
+		m_atlasTex = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment, clearVal);
 	}
 
 	// Tiles
-	m_tileAlloc.init(&getMemoryPool(), m_tileCountBothAxis, m_tileCountBothAxis, kTileAllocHierarchyCount, true);
+	m_tileAlloc.init(m_tileCountBothAxis, m_tileCountBothAxis, kTileAllocHierarchyCount, true);
 
 	m_fbDescr.m_depthStencilAttachment.m_aspect = DepthStencilAspectBit::kDepth;
 	m_fbDescr.m_depthStencilAttachment.m_loadOperation = AttachmentLoadOperation::kLoad;
@@ -127,7 +123,7 @@ void ShadowMapping::populateRenderGraph(RenderingContext& ctx)
 		TextureSubresourceInfo subresource = TextureSubresourceInfo(DepthStencilAspectBit::kDepth);
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kAllFramebuffer, subresource);
 
-		pass.newBufferDependency(m_r->getGpuSceneBufferHandle(),
+		pass.newBufferDependency(getRenderer().getGpuSceneBufferHandle(),
 								 BufferUsageBit::kStorageGeometryRead | BufferUsageBit::kStorageFragmentRead);
 	}
 }
@@ -614,13 +610,13 @@ void ShadowMapping::runShadowMapping(RenderPassWorkContext& rgraphCtx)
 		args.m_cameraTransform = Mat3x4::getIdentity(); // Don't care
 		args.m_viewProjectionMatrix = work.m_renderQueue->m_viewProjectionMatrix;
 		args.m_previousViewProjectionMatrix = Mat4::getIdentity(); // Don't care
-		args.m_sampler = m_r->getSamplers().m_trilinearRepeatAniso;
+		args.m_sampler = getRenderer().getSamplers().m_trilinearRepeatAniso;
 
-		m_r->getSceneDrawer().drawRange(args,
-										work.m_renderQueue->m_renderables.getBegin() + work.m_firstRenderableElement,
-										work.m_renderQueue->m_renderables.getBegin() + work.m_firstRenderableElement
-											+ work.m_renderableElementCount,
-										cmdb);
+		getRenderer().getSceneDrawer().drawRange(
+			args, work.m_renderQueue->m_renderables.getBegin() + work.m_firstRenderableElement,
+			work.m_renderQueue->m_renderables.getBegin() + work.m_firstRenderableElement
+				+ work.m_renderableElementCount,
+			cmdb);
 	}
 }
 

AnKi/Renderer/ShadowMapping.h

@@ -12,6 +12,10 @@
 
 namespace anki {
 
+// Forward
+class PointLightQueueElement;
+class SpotLightQueueElement;
+
 /// @addtogroup renderer
 /// @{
 
@@ -19,13 +23,6 @@ namespace anki {
 class ShadowMapping : public RendererObject
 {
 public:
-	ShadowMapping(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~ShadowMapping();
-
 	Error init();
 
 	/// Populate the rendergraph.

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -14,10 +14,6 @@
 
 namespace anki {
 
-ShadowmapsResolve::~ShadowmapsResolve()
-{
-}
-
 Error ShadowmapsResolve::init()
 {
 	const Error err = initInternal();
@@ -32,12 +28,12 @@ Error ShadowmapsResolve::init()
 Error ShadowmapsResolve::initInternal()
 {
 	m_quarterRez = ConfigSet::getSingleton().getRSmResolveQuarterRez();
-	const U32 width = m_r->getInternalResolution().x() / (m_quarterRez + 1);
-	const U32 height = m_r->getInternalResolution().y() / (m_quarterRez + 1);
+	const U32 width = getRenderer().getInternalResolution().x() / (m_quarterRez + 1);
+	const U32 height = getRenderer().getInternalResolution().y() / (m_quarterRez + 1);
 
 	ANKI_R_LOGV("Initializing shadowmaps resolve. Resolution %ux%u", width, height);
 
-	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::kR8G8B8A8_Unorm, "SM resolve");
+	m_rtDescr = getRenderer().create2DRenderTargetDescription(width, height, Format::kR8G8B8A8_Unorm, "SM resolve");
 	m_rtDescr.bake();
 
 	// Create FB descr
@@ -51,9 +47,9 @@ Error ShadowmapsResolve::initInternal()
 															m_prog));
 	ShaderProgramResourceVariantInitInfo variantInitInfo(m_prog);
 	variantInitInfo.addConstant("kFramebufferSize", UVec2(width, height));
-	variantInitInfo.addConstant("kTileCount", m_r->getTileCounts());
-	variantInitInfo.addConstant("kZSplitCount", m_r->getZSplitCount());
-	variantInitInfo.addConstant("kTileSize", m_r->getTileSize());
+	variantInitInfo.addConstant("kTileCount", getRenderer().getTileCounts());
+	variantInitInfo.addConstant("kZSplitCount", getRenderer().getZSplitCount());
+	variantInitInfo.addConstant("kTileSize", getRenderer().getTileSize());
 	variantInitInfo.addMutation("PCF", ConfigSet::getSingleton().getRShadowMappingPcf());
 	const ShaderProgramResourceVariant* variant;
 	m_prog->getOrCreateVariant(variantInitInfo, variant);
@@ -78,12 +74,12 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
-		rpass.newTextureDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt()
-												  : m_r->getGBuffer().getDepthRt(),
+		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getHiZRt()
+												  : getRenderer().getGBuffer().getDepthRt(),
 								   TextureUsageBit::kSampledCompute, TextureSurfaceInfo(0, 0, 0, 0));
-		rpass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
+		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-		rpass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 								  BufferUsageBit::kStorageComputeRead);
 	}
 	else
@@ -96,12 +92,13 @@ void ShadowmapsResolve::populateRenderGraph(RenderingContext& ctx)
 		});
 
 		rpass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kFramebufferWrite);
-		rpass.newTextureDependency((m_quarterRez) ? m_r->getDepthDownscale().getHiZRt()
-												  : m_r->getGBuffer().getDepthRt(),
+		rpass.newTextureDependency((m_quarterRez) ? getRenderer().getDepthDownscale().getHiZRt()
+												  : getRenderer().getGBuffer().getDepthRt(),
 								   TextureUsageBit::kSampledFragment, TextureSurfaceInfo(0, 0, 0, 0));
-		rpass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledFragment);
+		rpass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(),
+								   TextureUsageBit::kSampledFragment);
 
-		rpass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+		rpass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 								  BufferUsageBit::kStorageFragmentRead);
 	}
 }
@@ -112,24 +109,26 @@ void ShadowmapsResolve::run(RenderPassWorkContext& rgraphCtx)
 
 	cmdb->bindShaderProgram(m_grProg);
 
-	bindUniforms(cmdb, 0, 0, m_r->getClusterBinning().getClusteredUniformsRebarToken());
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1, ClusteredObjectType::kPointLight);
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 2, ClusteredObjectType::kSpotLight);
-	rgraphCtx.bindColorTexture(0, 3, m_r->getShadowMapping().getShadowmapRt());
-	bindStorage(cmdb, 0, 4, m_r->getClusterBinning().getClustersRebarToken());
+	bindUniforms(cmdb, 0, 0, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 1,
+																			 ClusteredObjectType::kPointLight);
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 2,
+																			 ClusteredObjectType::kSpotLight);
+	rgraphCtx.bindColorTexture(0, 3, getRenderer().getShadowMapping().getShadowmapRt());
+	bindStorage(cmdb, 0, 4, getRenderer().getClusterBinning().getClustersRebarToken());
 
-	cmdb->bindSampler(0, 5, m_r->getSamplers().m_trilinearClamp);
-	cmdb->bindSampler(0, 6, m_r->getSamplers().m_trilinearClampShadow);
-	cmdb->bindSampler(0, 7, m_r->getSamplers().m_trilinearRepeat);
+	cmdb->bindSampler(0, 5, getRenderer().getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 6, getRenderer().getSamplers().m_trilinearClampShadow);
+	cmdb->bindSampler(0, 7, getRenderer().getSamplers().m_trilinearRepeat);
 
 	if(m_quarterRez)
 	{
-		rgraphCtx.bindTexture(0, 8, m_r->getDepthDownscale().getHiZRt(),
+		rgraphCtx.bindTexture(0, 8, getRenderer().getDepthDownscale().getHiZRt(),
 							  TextureSubresourceInfo(TextureSurfaceInfo(0, 0, 0, 0)));
 	}
 	else
 	{
-		rgraphCtx.bindTexture(0, 8, m_r->getGBuffer().getDepthRt(),
+		rgraphCtx.bindTexture(0, 8, getRenderer().getGBuffer().getDepthRt(),
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 	}
 	cmdb->bindTexture(0, 9, m_noiseImage->getTextureView());

AnKi/Renderer/ShadowmapsResolve.h

@@ -18,14 +18,11 @@ namespace anki {
 class ShadowmapsResolve : public RendererObject
 {
 public:
-	ShadowmapsResolve(Renderer* r)
-		: RendererObject(r)
+	ShadowmapsResolve()
 	{
 		registerDebugRenderTarget("ResolvedShadows");
 	}
 
-	~ShadowmapsResolve();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/TemporalAA.cpp

@@ -13,15 +13,6 @@
 
 namespace anki {
 
-TemporalAA::TemporalAA(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-TemporalAA::~TemporalAA()
-{
-}
-
 Error TemporalAA::init()
 {
 	const Error err = initInternal();
@@ -51,8 +42,8 @@ Error TemporalAA::initInternal()
 
 		if(ConfigSet::getSingleton().getRPreferCompute())
 		{
-			variantInitInfo.addConstant("kFramebufferSize",
-										UVec2(m_r->getInternalResolution().x(), m_r->getInternalResolution().y()));
+			variantInitInfo.addConstant("kFramebufferSize", UVec2(getRenderer().getInternalResolution().x(),
+																  getRenderer().getInternalResolution().y()));
 		}
 
 		const ShaderProgramResourceVariant* variant;
@@ -66,15 +57,15 @@ Error TemporalAA::initInternal()
 		usage |= (ConfigSet::getSingleton().getRPreferCompute()) ? TextureUsageBit::kImageComputeWrite
 																 : TextureUsageBit::kFramebufferWrite;
 
-		TextureInitInfo texinit =
-			m_r->create2DRenderTargetInitInfo(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
-											  m_r->getHdrFormat(), usage, "TemporalAA");
+		TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+			getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
+			getRenderer().getHdrFormat(), usage, "TemporalAA");
 
-		m_rtTextures[i] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+		m_rtTextures[i] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 	}
 
-	m_tonemappedRtDescr = m_r->create2DRenderTargetDescription(
-		m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
+	m_tonemappedRtDescr = getRenderer().create2DRenderTargetDescription(
+		getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y(),
 		(GrManager::getSingleton().getDeviceCapabilities().m_unalignedBbpTextureFormats) ? Format::kR8G8B8_Unorm
 																						 : Format::kR8G8B8A8_Unorm,
 		"TemporalAA Tonemapped");
@@ -90,7 +81,7 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-	const U32 historyRtIdx = (m_r->getFrameCount() + 1) & 1;
+	const U32 historyRtIdx = (getRenderer().getFrameCount() + 1) & 1;
 	const U32 renderRtIdx = !historyRtIdx;
 	const Bool preferCompute = ConfigSet::getSingleton().getRPreferCompute();
 
@@ -135,33 +126,35 @@ void TemporalAA::populateRenderGraph(RenderingContext& ctx)
 		prpass = &pass;
 	}
 
-	prpass->newTextureDependency(m_r->getGBuffer().getDepthRt(), readUsage,
+	prpass->newTextureDependency(getRenderer().getGBuffer().getDepthRt(), readUsage,
 								 TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
-	prpass->newTextureDependency(m_r->getLightShading().getRt(), readUsage);
+	prpass->newTextureDependency(getRenderer().getLightShading().getRt(), readUsage);
 	prpass->newTextureDependency(m_runCtx.m_historyRt, readUsage);
-	prpass->newTextureDependency(m_r->getMotionVectors().getMotionVectorsRt(), readUsage);
+	prpass->newTextureDependency(getRenderer().getMotionVectors().getMotionVectorsRt(), readUsage);
 
 	prpass->setWork([this](RenderPassWorkContext& rgraphCtx) {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 		cmdb->bindShaderProgram(m_grProg);
 
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
-		rgraphCtx.bindColorTexture(0, 1, m_r->getLightShading().getRt());
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+		rgraphCtx.bindColorTexture(0, 1, getRenderer().getLightShading().getRt());
 		rgraphCtx.bindColorTexture(0, 2, m_runCtx.m_historyRt);
-		rgraphCtx.bindColorTexture(0, 3, m_r->getMotionVectors().getMotionVectorsRt());
-		rgraphCtx.bindImage(0, 4, m_r->getTonemapping().getRt());
+		rgraphCtx.bindColorTexture(0, 3, getRenderer().getMotionVectors().getMotionVectorsRt());
+		rgraphCtx.bindImage(0, 4, getRenderer().getTonemapping().getRt());
 
 		if(ConfigSet::getSingleton().getRPreferCompute())
 		{
 			rgraphCtx.bindImage(0, 5, m_runCtx.m_renderRt, TextureSubresourceInfo());
 			rgraphCtx.bindImage(0, 6, m_runCtx.m_tonemappedRt, TextureSubresourceInfo());
 
-			dispatchPPCompute(cmdb, 8, 8, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+			dispatchPPCompute(cmdb, 8, 8, getRenderer().getInternalResolution().x(),
+							  getRenderer().getInternalResolution().y());
 		}
 		else
 		{
-			cmdb->setViewport(0, 0, m_r->getInternalResolution().x(), m_r->getInternalResolution().y());
+			cmdb->setViewport(0, 0, getRenderer().getInternalResolution().x(),
+							  getRenderer().getInternalResolution().y());
 
 			cmdb->drawArrays(PrimitiveTopology::kTriangles, 3);
 		}

AnKi/Renderer/TemporalAA.h

@@ -16,10 +16,6 @@ namespace anki {
 class TemporalAA : public RendererObject
 {
 public:
-	TemporalAA(Renderer* r);
-
-	~TemporalAA();
-
 	Error init();
 
 	void populateRenderGraph(RenderingContext& ctx);

AnKi/Renderer/TileAllocator.cpp

@@ -33,14 +33,15 @@ public:
 	}
 };
 
+TileAllocator::TileAllocator()
+{
+}
+
 TileAllocator::~TileAllocator()
 {
-	m_lightInfoToTileIdx.destroy(*m_pool);
-	m_allTiles.destroy(*m_pool);
-	m_firstTileIdxOfHierarchy.destroy(*m_pool);
 }
 
-void TileAllocator::init(HeapMemoryPool* pool, U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching)
+void TileAllocator::init(U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching)
 {
 	// Preconditions
 	ANKI_ASSERT(tileCountX > 0);
@@ -51,9 +52,8 @@ void TileAllocator::init(HeapMemoryPool* pool, U32 tileCountX, U32 tileCountY, U
 	m_tileCountX = U16(tileCountX);
 	m_tileCountY = U16(tileCountY);
 	m_hierarchyCount = U8(hierarchyCount);
-	m_pool = pool;
 	m_cachingEnabled = enableCaching;
-	m_firstTileIdxOfHierarchy.create(*m_pool, hierarchyCount + 1);
+	m_firstTileIdxOfHierarchy.create(hierarchyCount + 1);
 
 	// Create the tile array & index ranges
 	U32 tileCount = 0;
@@ -71,7 +71,7 @@ void TileAllocator::init(HeapMemoryPool* pool, U32 tileCountX, U32 tileCountY, U
 		tileCount += hierarchyTileCountX * hierarchyTileCountY;
 	}
 	ANKI_ASSERT(tileCount >= tileCountX * tileCountY);
-	m_allTiles.create(*m_pool, tileCount);
+	m_allTiles.create(tileCount);
 	m_firstTileIdxOfHierarchy[hierarchyCount] = tileCount - 1;
 
 	// Init the tiles
@@ -246,7 +246,7 @@ TileAllocatorResult TileAllocator::allocate(Timestamp crntTimestamp, Timestamp l
 			if(tile.m_lightUuid != lightUuid || tile.m_lightHierarchy != hierarchy || tile.m_lightFace != lightFace)
 			{
 				// Cache entry is wrong, remove it
-				m_lightInfoToTileIdx.erase(*m_pool, it);
+				m_lightInfoToTileIdx.erase(it);
 			}
 			else
 			{
@@ -344,7 +344,7 @@ TileAllocatorResult TileAllocator::allocate(Timestamp crntTimestamp, Timestamp l
 	// Update the cache
 	if(m_cachingEnabled)
 	{
-		m_lightInfoToTileIdx.emplace(*m_pool, key, allocatedTileIdx);
+		m_lightInfoToTileIdx.emplace(key, allocatedTileIdx);
 	}
 
 	// Return
@@ -366,7 +366,7 @@ void TileAllocator::invalidateCache(U64 lightUuid, U32 lightFace)
 	auto it = m_lightInfoToTileIdx.find(key);
 	if(it != m_lightInfoToTileIdx.getEnd())
 	{
-		m_lightInfoToTileIdx.erase(*m_pool, it);
+		m_lightInfoToTileIdx.erase(it);
 	}
 }
 

AnKi/Renderer/TileAllocator.h

@@ -24,7 +24,7 @@ enum class TileAllocatorResult : U32
 class TileAllocator
 {
 public:
-	TileAllocator() = default;
+	TileAllocator();
 
 	TileAllocator(const TileAllocator&) = delete; // Non-copyable
 
@@ -33,7 +33,7 @@ public:
 	TileAllocator& operator=(const TileAllocator&) = delete; // Non-copyable
 
 	/// Initialize the allocator.
-	void init(HeapMemoryPool* pool, U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching);
+	void init(U32 tileCountX, U32 tileCountY, U32 hierarchyCount, Bool enableCaching);
 
 	/// Allocate some tiles.
 	/// @param hierarchy If it's 0 it chooses the smallest tile.
@@ -50,11 +50,10 @@ private:
 	/// A HashMap key.
 	class HashMapKey;
 
-	HeapMemoryPool* m_pool = nullptr;
-	DynamicArray<Tile> m_allTiles;
-	DynamicArray<U32> m_firstTileIdxOfHierarchy;
+	RendererDynamicArray<Tile> m_allTiles;
+	RendererDynamicArray<U32> m_firstTileIdxOfHierarchy;
 
-	HashMap<HashMapKey, U32> m_lightInfoToTileIdx;
+	RendererHashMap<HashMapKey, U32> m_lightInfoToTileIdx;
 
 	U16 m_tileCountX = 0; ///< Tile count for hierarchy 0
 	U16 m_tileCountY = 0; ///< Tile count for hierarchy 0

AnKi/Renderer/Tonemapping.cpp

@@ -22,9 +22,9 @@ Error Tonemapping::init()
 
 Error Tonemapping::initInternal()
 {
-	m_inputTexMip = m_r->getDownscaleBlur().getMipmapCount() - 2;
-	const U32 width = m_r->getDownscaleBlur().getPassWidth(m_inputTexMip);
-	const U32 height = m_r->getDownscaleBlur().getPassHeight(m_inputTexMip);
+	m_inputTexMip = getRenderer().getDownscaleBlur().getMipmapCount() - 2;
+	const U32 width = getRenderer().getDownscaleBlur().getPassWidth(m_inputTexMip);
+	const U32 height = getRenderer().getDownscaleBlur().getPassHeight(m_inputTexMip);
 
 	ANKI_R_LOGV("Initializing tonemapping. Resolution %ux%u", width, height);
 
@@ -44,10 +44,11 @@ Error Tonemapping::initInternal()
 	// automatic image transitions
 	const TextureUsageBit usage = TextureUsageBit::kAllImage;
 	const TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
+		getRenderer().create2DRenderTargetInitInfo(1, 1, Format::kR16G16_Sfloat, usage, "ExposureAndAvgLum1x1");
 	ClearValue clearValue;
 	clearValue.m_colorf = {0.5f, 0.5f, 0.5f, 0.5f};
-	m_exposureAndAvgLuminance1x1 = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kAllImage, clearValue);
+	m_exposureAndAvgLuminance1x1 =
+		getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kAllImage, clearValue);
 
 	return Error::kNone;
 }
@@ -74,14 +75,15 @@ void Tonemapping::populateRenderGraph(RenderingContext& ctx)
 
 		TextureSubresourceInfo inputTexSubresource;
 		inputTexSubresource.m_firstMipmap = m_inputTexMip;
-		rgraphCtx.bindTexture(0, 0, m_r->getDownscaleBlur().getRt(), inputTexSubresource);
+		rgraphCtx.bindTexture(0, 0, getRenderer().getDownscaleBlur().getRt(), inputTexSubresource);
 
 		cmdb->dispatchCompute(1, 1, 1);
 	});
 
 	TextureSubresourceInfo inputTexSubresource;
 	inputTexSubresource.m_firstMipmap = m_inputTexMip;
-	pass.newTextureDependency(m_r->getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute, inputTexSubresource);
+	pass.newTextureDependency(getRenderer().getDownscaleBlur().getRt(), TextureUsageBit::kSampledCompute,
+							  inputTexSubresource);
 }
 
 } // end namespace anki

AnKi/Renderer/Tonemapping.h

@@ -16,11 +16,6 @@ namespace anki {
 class Tonemapping : public RendererObject
 {
 public:
-	Tonemapping(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
 	Error init();
 
 	void importRenderTargets(RenderingContext& ctx);

AnKi/Renderer/TraditionalDeferredShading.cpp

@@ -56,15 +56,6 @@ inline constexpr U16 kConeIndices[] = {0, 1,  2, 2,  1,  3,  3,  1,  4,  4,  1,
 									   2, 13, 0, 0,  13, 12, 3,  13, 2,  4,  13, 3,  5,  13, 4,  6,  13, 5,
 									   7, 13, 6, 12, 13, 11, 11, 13, 10, 10, 13, 9,  9,  13, 8,  7,  8,  13};
 
-TraditionalDeferredLightShading::TraditionalDeferredLightShading(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-TraditionalDeferredLightShading::~TraditionalDeferredLightShading()
-{
-}
-
 Error TraditionalDeferredLightShading::init()
 {
 	// Init progs
@@ -208,13 +199,13 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 
 		cmdb->bindShaderProgram(m_skyboxGrProgs[!isSolidColor]);
 
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_nearestNearestClamp);
 		rgraphCtx.bindTexture(0, 1, info.m_gbufferDepthRenderTarget,
 							  TextureSubresourceInfo(DepthStencilAspectBit::kDepth));
 
 		if(!isSolidColor)
 		{
-			cmdb->bindSampler(0, 2, m_r->getSamplers().m_trilinearRepeatAniso);
+			cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearRepeatAniso);
 			cmdb->bindTexture(0, 3, TextureViewPtr(const_cast<TextureView*>(info.m_skybox->m_skyboxTexture)));
 		}
 
@@ -234,7 +225,7 @@ void TraditionalDeferredLightShading::drawLights(TraditionalDeferredLightShading
 		cmdb->setBlendFactors(0, BlendFactor::kOne, BlendFactor::kOne);
 
 		// NOTE: Use nearest sampler because we don't want the result to sample the near tiles
-		cmdb->bindSampler(0, 2, m_r->getSamplers().m_nearestNearestClamp);
+		cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_nearestNearestClamp);
 
 		rgraphCtx.bindColorTexture(0, 3, info.m_gbufferRenderTargets[0]);
 		rgraphCtx.bindColorTexture(0, 4, info.m_gbufferRenderTargets[1]);

AnKi/Renderer/TraditionalDeferredShading.h

@@ -46,10 +46,6 @@ public:
 class TraditionalDeferredLightShading : public RendererObject
 {
 public:
-	TraditionalDeferredLightShading(Renderer* r);
-
-	~TraditionalDeferredLightShading();
-
 	Error init();
 
 	/// Run the light shading. It will iterate over the lights and draw them. It doesn't bind anything related to

AnKi/Renderer/UiStage.cpp

@@ -12,21 +12,12 @@
 
 namespace anki {
 
-UiStage::UiStage(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-UiStage::~UiStage()
-{
-}
-
 Error UiStage::init()
 {
 	ANKI_CHECK(
 		UiManager::getSingleton().newInstance(m_font, "EngineAssets/UbuntuRegular.ttf", Array<U32, 3>{12, 16, 20}));
-	ANKI_CHECK(UiManager::getSingleton().newInstance(m_canvas, m_font, 12, m_r->getPostProcessResolution().x(),
-													 m_r->getPostProcessResolution().y()));
+	ANKI_CHECK(UiManager::getSingleton().newInstance(m_canvas, m_font, 12, getRenderer().getPostProcessResolution().x(),
+													 getRenderer().getPostProcessResolution().y()));
 
 	return Error::kNone;
 }

AnKi/Renderer/UiStage.h

@@ -7,6 +7,7 @@
 
 #include <AnKi/Renderer/RendererObject.h>
 #include <AnKi/Ui/Canvas.h>
+#include <AnKi/Ui/Font.h>
 
 namespace anki {
 
@@ -17,9 +18,6 @@ namespace anki {
 class UiStage : public RendererObject
 {
 public:
-	UiStage(Renderer* r);
-	~UiStage();
-
 	Error init();
 
 	void draw(U32 width, U32 height, RenderingContext& ctx, CommandBufferPtr& cmdb);

AnKi/Renderer/VolumetricFog.cpp

@@ -19,11 +19,11 @@ Error VolumetricFog::init()
 	// Misc
 	const F32 qualityXY = ConfigSet::getSingleton().getRVolumetricLightingAccumulationQualityXY();
 	const F32 qualityZ = ConfigSet::getSingleton().getRVolumetricLightingAccumulationQualityZ();
-	m_finalZSplit =
-		min(m_r->getZSplitCount() - 1, ConfigSet::getSingleton().getRVolumetricLightingAccumulationFinalZSplit());
+	m_finalZSplit = min(getRenderer().getZSplitCount() - 1,
+						ConfigSet::getSingleton().getRVolumetricLightingAccumulationFinalZSplit());
 
-	m_volumeSize[0] = U32(F32(m_r->getTileCounts().x()) * qualityXY);
-	m_volumeSize[1] = U32(F32(m_r->getTileCounts().y()) * qualityXY);
+	m_volumeSize[0] = U32(F32(getRenderer().getTileCounts().x()) * qualityXY);
+	m_volumeSize[1] = U32(F32(getRenderer().getTileCounts().y()) * qualityXY);
 	m_volumeSize[2] = U32(F32(m_finalZSplit + 1) * qualityZ);
 
 	ANKI_R_LOGV("Initializing volumetric fog. Resolution %ux%ux%u", m_volumeSize[0], m_volumeSize[1], m_volumeSize[2]);
@@ -40,8 +40,8 @@ Error VolumetricFog::init()
 	m_workgroupSize[1] = variant->getWorkgroupSizes()[1];
 
 	// RT descr
-	m_rtDescr =
-		m_r->create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat, "Fog");
+	m_rtDescr = getRenderer().create2DRenderTargetDescription(m_volumeSize[0], m_volumeSize[1],
+															  Format::kR16G16B16A16_Sfloat, "Fog");
 	m_rtDescr.m_depth = m_volumeSize[2];
 	m_rtDescr.m_type = TextureType::k3D;
 	m_rtDescr.bake();
@@ -58,15 +58,16 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 	ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("Vol fog");
 
 	pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
-	pass.newTextureDependency(m_r->getVolumetricLightingAccumulation().getRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(getRenderer().getVolumetricLightingAccumulation().getRt(),
+							  TextureUsageBit::kSampledCompute);
 
 	pass.setWork([this, &ctx](RenderPassWorkContext& rgraphCtx) -> void {
 		CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 		cmdb->bindShaderProgram(m_grProg);
 
-		cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
-		rgraphCtx.bindColorTexture(0, 1, m_r->getVolumetricLightingAccumulation().getRt());
+		cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearClamp);
+		rgraphCtx.bindColorTexture(0, 1, getRenderer().getVolumetricLightingAccumulation().getRt());
 
 		rgraphCtx.bindImage(0, 2, m_runCtx.m_rt, TextureSubresourceInfo());
 
@@ -77,7 +78,7 @@ void VolumetricFog::populateRenderGraph(RenderingContext& ctx)
 		regs.m_fogAbsorptionCoeff = el.m_fog.m_absorptionCoeff;
 		regs.m_near = ctx.m_renderQueue->m_cameraNear;
 		regs.m_far = ctx.m_renderQueue->m_cameraFar;
-		regs.m_zSplitCountf = F32(m_r->getZSplitCount());
+		regs.m_zSplitCountf = F32(getRenderer().getZSplitCount());
 		regs.m_volumeSize = UVec3(m_volumeSize);
 		regs.m_maxZSplitsToProcessf = F32(m_finalZSplit + 1);
 

AnKi/Renderer/VolumetricFog.h

@@ -16,15 +16,6 @@ namespace anki {
 class VolumetricFog : public RendererObject
 {
 public:
-	VolumetricFog(Renderer* r)
-		: RendererObject(r)
-	{
-	}
-
-	~VolumetricFog()
-	{
-	}
-
 	Error init();
 
 	/// Populate the rendergraph.

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -14,31 +14,23 @@
 
 namespace anki {
 
-VolumetricLightingAccumulation::VolumetricLightingAccumulation(Renderer* r)
-	: RendererObject(r)
-{
-}
-
-VolumetricLightingAccumulation::~VolumetricLightingAccumulation()
-{
-}
-
 Error VolumetricLightingAccumulation::init()
 {
 	// Misc
 	const F32 qualityXY = ConfigSet::getSingleton().getRVolumetricLightingAccumulationQualityXY();
 	const F32 qualityZ = ConfigSet::getSingleton().getRVolumetricLightingAccumulationQualityZ();
-	m_finalZSplit =
-		min(m_r->getZSplitCount() - 1, ConfigSet::getSingleton().getRVolumetricLightingAccumulationFinalZSplit());
+	m_finalZSplit = min(getRenderer().getZSplitCount() - 1,
+						ConfigSet::getSingleton().getRVolumetricLightingAccumulationFinalZSplit());
 
-	m_volumeSize[0] = U32(F32(m_r->getTileCounts().x()) * qualityXY);
-	m_volumeSize[1] = U32(F32(m_r->getTileCounts().y()) * qualityXY);
+	m_volumeSize[0] = U32(F32(getRenderer().getTileCounts().x()) * qualityXY);
+	m_volumeSize[1] = U32(F32(getRenderer().getTileCounts().y()) * qualityXY);
 	m_volumeSize[2] = U32(F32(m_finalZSplit + 1) * qualityZ);
 	ANKI_R_LOGV("Initializing volumetric lighting accumulation. Size %ux%ux%u", m_volumeSize[0], m_volumeSize[1],
 				m_volumeSize[2]);
 
-	if(!isAligned(m_r->getTileCounts().x(), m_volumeSize[0]) || !isAligned(m_r->getTileCounts().y(), m_volumeSize[1])
-	   || m_volumeSize[0] == 0 || m_volumeSize[1] == 0 || m_volumeSize[2] == 0)
+	if(!isAligned(getRenderer().getTileCounts().x(), m_volumeSize[0])
+	   || !isAligned(getRenderer().getTileCounts().y(), m_volumeSize[1]) || m_volumeSize[0] == 0 || m_volumeSize[1] == 0
+	   || m_volumeSize[2] == 0)
 	{
 		ANKI_R_LOGE("Wrong input");
 		return Error::kUserData;
@@ -59,15 +51,15 @@ Error VolumetricLightingAccumulation::init()
 	m_workgroupSize = variant->getWorkgroupSizes();
 
 	// Create RTs
-	TextureInitInfo texinit =
-		m_r->create2DRenderTargetInitInfo(m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
-										  TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite
-											  | TextureUsageBit::kSampledFragment | TextureUsageBit::kSampledCompute,
-										  "VolLight");
+	TextureInitInfo texinit = getRenderer().create2DRenderTargetInitInfo(
+		m_volumeSize[0], m_volumeSize[1], Format::kR16G16B16A16_Sfloat,
+		TextureUsageBit::kImageComputeRead | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kSampledFragment
+			| TextureUsageBit::kSampledCompute,
+		"VolLight");
 	texinit.m_depth = m_volumeSize[2];
 	texinit.m_type = TextureType::k3D;
-	m_rtTextures[0] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
-	m_rtTextures[1] = m_r->createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+	m_rtTextures[0] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
+	m_rtTextures[1] = getRenderer().createAndClearRenderTarget(texinit, TextureUsageBit::kSampledFragment);
 
 	return Error::kNone;
 }
@@ -76,7 +68,7 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 {
 	RenderGraphDescription& rgraph = ctx.m_renderGraphDescr;
 
-	const U readRtIdx = m_r->getFrameCount() & 1;
+	const U readRtIdx = getRenderer().getFrameCount() & 1;
 
 	m_runCtx.m_rts[0] = rgraph.importRenderTarget(m_rtTextures[readRtIdx], TextureUsageBit::kSampledFragment);
 	m_runCtx.m_rts[1] = rgraph.importRenderTarget(m_rtTextures[!readRtIdx], TextureUsageBit::kNone);
@@ -89,14 +81,14 @@ void VolumetricLightingAccumulation::populateRenderGraph(RenderingContext& ctx)
 
 	pass.newTextureDependency(m_runCtx.m_rts[0], TextureUsageBit::kSampledCompute);
 	pass.newTextureDependency(m_runCtx.m_rts[1], TextureUsageBit::kImageComputeWrite);
-	pass.newTextureDependency(m_r->getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
+	pass.newTextureDependency(getRenderer().getShadowMapping().getShadowmapRt(), TextureUsageBit::kSampledCompute);
 
-	pass.newBufferDependency(m_r->getClusterBinning().getClustersRenderGraphHandle(),
+	pass.newBufferDependency(getRenderer().getClusterBinning().getClustersRenderGraphHandle(),
 							 BufferUsageBit::kStorageComputeRead);
 
-	if(m_r->getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
+	if(getRenderer().getIndirectDiffuseProbes().hasCurrentlyRefreshedVolumeRt())
 	{
-		pass.newTextureDependency(m_r->getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(),
+		pass.newTextureDependency(getRenderer().getIndirectDiffuseProbes().getCurrentlyRefreshedVolumeRt(),
 								  TextureUsageBit::kSampledCompute);
 	}
 }
@@ -108,9 +100,9 @@ void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPass
 	cmdb->bindShaderProgram(m_grProg);
 
 	// Bind all
-	cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearRepeat);
-	cmdb->bindSampler(0, 1, m_r->getSamplers().m_trilinearClamp);
-	cmdb->bindSampler(0, 2, m_r->getSamplers().m_trilinearClampShadow);
+	cmdb->bindSampler(0, 0, getRenderer().getSamplers().m_trilinearRepeat);
+	cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(0, 2, getRenderer().getSamplers().m_trilinearClampShadow);
 
 	rgraphCtx.bindImage(0, 3, m_runCtx.m_rts[1], TextureSubresourceInfo());
 
@@ -118,17 +110,19 @@ void VolumetricLightingAccumulation::run(const RenderingContext& ctx, RenderPass
 
 	rgraphCtx.bindColorTexture(0, 5, m_runCtx.m_rts[0]);
 
-	bindUniforms(cmdb, 0, 6, m_r->getClusterBinning().getClusteredUniformsRebarToken());
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 7, ClusteredObjectType::kPointLight);
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 8, ClusteredObjectType::kSpotLight);
-	rgraphCtx.bindColorTexture(0, 9, m_r->getShadowMapping().getShadowmapRt());
+	bindUniforms(cmdb, 0, 6, getRenderer().getClusterBinning().getClusteredUniformsRebarToken());
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 7,
+																			 ClusteredObjectType::kPointLight);
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 8,
+																			 ClusteredObjectType::kSpotLight);
+	rgraphCtx.bindColorTexture(0, 9, getRenderer().getShadowMapping().getShadowmapRt());
 
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 10,
-																	ClusteredObjectType::kGlobalIlluminationProbe);
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(
+		cmdb, 0, 10, ClusteredObjectType::kGlobalIlluminationProbe);
 
-	m_r->getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 11,
-																	ClusteredObjectType::kFogDensityVolume);
-	bindStorage(cmdb, 0, 12, m_r->getClusterBinning().getClustersRebarToken());
+	getRenderer().getPackVisibleClusteredObjects().bindClusteredObjectBuffer(cmdb, 0, 11,
+																			 ClusteredObjectType::kFogDensityVolume);
+	bindStorage(cmdb, 0, 12, getRenderer().getClusterBinning().getClustersRebarToken());
 
 	cmdb->bindAllBindless(1);
 

AnKi/Renderer/VolumetricLightingAccumulation.h

@@ -16,9 +16,6 @@ namespace anki {
 class VolumetricLightingAccumulation : public RendererObject
 {
 public:
-	VolumetricLightingAccumulation(Renderer* r);
-	~VolumetricLightingAccumulation();
-
 	Error init();
 
 	/// Populate the rendergraph.

AnKi/Renderer/VrsSriGeneration.cpp

@@ -10,17 +10,6 @@
 
 namespace anki {
 
-VrsSriGeneration::VrsSriGeneration(Renderer* r)
-	: RendererObject(r)
-{
-	registerDebugRenderTarget("VrsSri");
-	registerDebugRenderTarget("VrsSriDownscaled");
-}
-
-VrsSriGeneration::~VrsSriGeneration()
-{
-}
-
 Error VrsSriGeneration::init()
 {
 	const Error err = initInternal();
@@ -40,7 +29,7 @@ Error VrsSriGeneration::initInternal()
 
 	m_sriTexelDimension = GrManager::getSingleton().getDeviceCapabilities().m_minShadingRateImageTexelSize;
 	ANKI_ASSERT(m_sriTexelDimension == 8 || m_sriTexelDimension == 16);
-	const UVec2 rez = (m_r->getInternalResolution() + m_sriTexelDimension - 1) / m_sriTexelDimension;
+	const UVec2 rez = (getRenderer().getInternalResolution() + m_sriTexelDimension - 1) / m_sriTexelDimension;
 
 	ANKI_R_LOGV("Intializing VRS SRI generation. SRI resolution %ux%u", rez.x(), rez.y());
 
@@ -48,13 +37,15 @@ Error VrsSriGeneration::initInternal()
 	const TextureUsageBit texUsage =
 		TextureUsageBit::kFramebufferShadingRate | TextureUsageBit::kImageComputeWrite | TextureUsageBit::kAllSampled;
 	TextureInitInfo sriInitInfo =
-		m_r->create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
-	m_sriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
+		getRenderer().create2DRenderTargetInitInfo(rez.x(), rez.y(), Format::kR8_Uint, texUsage, "VrsSri");
+	m_sriTex = getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
-	const UVec2 rezDownscaled = (m_r->getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
-	sriInitInfo = m_r->create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8_Uint, texUsage,
-													"VrsSriDownscaled");
-	m_downscaledSriTex = m_r->createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
+	const UVec2 rezDownscaled =
+		(getRenderer().getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
+	sriInitInfo = getRenderer().create2DRenderTargetInitInfo(rezDownscaled.x(), rezDownscaled.y(), Format::kR8_Uint,
+															 texUsage, "VrsSriDownscaled");
+	m_downscaledSriTex =
+		getRenderer().createAndClearRenderTarget(sriInitInfo, TextureUsageBit::kFramebufferShadingRate);
 
 	// Load programs
 	ANKI_CHECK(
@@ -153,23 +144,23 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 		ComputeRenderPassDescription& pass = rgraph.newComputeRenderPass("VRS SRI generation");
 
 		pass.newTextureDependency(m_runCtx.m_rt, TextureUsageBit::kImageComputeWrite);
-		pass.newTextureDependency(m_r->getLightShading().getRt(), TextureUsageBit::kSampledCompute);
+		pass.newTextureDependency(getRenderer().getLightShading().getRt(), TextureUsageBit::kSampledCompute);
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 			cmdb->bindShaderProgram(m_grProg);
 
-			rgraphCtx.bindColorTexture(0, 0, m_r->getLightShading().getRt());
-			cmdb->bindSampler(0, 1, m_r->getSamplers().m_nearestNearestClamp);
+			rgraphCtx.bindColorTexture(0, 0, getRenderer().getLightShading().getRt());
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_rt);
-			const Vec4 pc(1.0f / Vec2(m_r->getInternalResolution()), ConfigSet::getSingleton().getRVrsThreshold(),
-						  0.0f);
+			const Vec4 pc(1.0f / Vec2(getRenderer().getInternalResolution()),
+						  ConfigSet::getSingleton().getRVrsThreshold(), 0.0f);
 			cmdb->setPushConstants(&pc, sizeof(pc));
 
 			const U32 fakeWorkgroupSizeXorY = m_sriTexelDimension;
-			dispatchPPCompute(cmdb, fakeWorkgroupSizeXorY, fakeWorkgroupSizeXorY, m_r->getInternalResolution().x(),
-							  m_r->getInternalResolution().y());
+			dispatchPPCompute(cmdb, fakeWorkgroupSizeXorY, fakeWorkgroupSizeXorY,
+							  getRenderer().getInternalResolution().x(), getRenderer().getInternalResolution().y());
 		});
 	}
 
@@ -182,14 +173,14 @@ void VrsSriGeneration::populateRenderGraph(RenderingContext& ctx)
 
 		pass.setWork([this](RenderPassWorkContext& rgraphCtx) {
 			const UVec2 rezDownscaled =
-				(m_r->getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
+				(getRenderer().getInternalResolution() / 2 + m_sriTexelDimension - 1) / m_sriTexelDimension;
 
 			CommandBufferPtr& cmdb = rgraphCtx.m_commandBuffer;
 
 			cmdb->bindShaderProgram(m_downscaleGrProg);
 
 			rgraphCtx.bindColorTexture(0, 0, m_runCtx.m_rt);
-			cmdb->bindSampler(0, 1, m_r->getSamplers().m_nearestNearestClamp);
+			cmdb->bindSampler(0, 1, getRenderer().getSamplers().m_nearestNearestClamp);
 			rgraphCtx.bindImage(0, 2, m_runCtx.m_downscaledRt);
 			const Vec4 pc(1.0f / Vec2(rezDownscaled), 0.0f, 0.0f);
 			cmdb->setPushConstants(&pc, sizeof(pc));

AnKi/Renderer/VrsSriGeneration.h

@@ -16,8 +16,11 @@ namespace anki {
 class VrsSriGeneration : public RendererObject
 {
 public:
-	VrsSriGeneration(Renderer* r);
-	~VrsSriGeneration();
+	VrsSriGeneration()
+	{
+		registerDebugRenderTarget("VrsSri");
+		registerDebugRenderTarget("VrsSriDownscaled");
+	}
 
 	Error init();
 

AnKi/Scene/Octree.h

@@ -91,8 +91,10 @@ public:
 	template<typename TTestAabbFunc, typename TNewPlaceableFunc>
 	void walkTree(U32 testId, TTestAabbFunc testFunc, TNewPlaceableFunc newPlaceableFunc)
 	{
-		ANKI_ASSERT(m_rootLeaf);
-		walkTreeInternal(*m_rootLeaf, testId, testFunc, newPlaceableFunc);
+		if(m_rootLeaf) [[likely]]
+		{
+			walkTreeInternal(*m_rootLeaf, testId, testFunc, newPlaceableFunc);
+		}
 	}
 
 	/// Debug draw.

AnKi/Scene/SceneGraph.cpp

@@ -49,8 +49,6 @@ SceneGraph::~SceneGraph()
 	}
 
 	m_gpuSceneAllocators.destroy();
-
-	SceneMemoryPool::freeSingleton();
 }
 
 Error SceneGraph::init(AllocAlignedCallback allocCallback, void* allocCallbackData)

AnKi/Scene/SceneGraph.h

@@ -161,6 +161,15 @@ public:
 private:
 	class UpdateSceneNodesCtx;
 
+	class InitMemPoolDummy
+	{
+	public:
+		~InitMemPoolDummy()
+		{
+			SceneMemoryPool::freeSingleton();
+		}
+	} m_initMemPoolDummy;
+
 	mutable StackMemoryPool m_framePool;
 
 	IntrusiveList<SceneNode> m_nodes;

AnKi/Scene/Visibility.cpp

@@ -660,12 +660,23 @@ void CombineResultsTask::combine()
 	// Compute the timestamp
 	const U32 threadCount = m_frcCtx->m_queueViews.getSize();
 	results.m_shadowRenderablesLastUpdateTimestamp = 0;
+	U32 renderableCount = 0;
 	for(U32 i = 0; i < threadCount; ++i)
 	{
 		results.m_shadowRenderablesLastUpdateTimestamp =
 			max(results.m_shadowRenderablesLastUpdateTimestamp, m_frcCtx->m_queueViews[i].m_timestamp);
+
+		renderableCount += m_frcCtx->m_queueViews[i].m_renderables.m_elementCount;
+	}
+
+	if(renderableCount)
+	{
+		ANKI_ASSERT(results.m_shadowRenderablesLastUpdateTimestamp);
+	}
+	else
+	{
+		ANKI_ASSERT(results.m_shadowRenderablesLastUpdateTimestamp == 0);
 	}
-	ANKI_ASSERT(results.m_shadowRenderablesLastUpdateTimestamp);
 
 #define ANKI_VIS_COMBINE(t_, member_) \
 	{ \

AnKi/Script/Renderer.cpp

@@ -16,9 +16,7 @@ static MainRenderer* getMainRenderer(lua_State* l)
 	LuaBinder* binder = nullptr;
 	lua_getallocf(l, reinterpret_cast<void**>(&binder));
 
-	MainRenderer* r = nullptr; // TODO glob: fix it
-	ANKI_ASSERT(r);
-	return r;
+	return &MainRenderer::getSingleton();
 }
 
 LuaUserDataTypeInfo luaUserDataTypeInfoMainRenderer = {-6365712250974230727, "MainRenderer",

AnKi/Util/MemoryPool.h

@@ -418,6 +418,17 @@ public:
 	}
 };
 
+template<typename TMemoryPool>
+class SingletonMemoryPoolDeleter
+{
+public:
+	template<typename T>
+	void operator()(T* x)
+	{
+		deleteInstance<T>(TMemoryPool::getSingleton(), x);
+	}
+};
+
 inline void* BaseMemoryPool::allocate(PtrSize size, PtrSize alignmentBytes)
 {
 	void* out = nullptr;

Samples/Common/SampleApp.cpp

@@ -47,7 +47,7 @@ Error SampleApp::userMainLoop(Bool& quit, Second elapsedTime)
 	quit = false;
 
 	SceneGraph& scene = SceneGraph::getSingleton();
-	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
+	Renderer& renderer = MainRenderer::getSingleton().getOffscreenRenderer();
 	Input& in = Input::getSingleton();
 
 	if(in.getKey(KeyCode::kEscape))

Samples/PhysicsPlayground/Main.cpp

@@ -152,7 +152,7 @@ Error MyApp::sampleExtraInit()
 		{
 			SceneNode* monkey;
 			ANKI_CHECK(SceneGraph::getSingleton().newSceneNode(
-				StringRaii(&getMemoryPool()).sprintf("monkey_chain%u", i).toCString(), monkey));
+				StringRaii(&DefaultMemoryPool::getSingleton()).sprintf("monkey_chain%u", i).toCString(), monkey));
 			monkey->newComponent<ModelComponent>()->loadModelResource(
 				"Assets/Suzanne_dynamic_36043dae41fe12d5.ankimdl");
 
@@ -202,7 +202,7 @@ Error MyApp::sampleExtraInit()
 Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 {
 	// ANKI_CHECK(SampleApp::userMainLoop(quit));
-	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
+	Renderer& renderer = MainRenderer::getSingleton().getOffscreenRenderer();
 
 	if(Input::getSingleton().getKey(KeyCode::kEscape))
 	{
@@ -259,14 +259,14 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 		else if(mode == 1)
 		{
 			ConfigSet::getSingleton().setRDbg(true);
-			getMainRenderer().getDbg().setDepthTestEnabled(true);
-			getMainRenderer().getDbg().setDitheredDepthTestEnabled(false);
+			MainRenderer::getSingleton().getDbg().setDepthTestEnabled(true);
+			MainRenderer::getSingleton().getDbg().setDitheredDepthTestEnabled(false);
 		}
 		else
 		{
 			ConfigSet::getSingleton().setRDbg(true);
-			getMainRenderer().getDbg().setDepthTestEnabled(false);
-			getMainRenderer().getDbg().setDitheredDepthTestEnabled(true);
+			MainRenderer::getSingleton().getDbg().setDepthTestEnabled(false);
+			MainRenderer::getSingleton().getDbg().setDitheredDepthTestEnabled(true);
 		}
 	}
 
@@ -344,7 +344,7 @@ Error MyApp::userMainLoop(Bool& quit, [[maybe_unused]] Second elapsedTime)
 
 		SceneNode* monkey;
 		ANKI_CHECK(SceneGraph::getSingleton().newSceneNode(
-			StringRaii(&getMemoryPool()).sprintf("FireMonkey%u", instance++).toCString(), monkey));
+			StringRaii(&DefaultMemoryPool::getSingleton()).sprintf("FireMonkey%u", instance++).toCString(), monkey));
 		ModelComponent* modelc = monkey->newComponent<ModelComponent>();
 		modelc->loadModelResource("Assets/Suzanne_dynamic_36043dae41fe12d5.ankimdl");
 		// monkey->getFirstComponentOfType<MoveComponent>().setLocalTransform(camTrf);

Sandbox/Main.cpp

@@ -89,7 +89,7 @@ Error MyApp::userMainLoop(Bool& quit, Second elapsedTime)
 
 	SceneGraph& scene = SceneGraph::getSingleton();
 	Input& in = Input::getSingleton();
-	Renderer& renderer = getMainRenderer().getOffscreenRenderer();
+	Renderer& renderer = MainRenderer::getSingleton().getOffscreenRenderer();
 
 	if(in.getKey(KeyCode::kEscape))
 	{

Tests/Renderer/TileAllocator.cpp

@@ -8,10 +8,8 @@
 
 ANKI_TEST(Renderer, TileAllocator)
 {
-	HeapMemoryPool pool(allocAligned, nullptr);
-
 	TileAllocator talloc;
-	talloc.init(&pool, 8, 8, 3, true);
+	talloc.init(8, 8, 3, true);
 
 	Array<U32, 4> viewport;
 	TileAllocatorResult res;

Tools/Image/ImageViewerMain.cpp

@@ -313,7 +313,8 @@ public:
 	}
 };
 
-int main(int argc, char* argv[])
+ANKI_MAIN_FUNCTION(myMain)
+int myMain(int argc, char* argv[])
 {
 	Error err = Error::kNone;
 

Tools/Shader/ShaderProgramCompilerMain.cpp

@@ -215,7 +215,8 @@ static Error work(const CmdLineArgs& info)
 	return Error::kNone;
 }
 
-int main(int argc, char** argv)
+ANKI_MAIN_FUNCTION(myMain)
+int myMain(int argc, char** argv)
 {
 	CmdLineArgs info;
 	if(parseCommandLineArgs(argc, argv, info))