Support standalone temporal AA on mobile platforms. WITH VELOCITY PASS

YOung · chenyong2github · commit 1a24cb335370 · 2022-09-25T11:22:19.000+08:00
diff --git a/Engine/Source/Runtime/Renderer/Private/MobileShadingRenderer.cpp b/Engine/Source/Runtime/Renderer/Private/MobileShadingRenderer.cpp
@@ -386,13 +386,15 @@ void FMobileSceneRenderer::InitViews(FRHICommandListImmediate& RHICmdList)
 	// See CVarMobileForceDepthResolve use in ConditionalResolveSceneDepth.
 	const bool bForceDepthResolve = (CVarMobileForceDepthResolve.GetValueOnRenderThread() == 1);
 	const bool bSeparateTranslucencyActive = IsMobileSeparateTranslucencyActive(Views.GetData(), Views.Num()); 
+	const bool bShouldRenderVelocities = ShouldRenderVelocities();
 	bRequiresMultiPass = RequiresMultiPass(RHICmdList, Views[0]);
 	bKeepDepthContent = 
 		bRequiresMultiPass || 
 		bForceDepthResolve ||
 		bRequriesAmbientOcclusionPass ||
 		bRequiresPixelProjectedPlanarRelfectionPass ||
 		bSeparateTranslucencyActive ||
+		bShouldRenderVelocities ||
 		Views[0].bIsReflectionCapture;
 	// never keep MSAA depth
 	bKeepDepthContent = (NumMSAASamples > 1 ? false : bKeepDepthContent);
@@ -843,6 +845,10 @@ void FMobileSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
 					RenderOcclusion(GraphBuilder, MobileSceneTexturesPerView[ViewIndex]);
 
 					RenderScreenSpaceReflection(GraphBuilder, Views[ViewIndex], SceneContext);
+
+					FRDGTextureRef SceneDepthTexture = TryRegisterExternalTexture(GraphBuilder, SceneContext.SceneDepthZ);
+					FRDGTextureRef VelocityTexture = TryRegisterExternalTexture(GraphBuilder, SceneContext.SceneVelocity);
+					RenderVelocities(GraphBuilder, SceneDepthTexture, VelocityTexture, MobileSceneTexturesPerView[ViewIndex], EVelocityPass::Opaque, false);
 				}
 
 				RDG_EVENT_SCOPE(GraphBuilder, "PostProcessing");
diff --git a/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp b/Engine/Source/Runtime/Renderer/Private/PostProcess/PostProcessing.cpp
@@ -1331,6 +1331,7 @@ void AddMobilePostProcessingPasses(FRDGBuilder& GraphBuilder, const FViewInfo& V
 	const FScreenPassTexture SceneDepth((*Inputs.SceneTextures)->SceneDepthTexture, FinalOutputViewRect);
 	const FScreenPassTexture CustomDepth((*Inputs.SceneTextures)->CustomDepthTexture, FinalOutputViewRect);
 	const FScreenPassTexture BlackAlphaOneDummy(GSystemTextures.GetBlackAlphaOneDummy(GraphBuilder));
+	const FScreenPassTexture SceneVelocity((*Inputs.SceneTextures)->VelocityTexture, FinalOutputViewRect);
 
 	// Scene color is updated incrementally through the post process pipeline.
 	FScreenPassTexture SceneColor((*Inputs.SceneTextures)->SceneColorTexture, FinalOutputViewRect);
@@ -2003,7 +2004,7 @@ void AddMobilePostProcessingPasses(FRDGBuilder& GraphBuilder, const FViewInfo& V
 				UpscalerPassInputs.DownsampleOverrideFormat = PF_FloatRGB;
 				UpscalerPassInputs.SceneColorTexture = SceneColor.Texture;
 				UpscalerPassInputs.SceneDepthTexture = SceneDepth.Texture;
-				UpscalerPassInputs.SceneVelocityTexture = GSystemTextures.GetBlackDummy(GraphBuilder);
+				UpscalerPassInputs.SceneVelocityTexture = SceneVelocity.Texture;
 				UpscalerPassInputs.EyeAdaptationTexture = GetEyeAdaptationTexture(GraphBuilder, View);
 
 				FScreenPassTexture HalfResolutionSceneColor;
diff --git a/Engine/Source/Runtime/Renderer/Private/PostProcess/SceneRenderTargets.cpp b/Engine/Source/Runtime/Renderer/Private/PostProcess/SceneRenderTargets.cpp
@@ -2541,6 +2541,12 @@ static void SetupMobileSceneTextureUniformParameters(
 		SceneTextureParameters.WorldNormalRoughnessTextureSampler = TStaticSamplerState<>::GetRHI();
 	}
 
+	// Velocity
+	{
+		SceneTextureParameters.VelocityTexture = SceneContext.SceneVelocity ? GetRDG(SceneContext.SceneVelocity) : BlackDefault2D;
+		SceneTextureParameters.VelocityTextureSampler = TStaticSamplerState<>::GetRHI();
+	}
+
 	// Mobile GBuffer
 	{
 		const bool bCanReadGBufferUniforms = IsMobileDeferredShadingEnabled(GMaxRHIShaderPlatform);
diff --git a/Engine/Source/Runtime/Renderer/Private/SceneRendering.h b/Engine/Source/Runtime/Renderer/Private/SceneRendering.h
@@ -33,6 +33,8 @@
 #include "GpuDebugRendering.h"
 #include "PostProcess/PostProcessAmbientOcclusionMobile.h"
 
+enum class EVelocityPass : uint32;
+
 // Forward declarations.
 class FScene;
 class FSceneViewState;
@@ -2085,6 +2087,16 @@ class FMobileSceneRenderer : public FSceneRenderer
 	void SetupVolumetricFog();
 	void ComputeVolumetricFog(FRDGBuilder& GraphBuilder, FSceneRenderTargets& SceneContext);
 
+	bool ShouldRenderVelocities() const;
+
+	void RenderVelocities(
+		FRDGBuilder& GraphBuilder,
+		FRDGTextureRef SceneDepthTexture,
+		FRDGTextureRef& VelocityTexture,
+		TRDGUniformBufferRef<FMobileSceneTextureUniformParameters> SceneTexturesUniformBuffer,
+		EVelocityPass VelocityPass,
+		bool bForceVelocity);
+
 	/** Before SetupMobileBasePassAfterShadowInit, we need to update the uniform buffer and shadow info for all movable point lights.*/
 	void UpdateMovablePointLightUniformBufferAndShadowInfo();
 private:
diff --git a/Engine/Source/Runtime/Renderer/Private/VelocityRendering.cpp b/Engine/Source/Runtime/Renderer/Private/VelocityRendering.cpp
@@ -81,7 +81,7 @@ class FVelocityVS : public FMeshMaterialShader
 		const bool bMayModifyMeshes = Parameters.MaterialParameters.bMaterialMayModifyMeshPosition;
 
 		// Compile if supported by the hardware.
-		const bool bIsFeatureSupported = IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::SM5);
+		const bool bIsFeatureSupported = IsFeatureLevelSupported(Parameters.Platform, ERHIFeatureLevel::ES3_1);
 
 		/**
 		 * Any material with a vertex factory incompatible with base pass velocity generation must generate
@@ -207,6 +207,26 @@ bool FDeferredShadingSceneRenderer::ShouldRenderVelocities() const
 	return bNeedsVelocity;
 }
 
+bool FMobileSceneRenderer::ShouldRenderVelocities() const
+{
+	if (!FVelocityRendering::IsSeparateVelocityPassSupported(ShaderPlatform) || ViewFamily.UseDebugViewPS())
+	{
+		return false;
+	}
+
+	bool bNeedsVelocity = false;
+	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
+	{
+		const FViewInfo& View = Views[ViewIndex];
+
+		bool bTemporalAA = (View.AntiAliasingMethod == AAM_TemporalAA) && !View.bCameraCut;
+
+		bNeedsVelocity |= bTemporalAA && MobileUseStandaloneTAA((ShaderPlatform));
+	}
+
+	return bNeedsVelocity;
+}
+
 BEGIN_SHADER_PARAMETER_STRUCT(FVelocityPassParameters, )
 	SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FSceneTextureUniformParameters, SceneTextures)
 	RENDER_TARGET_BINDING_SLOTS()
@@ -331,9 +351,131 @@ void FDeferredShadingSceneRenderer::RenderVelocities(
 	}
 }
 
+BEGIN_SHADER_PARAMETER_STRUCT(FMobileVelocityPassParameters, )
+	SHADER_PARAMETER_RDG_UNIFORM_BUFFER(FMobileSceneTextureUniformParameters, SceneTextures)
+	RENDER_TARGET_BINDING_SLOTS()
+END_SHADER_PARAMETER_STRUCT()
+
+void FMobileSceneRenderer::RenderVelocities(
+	FRDGBuilder& GraphBuilder,
+	FRDGTextureRef DepthTexture,
+	FRDGTextureRef& InOutVelocityTexture,
+	TRDGUniformBufferRef<FMobileSceneTextureUniformParameters> SceneTexturesUniformBuffer,
+	EVelocityPass VelocityPass,
+	bool bForceVelocity)
+{
+	if (!ShouldRenderVelocities())
+	{
+		return;
+	}
+
+	RDG_CSV_STAT_EXCLUSIVE_SCOPE(GraphBuilder, RenderVelocities);
+	SCOPED_NAMED_EVENT(FMobileSceneRenderer_RenderVelocities, FColor::Emerald);
+	SCOPE_CYCLE_COUNTER(STAT_RenderVelocities);
+
+	ERenderTargetLoadAction VelocityLoadAction = ERenderTargetLoadAction::EClear;
+	FRDGTextureRef VelocityTexture = InOutVelocityTexture;
+	bool bVelocityRendered = false;
+
+	if (!VelocityTexture)
+	{
+		VelocityTexture = GraphBuilder.CreateTexture(FVelocityRendering::GetRenderTargetDesc(ShaderPlatform), TEXT("Velocity"));
+		VelocityLoadAction = ERenderTargetLoadAction::EClear;
+	}
+
+	RDG_GPU_STAT_SCOPE(GraphBuilder, RenderVelocities);
+	RDG_WAIT_FOR_TASKS_CONDITIONAL(GraphBuilder, IsVelocityWaitForTasksEnabled());
+
+	const EMeshPass::Type MeshPass = GetMeshPassFromVelocityPass(VelocityPass);
+
+	for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
+	{
+		const FViewInfo& View = Views[ViewIndex];
+
+		if (View.ShouldRenderView())
+		{
+			const FParallelMeshDrawCommandPass& ParallelMeshPass = View.ParallelMeshDrawCommandPasses[MeshPass];
+
+			const bool bHasAnyDraw = ParallelMeshPass.HasAnyDraw();
+			if (!bHasAnyDraw && !bForceVelocity)
+			{
+				continue;
+			}
+
+			RDG_GPU_MASK_SCOPE(GraphBuilder, View.GPUMask);
+
+			if (VelocityLoadAction == ERenderTargetLoadAction::EClear)
+			{
+				AddClearRenderTargetPass(GraphBuilder, VelocityTexture);
+
+				if (!View.Family->bMultiGPUForkAndJoin)
+				{
+					VelocityLoadAction = ERenderTargetLoadAction::ELoad;
+				}
+			}
+			bVelocityRendered = true;
+
+			if (!bHasAnyDraw)
+			{
+				continue;
+			}
+
+			FMobileVelocityPassParameters* PassParameters = GraphBuilder.AllocParameters<FMobileVelocityPassParameters>();
+			PassParameters->SceneTextures = SceneTexturesUniformBuffer;
+			PassParameters->RenderTargets.DepthStencil = FDepthStencilBinding(
+				DepthTexture,
+				ERenderTargetLoadAction::ELoad,
+				ERenderTargetLoadAction::ELoad,
+				VelocityPass == EVelocityPass::Opaque
+				? FExclusiveDepthStencil::DepthRead_StencilWrite
+				: FExclusiveDepthStencil::DepthWrite_StencilWrite);
+
+			if (IsParallelVelocity())
+			{
+				PassParameters->RenderTargets[0] = FRenderTargetBinding(VelocityTexture, ERenderTargetLoadAction::ELoad);
+
+				GraphBuilder.AddPass(
+					RDG_EVENT_NAME("VelocityParallel"),
+					PassParameters,
+					ERDGPassFlags::Raster | ERDGPassFlags::SkipRenderPass,
+					[this, &View, &ParallelMeshPass, VelocityPass, PassParameters](FRHICommandListImmediate& RHICmdList)
+					{
+						Scene->UniformBuffers.UpdateViewUniformBuffer(View);
+						FRDGParallelCommandListSet ParallelCommandListSet(RHICmdList, GET_STATID(STAT_CLP_Velocity), *this, View, FParallelCommandListBindings(PassParameters));
+						ParallelMeshPass.DispatchDraw(&ParallelCommandListSet, RHICmdList);
+					});
+			}
+			else
+			{
+				PassParameters->RenderTargets[0] = FRenderTargetBinding(VelocityTexture, ERenderTargetLoadAction::ELoad);
+
+				GraphBuilder.AddPass(
+					RDG_EVENT_NAME("Velocity"),
+					PassParameters,
+					ERDGPassFlags::Raster,
+					[this, &View, &ParallelMeshPass](FRHICommandListImmediate& RHICmdList)
+					{
+						Scene->UniformBuffers.UpdateViewUniformBuffer(View);
+						SetStereoViewport(RHICmdList, View);
+
+						ParallelMeshPass.DispatchDraw(nullptr, RHICmdList);
+					});
+			}
+
+		}
+	}
+
+	if (!InOutVelocityTexture && bVelocityRendered)
+	{
+		FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(GraphBuilder.RHICmdList);
+		ConvertToExternalTexture(GraphBuilder, VelocityTexture, SceneContext.SceneVelocity);
+		InOutVelocityTexture = VelocityTexture;
+	}
+}
+
 EPixelFormat FVelocityRendering::GetFormat(EShaderPlatform ShaderPlatform)
 {
-	return FDataDrivenShaderPlatformInfo::GetSupportsRayTracing(ShaderPlatform) ? PF_A16B16G16R16 : PF_G16R16;
+	return FDataDrivenShaderPlatformInfo::GetSupportsRayTracing(ShaderPlatform) ? PF_A16B16G16R16 : PF_G16R16F;
 }
 
 FRDGTextureDesc FVelocityRendering::GetRenderTargetDesc(EShaderPlatform ShaderPlatform)
@@ -671,6 +813,7 @@ FMeshPassProcessor* CreateVelocityPassProcessor(const FScene* Scene, const FScen
 }
 
 FRegisterPassProcessorCreateFunction RegisterVelocityPass(&CreateVelocityPassProcessor, EShadingPath::Deferred,  EMeshPass::Velocity, EMeshPassFlags::CachedMeshCommands | EMeshPassFlags::MainView);
+FRegisterPassProcessorCreateFunction RegisterMobileVelocityPass(&CreateVelocityPassProcessor, EShadingPath::Mobile, EMeshPass::Velocity, EMeshPassFlags::CachedMeshCommands | EMeshPassFlags::MainView);
 FTranslucentVelocityMeshProcessor::FTranslucentVelocityMeshProcessor(const FScene* Scene, const FSceneView* InViewIfDynamicMeshCommand, const FMeshPassProcessorRenderState& InPassDrawRenderState, FMeshPassDrawListContext* InDrawListContext)
 	: FVelocityMeshProcessor(Scene, InViewIfDynamicMeshCommand, InPassDrawRenderState, InDrawListContext)
 {}
diff --git a/Engine/Source/Runtime/Renderer/Private/VelocityRendering.h b/Engine/Source/Runtime/Renderer/Private/VelocityRendering.h
@@ -29,6 +29,10 @@ enum class EVelocityPass : uint32
 
 EMeshPass::Type GetMeshPassFromVelocityPass(EVelocityPass VelocityPass);
 
+// Returns whether velocity is enabled and there primitives to draw in the view
+bool IsMobileVelocityActive(const FViewInfo& View);
+bool IsMobileVelocityActive(const FViewInfo* Views, int32 NumViews);
+
 // Group Velocity Rendering accessors, types, etc.
 struct FVelocityRendering
 {
diff --git a/Engine/Source/Runtime/Renderer/Public/SceneRenderTargetParameters.h b/Engine/Source/Runtime/Renderer/Public/SceneRenderTargetParameters.h
@@ -88,6 +88,8 @@ BEGIN_GLOBAL_SHADER_PARAMETER_STRUCT(FMobileSceneTextureUniformParameters, RENDE
 	SHADER_PARAMETER_UAV(RWBuffer<uint>, VirtualTextureFeedbackUAV)
 	SHADER_PARAMETER_RDG_TEXTURE(Texture2D, WorldNormalRoughnessTexture)
 	SHADER_PARAMETER_SAMPLER(SamplerState, WorldNormalRoughnessTextureSampler)
+	SHADER_PARAMETER_RDG_TEXTURE(Texture2D, VelocityTexture)
+	SHADER_PARAMETER_SAMPLER(SamplerState, VelocityTextureSampler)
 	// GBuffer
 	SHADER_PARAMETER_TEXTURE(Texture2D, GBufferATexture)
 	SHADER_PARAMETER_TEXTURE(Texture2D, GBufferBTexture)

Original file line number	Diff line number	Diff line change
`@@ -2541,6 +2541,12 @@ static void SetupMobileSceneTextureUniformParameters(`
`2541`	`2541`	`SceneTextureParameters.WorldNormalRoughnessTextureSampler = TStaticSamplerState<>::GetRHI();`
`2542`	`2542`	`}`
`2543`	`2543`
	`2544`	`+ // Velocity`
	`2545`	`+ {`
	`2546`	`+ SceneTextureParameters.VelocityTexture = SceneContext.SceneVelocity ? GetRDG(SceneContext.SceneVelocity) : BlackDefault2D;`
	`2547`	`+ SceneTextureParameters.VelocityTextureSampler = TStaticSamplerState<>::GetRHI();`
	`2548`	`+ }`
	`2549`	`+`
`2544`	`2550`	`// Mobile GBuffer`
`2545`	`2551`	`{`
`2546`	`2552`	`const bool bCanReadGBufferUniforms = IsMobileDeferredShadingEnabled(GMaxRHIShaderPlatform);`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,10 @@ enum class EVelocityPass : uint32`
`29`	`29`
`30`	`30`	`EMeshPass::Type GetMeshPassFromVelocityPass(EVelocityPass VelocityPass);`
`31`	`31`
	`32`	`+// Returns whether velocity is enabled and there primitives to draw in the view`
	`33`	`+bool IsMobileVelocityActive(const FViewInfo& View);`
	`34`	`+bool IsMobileVelocityActive(const FViewInfo* Views, int32 NumViews);`
	`35`	`+`
`32`	`36`	`// Group Velocity Rendering accessors, types, etc.`
`33`	`37`	`struct FVelocityRendering`
`34`	`38`	`{`