Fix bugs

AnKi/Core/App.cpp

@@ -168,6 +168,8 @@ Error App::init(ConfigSet* config, AllocAlignedCallback allocCb, void* allocCbUs
 
 Error App::initInternal(AllocAlignedCallback allocCb, void* allocCbUserData)
 {
+	LoggerSingleton::get().enableVerbosity(m_config->getCoreVerboseLog());
+
 	setSignalHandlers();
 
 	Thread::setNameOfCurrentThread("anki_main");

AnKi/Core/ConfigSet.cpp

@@ -41,7 +41,7 @@ void ConfigSet::init(AllocAlignedCallback allocCb, void* allocCbUserData)
 	m_##name.m_description = description; \
 	m_##name.m_value = defaultValue; \
 	m_##name.m_min = minValue; \
-	m_##name.m_max = minValue; \
+	m_##name.m_max = maxValue; \
 	m_vars.pushBack(&m_##name);
 
 #define ANKI_CONFIG_VAR_U8(name, defaultValue, minValue, maxValue, description) \
@@ -215,16 +215,18 @@ Error ConfigSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLine
 		{
 		}
 
-#define ANKI_NUMERIC(name) \
+#define ANKI_NUMERIC(type, name) \
 	else if(varName == m_##name.m_name) \
 	{ \
-		ANKI_CHECK(value.toNumber(m_##name.m_value)); \
+		type v; \
+		ANKI_CHECK(value.toNumber(v)); \
+		set##name(v); \
 	}
 
-#define ANKI_CONFIG_VAR_U8(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(name)
-#define ANKI_CONFIG_VAR_U32(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(name)
-#define ANKI_CONFIG_VAR_PTR_SIZE(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(name)
-#define ANKI_CONFIG_VAR_F32(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(name)
+#define ANKI_CONFIG_VAR_U8(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(U8, name)
+#define ANKI_CONFIG_VAR_U32(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(U32, name)
+#define ANKI_CONFIG_VAR_PTR_SIZE(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(PtrSize, name)
+#define ANKI_CONFIG_VAR_F32(name, defaultValue, minValue, maxValue, description) ANKI_NUMERIC(F32, name)
 
 #define ANKI_CONFIG_VAR_BOOL(name, defaultValue, description) \
 	else if(varName == m_##name.m_name) \

AnKi/Core/ConfigVars.defs.h

@@ -21,3 +21,4 @@ ANKI_CONFIG_VAR_U32(CoreTargetFps, 60u, 30u, MAX_U32, "Target FPS")
 ANKI_CONFIG_VAR_U32(CoreJobThreadCount, max(2u, getCpuCoresCount() / 2u), 2u, 1024u, "Number of job thread")
 ANKI_CONFIG_VAR_BOOL(CoreDisplayStats, false, "Display stats")
 ANKI_CONFIG_VAR_BOOL(CoreClearCaches, false, "Clear all caches")
+ANKI_CONFIG_VAR_BOOL(CoreVerboseLog, false, "Verbose logging")

AnKi/Gr/Vulkan/Common.h

@@ -38,6 +38,7 @@ class GrManagerImpl;
 #define ANKI_VK_LOGE(...) ANKI_LOG("VK  ", ERROR, __VA_ARGS__)
 #define ANKI_VK_LOGW(...) ANKI_LOG("VK  ", WARNING, __VA_ARGS__)
 #define ANKI_VK_LOGF(...) ANKI_LOG("VK  ", FATAL, __VA_ARGS__)
+#define ANKI_VK_LOGV(...) ANKI_LOG("VK  ", VERBOSE, __VA_ARGS__)
 
 #define ANKI_VK_SELF(class_) class_& self = *static_cast<class_*>(this)
 #define ANKI_VK_SELF_CONST(class_) const class_& self = *static_cast<const class_*>(this)

AnKi/Gr/Vulkan/GrManagerImpl.cpp

@@ -323,10 +323,10 @@ Error GrManagerImpl::initInstance(const GrManagerInitInfo& init)
 		instExtensionInf.create(extCount);
 		vkEnumerateInstanceExtensionProperties(nullptr, &extCount, &instExtensionInf[0]);
 
-		ANKI_VK_LOGI("Found the following instance extensions:");
+		ANKI_VK_LOGV("Found the following instance extensions:");
 		for(U32 i = 0; i < extCount; ++i)
 		{
-			ANKI_VK_LOGI("\t%s", instExtensionInf[i].extensionName);
+			ANKI_VK_LOGV("\t%s", instExtensionInf[i].extensionName);
 		}
 
 		U32 instExtensionCount = 0;
@@ -609,10 +609,10 @@ Error GrManagerImpl::initDevice(const GrManagerInitInfo& init)
 		U32 extensionsToEnableCount = 0;
 		vkEnumerateDeviceExtensionProperties(m_physicalDevice, nullptr, &extCount, &extensionInfos[0]);
 
-		ANKI_VK_LOGI("Found the following device extensions:");
+		ANKI_VK_LOGV("Found the following device extensions:");
 		for(U32 i = 0; i < extCount; ++i)
 		{
-			ANKI_VK_LOGI("\t%s", extensionInfos[i].extensionName);
+			ANKI_VK_LOGV("\t%s", extensionInfos[i].extensionName);
 		}
 
 		while(extCount-- != 0)

AnKi/Renderer/Bloom.cpp

@@ -21,6 +21,17 @@ Bloom::~Bloom()
 {
 }
 
+Error Bloom::initInternal()
+{
+	ANKI_R_LOGV("Initializing bloom");
+
+	ANKI_CHECK(initExposure());
+	ANKI_CHECK(initUpscale());
+	m_fbDescr.m_colorAttachmentCount = 1;
+	m_fbDescr.bake();
+	return Error::NONE;
+}
+
 Error Bloom::initExposure()
 {
 	m_exposure.m_width = m_r->getDownscaleBlur().getPassWidth(MAX_U32) * 2;

AnKi/Renderer/Bloom.h

@@ -82,14 +82,7 @@ private:
 	ANKI_USE_RESULT Error initExposure();
 	ANKI_USE_RESULT Error initUpscale();
 
-	ANKI_USE_RESULT Error initInternal()
-	{
-		ANKI_CHECK(initExposure());
-		ANKI_CHECK(initUpscale());
-		m_fbDescr.m_colorAttachmentCount = 1;
-		m_fbDescr.bake();
-		return Error::NONE;
-	}
+	ANKI_USE_RESULT Error initInternal();
 };
 
 /// @}

AnKi/Renderer/ClusterBinning.cpp

@@ -27,7 +27,7 @@ ClusterBinning::~ClusterBinning()
 
 Error ClusterBinning::init()
 {
-	ANKI_R_LOGI("Initializing clusterer binning");
+	ANKI_R_LOGV("Initializing clusterer binning");
 
 	ANKI_CHECK(getResourceManager().loadResource("Shaders/ClusterBinning.ankiprog", m_prog));
 

AnKi/Renderer/Common.h

@@ -17,6 +17,7 @@ namespace anki {
 #define ANKI_R_LOGE(...) ANKI_LOG("R   ", ERROR, __VA_ARGS__)
 #define ANKI_R_LOGW(...) ANKI_LOG("R   ", WARNING, __VA_ARGS__)
 #define ANKI_R_LOGF(...) ANKI_LOG("R   ", FATAL, __VA_ARGS__)
+#define ANKI_R_LOGV(...) ANKI_LOG("R   ", VERBOSE, __VA_ARGS__)
 
 // Forward
 #define ANKI_RENDERER_OBJECT_DEF(a, b) class a;

AnKi/Renderer/ConfigVars.defs.h

@@ -12,7 +12,7 @@ ANKI_CONFIG_VAR_BOOL(RPreferCompute, !ANKI_OS_ANDROID, "Prefer compute shaders")
 
 ANKI_CONFIG_VAR_F32(RInternalRenderScaling, 1.0f, 0.5f, 1.0f,
 					"A factor over the requested swapchain resolution. Applies to all passes up to TAA")
-ANKI_CONFIG_VAR_F32(RRenderScaling, 1.0f, 0.5f, 1.0f,
+ANKI_CONFIG_VAR_F32(RRenderScaling, 1.0f, 0.5f, 8.0f,
 					"A factor over the requested swapchain resolution. Applies to post-processing and UI")
 
 ANKI_CONFIG_VAR_F32(RVolumetricLightingAccumulationQualityXY, 4.0f, 1.0f, 16.0f,
@@ -47,7 +47,7 @@ ANKI_CONFIG_VAR_U32(RProbeRefectionMaxCachedProbes, 32, 4, 256, "Max cached numb
 ANKI_CONFIG_VAR_U32(RProbeReflectionShadowMapResolution, 64, 4, 2048, "Reflection probe shadow resolution")
 
 ANKI_CONFIG_VAR_U8(RLensFlareMaxSpritesPerFlare, 8, 4, 255, "Max sprites per lens flare")
-ANKI_CONFIG_VAR_U8(RLensFlareMaxFlares, 16, 8, 256, "Max flare count")
+ANKI_CONFIG_VAR_U8(RLensFlareMaxFlares, 16, 8, 255, "Max flare count")
 
 ANKI_CONFIG_VAR_U32(RGiTileResolution, (ANKI_OS_ANDROID) ? 16 : 32, 4, 2048, "GI tile resolution")
 ANKI_CONFIG_VAR_U32(RGiShadowMapResolution, 128, 4, 2048, "GI shadowmap resolution")

AnKi/Renderer/Dbg.cpp

@@ -28,6 +28,8 @@ Dbg::~Dbg()
 
 Error Dbg::init()
 {
+	ANKI_R_LOGV("Initializing DBG");
+
 	// RT descr
 	m_rtDescr = m_r->create2DRenderTargetDescription(m_r->getInternalResolution().x(), m_r->getInternalResolution().y(),
 													 DBG_COLOR_ATTACHMENT_PIXEL_FORMAT, "Dbg");

AnKi/Renderer/DepthDownscale.cpp

@@ -39,7 +39,7 @@ Error DepthDownscale::initInternal()
 	m_lastMipSize.x() = width >> (m_mipCount - 1);
 	m_lastMipSize.y() = height >> (m_mipCount - 1);
 
-	ANKI_R_LOGI("Initializing HiZ. Mip count %u, last mip size %ux%u", m_mipCount, m_lastMipSize.x(),
+	ANKI_R_LOGV("Initializing HiZ. Mip count %u, last mip size %ux%u", m_mipCount, m_lastMipSize.x(),
 				m_lastMipSize.y());
 
 	const Bool supportsReductionSampler = getGrManager().getDeviceCapabilities().m_samplingFilterMinMax;

AnKi/Renderer/DownscaleBlur.cpp

@@ -32,12 +32,14 @@ Error DownscaleBlur::initInternal()
 										  DOWNSCALE_BLUR_DOWN_TO)
 				  - 1;
 
+	const UVec2 rez = m_r->getPostProcessResolution() / 2;
+	ANKI_R_LOGV("Initializing downscale pyramid. Resolution %ux%u, mip count %u", rez.x(), rez.y(), m_passCount);
+
 	const Bool preferCompute = getConfig().getRPreferCompute();
 
 	// Create the miped texture
 	TextureInitInfo texinit = m_r->create2DRenderTargetDescription(
-		m_r->getPostProcessResolution().x() / 2, m_r->getPostProcessResolution().y() / 2,
-		LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT, "DownscaleBlur");
+		rez.x(), rez.y(), LIGHT_SHADING_COLOR_ATTACHMENT_PIXEL_FORMAT, "DownscaleBlur");
 	texinit.m_usage = TextureUsageBit::SAMPLED_FRAGMENT | TextureUsageBit::SAMPLED_COMPUTE;
 	if(preferCompute)
 	{

AnKi/Renderer/FinalComposite.cpp

@@ -30,6 +30,8 @@ FinalComposite::~FinalComposite()
 
 Error FinalComposite::initInternal()
 {
+	ANKI_R_LOGV("Initializing final composite");
+
 	ANKI_CHECK(loadColorGradingTextureImage("EngineAssets/DefaultLut.ankitex"));
 
 	m_fbDescr.m_colorAttachmentCount = 1;
@@ -99,17 +101,18 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 	});
 	pass.setFramebufferInfo(m_fbDescr, {ctx.m_outRenderTarget});
 
-	pass.newDependency({ctx.m_outRenderTarget, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
+	pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
 
 	if(getConfig().getRDbgEnabled())
 	{
-		pass.newDependency({m_r->getDbg().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+		pass.newDependency(RenderPassDependency(m_r->getDbg().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 	}
 
-	pass.newDependency({m_r->getScale().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getBloom().getRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::SAMPLED_FRAGMENT});
-	pass.newDependency({m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT});
+	pass.newDependency(RenderPassDependency(m_r->getScale().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getBloom().getRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(
+		RenderPassDependency(m_r->getMotionVectors().getMotionVectorsRt(), TextureUsageBit::SAMPLED_FRAGMENT));
+	pass.newDependency(RenderPassDependency(m_r->getGBuffer().getDepthRt(), TextureUsageBit::SAMPLED_FRAGMENT));
 
 	RenderTargetHandle dbgRt;
 	Bool dbgRtValid;
@@ -117,7 +120,7 @@ void FinalComposite::populateRenderGraph(RenderingContext& ctx)
 	m_r->getCurrentDebugRenderTarget(dbgRt, dbgRtValid, debugProgram);
 	if(dbgRtValid)
 	{
-		pass.newDependency({dbgRt, TextureUsageBit::SAMPLED_FRAGMENT});
+		pass.newDependency(RenderPassDependency(dbgRt, TextureUsageBit::SAMPLED_FRAGMENT));
 	}
 }
 

AnKi/Renderer/GBuffer.cpp

@@ -29,6 +29,9 @@ Error GBuffer::init()
 
 Error GBuffer::initInternal()
 {
+	ANKI_R_LOGV("Initializing GBuffer. Resolution %ux%u", m_r->getInternalResolution().x(),
+				m_r->getInternalResolution().y());
+
 	// RTs
 	static const Array<const char*, 2> depthRtNames = {{"GBuffer depth #0", "GBuffer depth #1"}};
 	for(U32 i = 0; i < 2; ++i)

AnKi/Renderer/GBufferPost.cpp

@@ -26,7 +26,7 @@ Error GBufferPost::init()
 
 Error GBufferPost::initInternal()
 {
-	ANKI_R_LOGI("Initializing GBufferPost pass");
+	ANKI_R_LOGV("Initializing GBufferPost pass");
 
 	// Load shaders
 	ANKI_CHECK(getResourceManager().loadResource("Shaders/GBufferPost.ankiprog", m_prog));

AnKi/Renderer/IndirectDiffuse.cpp

@@ -33,6 +33,9 @@ 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");
+
+	ANKI_R_LOGV("Initializing indirect diffuse. Resolution %ux%u", size.x(), size.y());
+
 	const Bool preferCompute = getConfig().getRPreferCompute();
 
 	// Init textures

AnKi/Renderer/LensFlare.cpp

@@ -30,6 +30,8 @@ Error LensFlare::init()
 
 Error LensFlare::initInternal()
 {
+	ANKI_R_LOGV("Initializing lens flare");
+
 	ANKI_CHECK(initSprite());
 	ANKI_CHECK(initOcclusion());
 

AnKi/Renderer/LightShading.cpp

@@ -30,6 +30,8 @@ LightShading::~LightShading()
 
 Error LightShading::init()
 {
+	ANKI_R_LOGV("Initializing light shading");
+
 	Error err = initLightShading();
 
 	if(!err)

AnKi/Renderer/MainRenderer.cpp

@@ -37,9 +37,7 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 
 	// Init renderer and manipulate the width/height
 	m_swapchainResolution = inf.m_swapchainSize;
-	m_renderScaling = inf.m_config->getRRenderScaling();
-
-	m_rDrawToDefaultFb = m_renderScaling == 1.0f;
+	m_rDrawToDefaultFb = inf.m_config->getRRenderScaling() == 1.0f;
 
 	m_r.reset(m_alloc.newInstance<Renderer>());
 	ANKI_CHECK(m_r->init(inf.m_threadHive, inf.m_resourceManager, inf.m_gr, inf.m_stagingMemory, inf.m_ui, m_alloc,
@@ -54,8 +52,7 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 		m_blitGrProg = variant->getProgram();
 
 		// The RT desc
-		const Vec2 fresolution = Vec2(m_swapchainResolution);
-		UVec2 resolution = UVec2(fresolution * m_renderScaling);
+		UVec2 resolution = UVec2(Vec2(m_swapchainResolution) * inf.m_config->getRRenderScaling());
 		alignRoundDown(2, resolution.x());
 		alignRoundDown(2, resolution.y());
 		m_tmpRtDesc = m_r->create2DRenderTargetDescription(resolution.x(), resolution.y(), Format::R8G8B8_UNORM,
@@ -67,12 +64,12 @@ Error MainRenderer::init(const MainRendererInitInfo& inf)
 		m_fbDescr.m_colorAttachments[0].m_loadOperation = AttachmentLoadOperation::DONT_CARE;
 		m_fbDescr.bake();
 
-		ANKI_R_LOGI("The main renderer will have to blit the offscreen renderer's result");
+		ANKI_R_LOGI("There will be a blit pass to the swapchain because render scaling is not 1.0");
 	}
 
 	m_rgraph = inf.m_gr->newRenderGraph();
 
-	ANKI_R_LOGI("Main renderer initialized. Rendering size %ux%u", m_swapchainResolution.x(),
+	ANKI_R_LOGI("Main renderer initialized. Swapchain resolution %ux%u", m_swapchainResolution.x(),
 				m_swapchainResolution.x());
 
 	return Error::NONE;
@@ -108,8 +105,8 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 		// m_r will draw to a temp tex
 
 		ctx.m_outRenderTarget = ctx.m_renderGraphDescr.newRenderTarget(m_tmpRtDesc);
-		ctx.m_outRenderTargetWidth = U32(F32(m_swapchainResolution.x()) * m_renderScaling);
-		ctx.m_outRenderTargetHeight = U32(F32(m_swapchainResolution.y()) * m_renderScaling);
+		ctx.m_outRenderTargetWidth = m_tmpRtDesc.m_width;
+		ctx.m_outRenderTargetHeight = m_tmpRtDesc.m_height;
 	}
 
 	ctx.m_renderQueue = &rqueue;
@@ -129,11 +126,11 @@ Error MainRenderer::render(RenderQueue& rqueue, TexturePtr presentTex)
 			cmdb->bindSampler(0, 0, m_r->getSamplers().m_trilinearClamp);
 			rgraphCtx.bindColorTexture(0, 1, m_runCtx.m_ctx->m_outRenderTarget);
 
-			cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3, 1);
+			cmdb->drawArrays(PrimitiveTopology::TRIANGLES, 3);
 		});
 
-		pass.newDependency({presentRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE});
-		pass.newDependency({ctx.m_outRenderTarget, TextureUsageBit::SAMPLED_FRAGMENT});
+		pass.newDependency(RenderPassDependency(presentRt, TextureUsageBit::FRAMEBUFFER_ATTACHMENT_WRITE));
+		pass.newDependency(RenderPassDependency(ctx.m_outRenderTarget, TextureUsageBit::SAMPLED_FRAGMENT));
 	}
 
 	// Create a dummy pass to transition the presentable image to present

AnKi/Renderer/MainRenderer.h

@@ -93,7 +93,6 @@ private:
 	ShaderProgramPtr m_blitGrProg;
 
 	UVec2 m_swapchainResolution = UVec2(0u);
-	F32 m_renderScaling = 1.0f;
 
 	RenderGraphPtr m_rgraph;
 	RenderTargetDescription m_tmpRtDesc;

AnKi/Renderer/MotionVectors.cpp

@@ -27,6 +27,8 @@ Error MotionVectors::init()
 
 Error MotionVectors::initInternal()
 {
+	ANKI_R_LOGV("Initializing motion vectors");
+
 	// Prog
 	ANKI_CHECK(getResourceManager().loadResource((getConfig().getRPreferCompute())
 													 ? "Shaders/MotionVectorsCompute.ankiprog"

AnKi/Renderer/Renderer.cpp

@@ -83,25 +83,22 @@ Error Renderer::init(ThreadHive* hive, ResourceManager* resources, GrManager* gl
 	return err;
 }
 
-Error Renderer::initInternal(UVec2 swapchainSize)
+Error Renderer::initInternal(UVec2 swapchainResolution)
 {
 	m_frameCount = 0;
 
 	// Set from the config
-	const F32 renderScaling = m_config->getRRenderScaling();
-	const F32 internalRenderScaling = min(m_config->getRInternalRenderScaling(), renderScaling);
-
-	const Vec2 fresolution = Vec2(swapchainSize);
-	m_postProcessResolution = UVec2(fresolution * renderScaling);
+	m_postProcessResolution = UVec2(Vec2(swapchainResolution) * m_config->getRRenderScaling());
 	alignRoundDown(2, m_postProcessResolution.x());
 	alignRoundDown(2, m_postProcessResolution.y());
 
-	m_internalResolution = UVec2(fresolution * internalRenderScaling);
+	m_internalResolution = UVec2(Vec2(m_postProcessResolution) * m_config->getRInternalRenderScaling());
 	alignRoundDown(2, m_internalResolution.x());
 	alignRoundDown(2, m_internalResolution.y());
 
-	ANKI_R_LOGI("Initializing offscreen renderer. Size %ux%u. Internal size %ux%u", m_postProcessResolution.x(),
-				m_postProcessResolution.y(), m_internalResolution.x(), m_internalResolution.y());
+	ANKI_R_LOGI("Initializing offscreen renderer. Resolution %ux%u. Internal resolution %ux%u",
+				m_postProcessResolution.x(), m_postProcessResolution.y(), m_internalResolution.x(),
+				m_internalResolution.y());
 
 	m_tileSize = m_config->getRTileSize();
 	m_tileCounts.x() = (m_internalResolution.x() + m_tileSize - 1) / m_tileSize;

AnKi/Renderer/RtShadows.cpp

@@ -33,6 +33,8 @@ Error RtShadows::init()
 
 Error RtShadows::initInternal()
 {
+	ANKI_R_LOGV("Initializing RT shadows");
+
 	m_useSvgf = getConfig().getRRtShadowsSvgf();
 	m_atrousPassCount = getConfig().getRRtShadowsSvgfAtrousPassCount();
 

AnKi/Renderer/Scale.cpp

@@ -28,6 +28,8 @@ Scale::~Scale()
 
 Error Scale::init()
 {
+	ANKI_R_LOGV("Initializing scale");
+
 	const Bool needsScaling = m_r->getPostProcessResolution() != m_r->getInternalResolution();
 	const Bool needsSharpening = getConfig().getRSharpen();
 	if(!needsScaling && !needsSharpening)

AnKi/Renderer/ShadowMapping.cpp

@@ -48,6 +48,8 @@ ShadowMapping::~ShadowMapping()
 
 Error ShadowMapping::init()
 {
+	ANKI_R_LOGV("Initializing shadowmapping")
+
 	const Error err = initInternal();
 	if(err)
 	{
@@ -55,10 +57,11 @@ Error ShadowMapping::init()
 	}
 	else
 	{
-		ANKI_R_LOGI(
-			"Shadowmapping scratch size %ux%u. atlas size %ux%u", m_scratch.m_tileCountX * m_scratch.m_tileResolution,
-			m_scratch.m_tileCountY * m_scratch.m_tileResolution, m_atlas.m_tileCountBothAxis * m_atlas.m_tileResolution,
-			m_atlas.m_tileCountBothAxis * m_atlas.m_tileResolution);
+		ANKI_R_LOGV("Shadowmapping initialized. Scratch size %ux%u, atlas size %ux%u",
+					m_scratch.m_tileCountX * m_scratch.m_tileResolution,
+					m_scratch.m_tileCountY * m_scratch.m_tileResolution,
+					m_atlas.m_tileCountBothAxis * m_atlas.m_tileResolution,
+					m_atlas.m_tileCountBothAxis * m_atlas.m_tileResolution);
 	}
 
 	return err;

AnKi/Renderer/ShadowmapsResolve.cpp

@@ -33,6 +33,8 @@ Error ShadowmapsResolve::initInternal()
 	U32 height = U32(getConfig().getRSmResolveFactor() * F32(m_r->getInternalResolution().y()));
 	height = min(m_r->getInternalResolution().y(), getAlignedRoundUp(4, height));
 
+	ANKI_R_LOGV("Initializing shadowmaps resolve. Resolution %ux%u", width, height);
+
 	m_rtDescr = m_r->create2DRenderTargetDescription(width, height, Format::R8G8B8A8_UNORM, "SM resolve");
 	m_rtDescr.bake();
 

AnKi/Renderer/Ssr.cpp

@@ -33,6 +33,8 @@ Error Ssr::initInternal()
 	const U32 width = m_r->getInternalResolution().x() / 2;
 	const U32 height = m_r->getInternalResolution().y() / 2;
 
+	ANKI_R_LOGV("Initializing SSR. Resolution %ux%u", width, height);
+
 	ANKI_CHECK(getResourceManager().loadResource("EngineAssets/BlueNoise_Rgba8_64x64.png", m_noiseImage));
 
 	// Create RT

AnKi/Renderer/TemporalAA.cpp

@@ -35,6 +35,8 @@ Error TemporalAA::init()
 
 Error TemporalAA::initInternal()
 {
+	ANKI_R_LOGV("Initializing TAA");
+
 	ANKI_CHECK(m_r->getResourceManager().loadResource(
 		(getConfig().getRPreferCompute()) ? "Shaders/TemporalAACompute.ankiprog" : "Shaders/TemporalAARaster.ankiprog",
 		m_prog));

AnKi/Renderer/Tonemapping.cpp

@@ -26,6 +26,8 @@ Error Tonemapping::initInternal()
 	const U32 width = m_r->getDownscaleBlur().getPassWidth(m_inputTexMip);
 	const U32 height = m_r->getDownscaleBlur().getPassHeight(m_inputTexMip);
 
+	ANKI_R_LOGV("Initializing tonemapping. Resolution %ux%u", width, height);
+
 	// Create program
 	ANKI_CHECK(getResourceManager().loadResource("Shaders/TonemappingAverageLuminance.ankiprog", m_prog));
 

AnKi/Renderer/VolumetricFog.cpp

@@ -25,6 +25,8 @@ Error VolumetricFog::init()
 	m_volumeSize[1] = U32(F32(m_r->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]);
+
 	// Shaders
 	ANKI_CHECK(getResourceManager().loadResource("Shaders/VolumetricFogAccumulation.ankiprog", m_prog));
 

AnKi/Renderer/VolumetricLightingAccumulation.cpp

@@ -31,7 +31,7 @@ Error VolumetricLightingAccumulation::init()
 	m_volumeSize[0] = U32(F32(m_r->getTileCounts().x()) * qualityXY);
 	m_volumeSize[1] = U32(F32(m_r->getTileCounts().y()) * qualityXY);
 	m_volumeSize[2] = U32(F32(m_finalZSplit + 1) * qualityZ);
-	ANKI_R_LOGI("Initializing volumetric lighting accumulation. Size %ux%ux%u", m_volumeSize[0], m_volumeSize[1],
+	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])

AnKi/Resource/ConfigVars.defs.h

@@ -14,3 +14,4 @@ ANKI_CONFIG_VAR_STRING(RsrcDataPathExcludedStrings, "build",
 					   "A list of string separated by : that will be used to exclude paths from rsrc_dataPaths")
 ANKI_CONFIG_VAR_PTR_SIZE(RsrcTransferScratchMemorySize, 256_MB, 1_MB, 4_GB,
 						 "Memory that is used fot texture and buffer uploads")
+ANKI_CONFIG_VAR_BOOL(RsrcForceFullFpPrecision, false, "Force full floating point precision")

AnKi/Resource/ShaderProgramResourceSystem.cpp

@@ -69,6 +69,7 @@ Error ShaderProgramResourceSystem::compileAllShaders(CString cacheDir, GrManager
 	ShaderCompilerOptions compilerOptions;
 	compilerOptions.m_bindlessLimits.m_bindlessTextureCount = gr.getConfig().getGrMaxBindlessTextures();
 	compilerOptions.m_bindlessLimits.m_bindlessImageCount = gr.getConfig().getGrMaxBindlessImages();
+	compilerOptions.m_forceFullFloatingPointPrecision = gr.getConfig().getRsrcForceFullFpPrecision();
 	U64 gpuHash = computeHash(&compilerOptions, sizeof(compilerOptions));
 	gpuHash = appendHash(&SHADER_BINARY_VERSION, sizeof(SHADER_BINARY_VERSION), gpuHash);
 

AnKi/ShaderCompiler/Common.h

@@ -48,19 +48,24 @@ public:
 };
 
 /// Bindless related info.
+ANKI_BEGIN_PACKED_STRUCT
 class BindlessLimits
 {
 public:
 	U32 m_bindlessTextureCount = 0;
 	U32 m_bindlessImageCount = 0;
 };
+ANKI_END_PACKED_STRUCT
 
 /// Options to be passed to the compiler.
+ANKI_BEGIN_PACKED_STRUCT
 class ShaderCompilerOptions
 {
 public:
 	BindlessLimits m_bindlessLimits;
+	Bool m_forceFullFloatingPointPrecision = false;
 };
+ANKI_END_PACKED_STRUCT
 /// @}
 
 } // end namespace anki

AnKi/ShaderCompiler/ShaderProgramParser.cpp

@@ -24,6 +24,7 @@ static const char SHADER_HEADER[] = R"(#version 460 core
 #define ANKI_OS_ANDROID %d
 #define ANKI_OS_WINDOWS %d
 #define ANKI_OS_LINUX %d
+#define ANKI_FORCE_FULL_FP_PRECISION %d
 
 #define _ANKI_SUPPORTS_64BIT !ANKI_OS_ANDROID
 
@@ -253,7 +254,12 @@ static const char SHADER_HEADER[] = R"(#version 460 core
 layout(std140, row_major) uniform;
 layout(std140, row_major) buffer;
 
-#define ANKI_RP mediump
+#if ANKI_FORCE_FULL_FP_PRECISION
+#	define ANKI_RP mediump
+#else
+#	define ANKI_RP highp
+#endif
+
 #define ANKI_FP highp
 
 precision highp int;
@@ -963,7 +969,8 @@ void ShaderProgramParser::generateAnkiShaderHeader(ShaderType shaderType, const
 												   StringAuto& header)
 {
 	header.sprintf(SHADER_HEADER, SHADER_STAGE_NAMES[shaderType].cstr(), ANKI_OS_ANDROID, ANKI_OS_WINDOWS,
-				   ANKI_OS_LINUX, compilerOptions.m_bindlessLimits.m_bindlessTextureCount,
+				   ANKI_OS_LINUX, compilerOptions.m_forceFullFloatingPointPrecision,
+				   compilerOptions.m_bindlessLimits.m_bindlessTextureCount,
 				   compilerOptions.m_bindlessLimits.m_bindlessImageCount);
 }
 

AnKi/Util/Logger.cpp

@@ -25,7 +25,7 @@ Logger::Logger()
 {
 	addMessageHandler(this, &defaultSystemMessageHandler);
 
-	if(getenv("ANKI_LOGGER_VERBOSE") && getenv("ANKI_LOGGER_VERBOSE") == CString("1"))
+	if(getenv("ANKI_LOG_VERBOSE") && getenv("ANKI_LOG_VERBOSE") == CString("1"))
 	{
 		m_verbosityEnabled = true;
 	}
@@ -130,6 +130,8 @@ void Logger::writeFormated(const char* file, int line, const char* func, const c
 void Logger::defaultSystemMessageHandler(void*, const LoggerMessageInfo& info)
 {
 #if ANKI_OS_LINUX
+	// More info about terminal colors:
+	// https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences
 	FILE* out = nullptr;
 	const char* terminalColor = nullptr;
 	const char* terminalColorBg = nullptr;
@@ -138,11 +140,15 @@ void Logger::defaultSystemMessageHandler(void*, const LoggerMessageInfo& info)
 	switch(info.m_type)
 	{
 	case LoggerMessageType::NORMAL:
-	case LoggerMessageType::VERBOSE:
 		out = stdout;
 		terminalColor = "\033[0;32m";
 		terminalColorBg = "\033[1;42;37m";
 		break;
+	case LoggerMessageType::VERBOSE:
+		out = stdout;
+		terminalColor = "\033[0;34m";
+		terminalColorBg = "\033[1;44;37m";
+		break;
 	case LoggerMessageType::ERROR:
 		out = stderr;
 		terminalColor = "\033[0;31m";