目录

 

 

为了与时俱进，紧跟UE官方的步伐，从本篇起：

分析的UE源码升级到4.26.2，不再是4.25的源码！

分析的UE源码升级到4.26.2，不再是4.25的源码！！

分析的UE源码升级到4.26.2，不再是4.25的源码！！！

重要的事情说三遍，需要同步看源码的同学注意更新了。

其实在剖析虚幻渲染体系（04）- 延迟渲染管线的章节4.3.9 PostProcessing就已经粗略地介绍过后处理的内容，不过本篇将更加深入详细地阐述后处理的流程和主要技术点。

更具体地，本篇主要阐述UE的以下内容：

  • 后处理主流程
  • 后处理序列
  • 后处理主要技术点

不过，还是推荐先阅读剖析虚幻渲染体系（04）- 延迟渲染管线，再阅读此篇，保持循序渐进地学习UE渲染体系的步伐。另外，也推荐先阅读笔者的一篇文章2.1 色彩理论，对颜色空间、色彩理论、线性空间和Gamma校正有了清晰的认知之后更好地过渡到本篇文章。

本篇涉及的源码目录主要在：

  • Engine\Source\Runtime\Renderer\Private\PostProcess\
  • Engine\Shaders\Private\

可能有些同学会疑惑，后处理不就是对渲染完的图片进行处理吗？跟图形渲染的紧密性有那么大么？可以忽略学习后处理么？

为了解答以上疑问，也体现后处理的重要性，以及其在UE或图形渲染的关联和地位，特地开辟了此小节。

以UE的默认场景为例，它的画面如下：

现在用以下命令行关闭所有后处理：

  1. ShowFlag.PostProcessing 0

结果画面变成了下面这般模样：

用RenderDoc截帧，发现上面的画面其实还应用了后处理阶段的Gamma校正，好家伙，把它也关了，由此得到彻底没有后处理的画面：

对比第一幅图，看到差别了么？是不是颜色的亮度、对比度、色彩、还有锯齿都不一样？

这也印证了，即便你没有对后处理做任何设置或更改，UE依然在默认情况下执行了很多后处理，才使得渲染画面最终正常地呈现在屏幕前。

由此可知，后处理之于渲染、之于UE，有着何等重要的位置。有了后处理，我们便可如虎添翼，画龙点睛，让画面才更加可信、生动、有趣。

实际上，后处理的应用远不止于此，结合深度、法线等屏幕空间的信息之后，将拥有更广阔更丰富的魔法世界。

 

本章将阐述后处理的一些基础知识点和概念及UE的操作使用。

艺术家和设计师使用虚幻引擎提供的后期处理效果，可以调整场景的整体外观和感觉。

默认情况下，UE会开启抗锯齿、自动曝光、Bloom、色调映射和Gamma校正等后处理：

当然，可以通过场景视图的Show/Post Processing菜单下的选项动态开启关闭后处理，以便观察指定后处理的对场景产生的效果和变化。

也可以通过之前提及的控制台命令开启或关闭后处理。

对于艺术家，更通用且方便的方法是往场景拖曳后处理体积（Post Processing Volume），以便精确地控制后处理效果和参数。

后处理体积涉及的类型和参数非常多，下面是后处理体积的属性分类：

其中Lens是镜头相关的后处理效果，包含Bloom、Exposure、Flares、DOF等效果；Color Grading是颜色分级，包含白平衡、全局、阴影、中调、高调等效果；Film就是电影色调映射，可以调整斜度、低调、黑色、肩部、白色等曲线参数；Rendering Feature包含了渲染管线相关的效果，包含后处理材质、环境立方图、AO、光追相关特性、GI、运动模糊、LPV、反射、SSR、透明、路径追踪以及屏幕百分比；最后是Post Processing Volume Setting，可以指定优先级、混合权重、设定是否影响无限范围（上图）。

同一个场景可以同时存在多个后处理体积，但为了性能和可维护性，应该保持一个场景只有一个全局后处理（Infinite Extent），其余的设置为局部范围。

虽然后处理体积提供了很多内置的后处理效果，但渲染的效果千变万化，它们肯定无法全部满足应用的实际需求。UE的后处理材质（Post Processing Material）便满足自定义要求，可以利用材质编辑器实现自定义的后处理效果。

添加后处理材质也不复杂，新建材质，将材质域（Material Domain）设置为Post Process，此时材质引脚只有Emissive Color被点亮：

并且Post Process Material属性栏处于可编辑状态：

这些参数的含义说明如下：

  • Blendable Location：材质混合位置，可选的有After Tonemapping（色调映射之后）、Before Tonemapping（色调映射之前）、Before Translucency（透明之前）、Replacing Tonemapping（替换色调映射）、SSR Input（屏幕空间反射输入），默认是After Tonemapping（色调映射之后）。
  • Output Alpha：是否输出Alpha，如果是，则需要正确处理和输出Emissive Color的Alpha通道。默认不开启。
  • Blendable Priority：混合优先级，数值越高越后被渲染（即优先级小的先被渲染）。默认是0。
  • Is Blendable：是否可混合，如果可混合，会在C++层预先插值混合共享同一母材质的所有材质（或材质实例）参数。默认是可以。
  • Enable Stencil Test：是否开启模板测试，如果开启，可以设置比较方式和参考值。默认不开启。

编辑好后处理材质之后，为了将它应用到场景上，可以在后处理体积的Rendering Feature属性栏的Post Process Material列表中设置：

还可以调整每个材质的混合权重和顺序（拖曳权重左边的点阵）。

值得注意的是，在后处理材质中，SceneTexture材质节点的SceneColor无法访问，否则会报错：

后处理材质中无法访问SceneColor，提示SceneColor只能在Surface材质域中使用。

解决这个问题就是选中SceneTexture节点，在属性栏的Scene Texture Id选择PostProcessInput0：

除了PostProcessInput0，还有其它很多屏幕空间的数据（GBuffer）可以被后处理材质读取：

但是，在多数后处理通道中，PostProcessInput1~PostProcessInput6是空纹理。

 

本章将进入UE的后处理代码进行分析。

后处理的主入口是AddPostProcessingPasses，位于的FDeferred末尾：

  1. void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
  2. {
  3.     (......)
  4.     
  5.     RenderTranslucency(RHICmdList, ...);
  6.     
  7.     (......)
  8.     
  9.     // 后处理阶段。
  10.     if (ViewFamily.bResolveScene)
  11.     {
  12.         GRenderTargetPool.AddPhaseEvent(TEXT("PostProcessing"));
  14.         (......)
  15.         
  16.         // 后处理的输入参数.
  17.         FPostProcessingInputs PostProcessingInputs;
  18.         PostProcessingInputs.ViewFamilyTexture = ViewFamilyTexture;
  19.         PostProcessingInputs.SeparateTranslucencyTextures = &SeparateTranslucencyTextures;
  20.         PostProcessingInputs.SceneTextures = SceneTextures;
  22.         (......)
  23.         
  24.         {
  25.             // 遍历所有view, 每个view增加后处理Pass.
  26.             for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
  27.             {
  28.                 FViewInfo& View = Views[ViewIndex];
  29.                 // 增加后处理通道.
  30.                 AddPostProcessingPasses(GraphBuilder, View, PostProcessingInputs);
  31.             }
  32.         }
  34.         // 将场景上下文的场景颜色纹理置空.
  35.         AddPass(GraphBuilder, [this, &SceneContext](FRHICommandListImmediate&)
  36.         {
  37.             SceneContext.SetSceneColor(nullptr);
  38.         });
  39.     }
  40.     
  41.     (......)
  42. }

AddPostProcessingPasses是处理UE内置后处理序列的，涉及的代码量大，不过下面先分析其主要流程：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessing.cpp
  3. void AddPostProcessingPasses(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FPostProcessingInputs& Inputs)
  4. {
  5.     Inputs.Validate();
  7.     // 获取纹理和视图数据.
  8.     const FIntRect PrimaryViewRect = View.ViewRect;
  9.     const FSceneTextureParameters SceneTextureParameters = GetSceneTextureParameters(GraphBuilder, Inputs.SceneTextures);
  10.     const FScreenPassRenderTarget ViewFamilyOutput = FScreenPassRenderTarget::CreateViewFamilyOutput(Inputs.ViewFamilyTexture, View);
  11.     const FScreenPassTexture SceneDepth(SceneTextureParameters.SceneDepthTexture, PrimaryViewRect);
  12.     const FScreenPassTexture SeparateTranslucency(Inputs.SeparateTranslucencyTextures->GetColorForRead(GraphBuilder), PrimaryViewRect);
  13.     const FScreenPassTexture CustomDepth((*Inputs.SceneTextures)->CustomDepthTexture, PrimaryViewRect);
  14.     const FScreenPassTexture Velocity(SceneTextureParameters.GBufferVelocityTexture, PrimaryViewRect);
  15.     const FScreenPassTexture BlackDummy(GSystemTextures.GetBlackDummy(GraphBuilder));
  17.     // 场景颜色.
  18.     FScreenPassTexture SceneColor((*Inputs.SceneTextures)->SceneColorTexture, PrimaryViewRect);
  19.     FScreenPassTexture SceneColorBeforeTonemap;
  20.     FScreenPassTexture SceneColorAfterTonemap;
  21.     const FScreenPassTexture OriginalSceneColor = SceneColor;
  23.     // 初始化纹理.
  24.     const FEyeAdaptationParameters EyeAdaptationParameters = GetEyeAdaptationParameters(View, ERHIFeatureLevel::SM5);
  25.     FRDGTextureRef LastEyeAdaptationTexture = GetEyeAdaptationTexture(GraphBuilder, View);
  26.     FRDGTextureRef EyeAdaptationTexture = LastEyeAdaptationTexture;
  27.     FRDGTextureRef HistogramTexture = BlackDummy.Texture;
  29.     // 处理后处理开启标记.
  30.     const FEngineShowFlags& EngineShowFlags = View.Family->EngineShowFlags;
  31.     const bool bVisualizeHDR = EngineShowFlags.VisualizeHDR;
  32.     const bool bViewFamilyOutputInHDR = GRHISupportsHDROutput && IsHDREnabled();
  33.     const bool bVisualizeGBufferOverview = IsVisualizeGBufferOverviewEnabled(View);
  34.     const bool bVisualizeGBufferDumpToFile = IsVisualizeGBufferDumpToFileEnabled(View);
  35.     const bool bVisualizeGBufferDumpToPIpe = IsVisualizeGBufferDumpToPipeEnabled(View);
  36.     const bool bOutputInHDR = IsPostProcessingOutputInHDR();
  38.     const FPaniniProjectionConfig PaniniConfig(View);
  40.     // 后处理特定Pass.
  41.     enum class EPass : uint32
  42.     {
  43.         MotionBlur,    // 运动模糊
  44.         Tonemap,     // 色调映射
  45.         FXAA,        // FXAA抗锯齿    
  46.         PostProcessMaterialAfterTonemapping, // 色调映射之后的后处理
  47.         VisualizeDepthOfField,
  48.         VisualizeStationaryLightOverlap,
  49.         VisualizeLightCulling,
  50.         SelectionOutline,
  51.         EditorPrimitive,
  52.         VisualizeShadingModels,
  53.         VisualizeGBufferHints,
  54.         VisualizeSubsurface,
  55.         VisualizeGBufferOverview,
  56.         VisualizeHDR,
  57.         PixelInspector,
  58.         HMDDistortion,
  59.         HighResolutionScreenshotMask,
  60.         PrimaryUpscale,     // 主放大
  61.         SecondaryUpscale,     // 次放大
  62.         MAX
  63.     };
  64.     
  65.     (......)
  67.     // 后处理特定Pass对应的名字.
  68.     const TCHAR* PassNames[] =
  69.     {
  70.         TEXT("MotionBlur"),
  71.         TEXT("Tonemap"),
  72.         TEXT("FXAA"),
  73.         TEXT("PostProcessMaterial (AfterTonemapping)"),
  74.         TEXT("VisualizeDepthOfField"),
  75.         TEXT("VisualizeStationaryLightOverlap"),
  76.         TEXT("VisualizeLightCulling"),
  77.         TEXT("SelectionOutline"),
  78.         TEXT("EditorPrimitive"),
  79.         TEXT("VisualizeShadingModels"),
  80.         TEXT("VisualizeGBufferHints"),
  81.         TEXT("VisualizeSubsurface"),
  82.         TEXT("VisualizeGBufferOverview"),
  83.         TEXT("VisualizeHDR"),
  84.         TEXT("PixelInspector"),
  85.         TEXT("HMDDistortion"),
  86.         TEXT("HighResolutionScreenshotMask"),
  87.         TEXT("PrimaryUpscale"),
  88.         TEXT("SecondaryUpscale")
  89.     };
  91.     static_assert(static_cast<uint32>(EPass::MAX) == UE_ARRAY_COUNT(PassNames), "EPass does not match PassNames.");
  93.     // 声明后处理序列PassSequence实例.
  94.     TOverridePassSequence<EPass> PassSequence(ViewFamilyOutput);
  95.     PassSequence.SetNames(PassNames, UE_ARRAY_COUNT(PassNames));
  96.     
  97.     // 开启或关闭指定Pass.
  98.     PassSequence.SetEnabled(EPass::VisualizeStationaryLightOverlap, EngineShowFlags.StationaryLightOverlap);
  99.     PassSequence.SetEnabled(EPass::VisualizeLightCulling, EngineShowFlags.VisualizeLightCulling);
  100.     PassSequence.SetEnabled(EPass::SelectionOutline, false);
  101.     PassSequence.SetEnabled(EPass::EditorPrimitive, false);
  102.     PassSequence.SetEnabled(EPass::VisualizeShadingModels, EngineShowFlags.VisualizeShadingModels);
  103.     PassSequence.SetEnabled(EPass::VisualizeGBufferHints, EngineShowFlags.GBufferHints);
  104.     PassSequence.SetEnabled(EPass::VisualizeSubsurface, EngineShowFlags.VisualizeSSS);
  105.     PassSequence.SetEnabled(EPass::VisualizeGBufferOverview, bVisualizeGBufferOverview || bVisualizeGBufferDumpToFile || bVisualizeGBufferDumpToPIpe);
  106.     PassSequence.SetEnabled(EPass::VisualizeHDR, EngineShowFlags.VisualizeHDR);
  107.     PassSequence.SetEnabled(EPass::PixelInspector, false);
  108.     PassSequence.SetEnabled(EPass::HMDDistortion, EngineShowFlags.StereoRendering && EngineShowFlags.HMDDistortion);
  109.     PassSequence.SetEnabled(EPass::HighResolutionScreenshotMask, IsHighResolutionScreenshotMaskEnabled(View));
  110.     PassSequence.SetEnabled(EPass::PrimaryUpscale, PaniniConfig.IsEnabled() || (View.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::SpatialUpscale && PrimaryViewRect.Size() != View.GetSecondaryViewRectSize()));
  111.     PassSequence.SetEnabled(EPass::SecondaryUpscale, View.RequiresSecondaryUpscale());
  112.     
  113.     (......)
  115.     if (IsPostProcessingEnabled(View)) // 视图启用后处理
  116.     {
  117.         const EStereoscopicPass StereoPass = View.StereoPass;
  118.         
  119.         // 处理数据和标记.
  120.         const bool bPrimaryView = IStereoRendering::IsAPrimaryView(View);
  121.         const bool bHasViewState = View.ViewState != nullptr;
  122.         const bool bDepthOfFieldEnabled = DiaphragmDOF::IsEnabled(View);
  123.         const bool bVisualizeDepthOfField = bDepthOfFieldEnabled && EngineShowFlags.VisualizeDOF;
  124.         const bool bVisualizeMotionBlur = IsVisualizeMotionBlurEnabled(View);
  125.         const EAutoExposureMethod AutoExposureMethod = GetAutoExposureMethod(View);
  126.         const EAntiAliasingMethod AntiAliasingMethod = !bVisualizeDepthOfField ? View.AntiAliasingMethod : AAM_None;
  127.         const EDownsampleQuality DownsampleQuality = GetDownsampleQuality();
  128.         const EPixelFormat DownsampleOverrideFormat = PF_FloatRGB;
  129.         const bool bMotionBlurEnabled = !bVisualizeMotionBlur && IsMotionBlurEnabled(View);
  130.         const bool bTonemapEnabled = !bVisualizeMotionBlur;
  131.         const bool bTonemapOutputInHDR = View.Family->SceneCaptureSource == SCS_FinalColorHDR || View.Family->SceneCaptureSource == SCS_FinalToneCurveHDR || bOutputInHDR || bViewFamilyOutputInHDR;
  132.         const bool bEyeAdaptationEnabled = bHasViewState && bPrimaryView;
  133.         const bool bHistogramEnabled = bVisualizeHDR || (bEyeAdaptationEnabled && AutoExposureMethod == EAutoExposureMethod::AEM_Histogram && View.FinalPostProcessSettings.AutoExposureMinBrightness < View.FinalPostProcessSettings.AutoExposureMaxBrightness);
  134.         const bool bBloomEnabled = View.FinalPostProcessSettings.BloomIntensity > 0.0f;
  136.         // 色调映射之后的后处理材质.
  137.         const FPostProcessMaterialChain PostProcessMaterialAfterTonemappingChain = GetPostProcessMaterialChain(View, BL_AfterTonemapping);
  139.         PassSequence.SetEnabled(EPass::MotionBlur, bVisualizeMotionBlur || bMotionBlurEnabled);
  140.         PassSequence.SetEnabled(EPass::Tonemap, bTonemapEnabled);
  141.         PassSequence.SetEnabled(EPass::FXAA, AntiAliasingMethod == AAM_FXAA);
  142.         PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, PostProcessMaterialAfterTonemappingChain.Num() != 0);
  143.         PassSequence.SetEnabled(EPass::VisualizeDepthOfField, bVisualizeDepthOfField);
  145.         // 插件后处理回调.
  146.         for (int32 ViewExt = 0; ViewExt < View.Family->ViewExtensions.Num(); ++ViewExt)
  147.         {
  148.             for (int32 SceneViewPassId = 0; SceneViewPassId != static_cast<int>(ISceneViewExtension::EPostProcessingPass::MAX); SceneViewPassId++)
  149.             {
  150.                 ISceneViewExtension::EPostProcessingPass SceneViewPass = static_cast<ISceneViewExtension::EPostProcessingPass>(SceneViewPassId);
  151.                 EPass PostProcessingPass = TranslatePass(SceneViewPass);
  153.                 View.Family->ViewExtensions[ViewExt]->SubscribeToPostProcessingPass(
  154.                     SceneViewPass,
  155.                     PassSequence.GetAfterPassCallbacks(PostProcessingPass),
  156.                     PassSequence.IsEnabled(PostProcessingPass));
  157.             }
  158.         }
  160.         // 后处理序列开启或关闭处理完毕.
  161.         PassSequence.Finalize();
  163.         // 后处理材质链 - 透明混合之前(Before Translucency)
  164.         {
  165.             const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_BeforeTranslucency);
  167.             if (MaterialChain.Num())
  168.             {
  169.                 SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, GetPostProcessMaterialInputs(SceneColor), MaterialChain);
  170.             }
  171.         }
  173.         // 光圈DOF
  174.         {
  175.             FRDGTextureRef LocalSceneColorTexture = SceneColor.Texture;
  177.             if (bDepthOfFieldEnabled)
  178.             {
  179.                 LocalSceneColorTexture = DiaphragmDOF::AddPasses(GraphBuilder, SceneTextureParameters, View, SceneColor.Texture, *Inputs.SeparateTranslucencyTextures);
  180.             }
  182.             if (LocalSceneColorTexture == SceneColor.Texture)
  183.             {
  184.                 LocalSceneColorTexture = AddSeparateTranslucencyCompositionPass(GraphBuilder, View, SceneColor.Texture, *Inputs.SeparateTranslucencyTextures);
  185.             }
  187.             SceneColor.Texture = LocalSceneColorTexture;
  188.         }
  190.         // 后处理材质链 - 色调映射之前(Before Tonemapping)
  191.         {
  192.             const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_BeforeTonemapping);
  194.             if (MaterialChain.Num())
  195.             {
  196.                 SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, GetPostProcessMaterialInputs(SceneColor), MaterialChain);
  197.             }
  198.         }
  200.         FScreenPassTexture HalfResolutionSceneColor;
  202.         // 主视图区域.
  203.         FIntRect SecondaryViewRect = PrimaryViewRect;
  205.         // 时间抗锯齿TAA.
  206.         if (AntiAliasingMethod == AAM_TemporalAA)
  207.         {
  208.             // 是否允许场景颜色下采样.
  209.             const bool bAllowSceneDownsample =
  210.                 IsTemporalAASceneDownsampleAllowed(View) &&
  211.                 // We can only merge if the normal downsample pass would happen immediately after.
  212.                 !bMotionBlurEnabled && !bVisualizeMotionBlur &&
  213.                 // TemporalAA is only able to match the low quality mode (box filter).
  214.                 GetDownsampleQuality() == EDownsampleQuality::Low;
  216.             int32 UpscaleMode = ITemporalUpscaler::GetTemporalUpscalerMode();
  218.             const ITemporalUpscaler* DefaultTemporalUpscaler = ITemporalUpscaler::GetDefaultTemporalUpscaler();
  219.             const ITemporalUpscaler* UpscalerToUse = ( UpscaleMode == 0 || !View.Family->GetTemporalUpscalerInterface())? DefaultTemporalUpscaler : View.Family->GetTemporalUpscalerInterface();
  221.             const TCHAR* UpscalerName = UpscalerToUse->GetDebugName();
  223.             (......)
  225.             ITemporalUpscaler::FPassInputs UpscalerPassInputs;
  227.             UpscalerPassInputs.bAllowDownsampleSceneColor = bAllowSceneDownsample;
  228.             UpscalerPassInputs.DownsampleOverrideFormat = DownsampleOverrideFormat;
  229.             UpscalerPassInputs.SceneColorTexture = SceneColor.Texture;
  230.             UpscalerPassInputs.SceneDepthTexture = SceneDepth.Texture;
  231.             UpscalerPassInputs.SceneVelocityTexture = Velocity.Texture;
  232.             UpscalerPassInputs.EyeAdaptationTexture = GetEyeAdaptationTexture(GraphBuilder, View);
  234.             // 增加TAA Pass.
  235.             UpscalerToUse->AddPasses(
  236.                 GraphBuilder,
  237.                 View,
  238.                 UpscalerPassInputs,
  239.                 &SceneColor.Texture,
  240.                 &SecondaryViewRect,
  241.                 &HalfResolutionSceneColor.Texture,
  242.                 &HalfResolutionSceneColor.ViewRect);
  243.         }
  244.         // 屏幕空间反射(SSR).
  245.         else if (ShouldRenderScreenSpaceReflections(View))
  246.         {
  247.             if (!View.bStatePrevViewInfoIsReadOnly)
  248.             {
  249.                 check(View.ViewState);
  250.                 FTemporalAAHistory& OutputHistory = View.ViewState->PrevFrameViewInfo.TemporalAAHistory;
  251.                 GraphBuilder.QueueTextureExtraction(SceneColor.Texture, &OutputHistory.RT[0]);
  253.                 FTAAPassParameters TAAInputs(View);
  254.                 TAAInputs.SceneColorInput = SceneColor.Texture;
  255.                 TAAInputs.SetupViewRect(View);
  256.                 OutputHistory.ViewportRect = TAAInputs.OutputViewRect;
  257.                 OutputHistory.ReferenceBufferSize = TAAInputs.GetOutputExtent() * TAAInputs.ResolutionDivisor;
  258.             }
  259.         }
  261.         // 场景颜色视图区域编程次视图的.
  262.         SceneColor.ViewRect = SecondaryViewRect;
  264.         // 后处理材质链 - 屏幕空间反射输入(SSR Input)
  265.         if (View.ViewState && !View.bStatePrevViewInfoIsReadOnly)
  266.         {
  267.             const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_SSRInput);
  269.             if (MaterialChain.Num())
  270.             {
  271.                 // 保存SSR的后处理输出给下一帧使用.
  272.                 FScreenPassTexture PassOutput = AddPostProcessMaterialChain(GraphBuilder, View, GetPostProcessMaterialInputs(SceneColor), MaterialChain);
  273.                 GraphBuilder.QueueTextureExtraction(PassOutput.Texture, &View.ViewState->PrevFrameViewInfo.CustomSSRInput);
  274.             }
  275.         }
  277.         // 运动模糊.
  278.         if (PassSequence.IsEnabled(EPass::MotionBlur))
  279.         {
  280.             FMotionBlurInputs PassInputs;
  281.             PassSequence.AcceptOverrideIfLastPass(EPass::MotionBlur, PassInputs.OverrideOutput);
  282.             PassInputs.SceneColor = SceneColor;
  283.             PassInputs.SceneDepth = SceneDepth;
  284.             PassInputs.SceneVelocity = Velocity;
  285.             PassInputs.Quality = GetMotionBlurQuality();
  286.             PassInputs.Filter = GetMotionBlurFilter();
  288.             if (bVisualizeMotionBlur)
  289.             {
  290.                 SceneColor = AddVisualizeMotionBlurPass(GraphBuilder, View, PassInputs);
  291.             }
  292.             else
  293.             {
  294.                 SceneColor = AddMotionBlurPass(GraphBuilder, View, PassInputs);
  295.             }
  296.         }
  298.         SceneColor = AddAfterPass(EPass::MotionBlur, SceneColor);
  300.         // 如果TAA没有下采样场景颜色, 这里将采用半尺寸分辨率执行之.
  301.         if (!HalfResolutionSceneColor.Texture)
  302.         {
  303.             FDownsamplePassInputs PassInputs;
  304.             PassInputs.Name = TEXT("HalfResolutionSceneColor");
  305.             PassInputs.SceneColor = SceneColor;
  306.             PassInputs.Quality = DownsampleQuality;
  307.             PassInputs.FormatOverride = DownsampleOverrideFormat;
  309.             HalfResolutionSceneColor = AddDownsamplePass(GraphBuilder, View, PassInputs);
  310.         }
  312.         // 保存半尺寸分辨率的场景颜色到历史中.
  313.         extern int32 GSSRHalfResSceneColor;
  314.         if (ShouldRenderScreenSpaceReflections(View) && !View.bStatePrevViewInfoIsReadOnly && GSSRHalfResSceneColor)
  315.         {
  316.             check(View.ViewState);
  317.             GraphBuilder.QueueTextureExtraction(HalfResolutionSceneColor.Texture, &View.ViewState->PrevFrameViewInfo.HalfResTemporalAAHistory);
  318.         }
  320.         FSceneDownsampleChain SceneDownsampleChain;
  322.         // 直方图.
  323.         if (bHistogramEnabled)
  324.         {
  325.             HistogramTexture = AddHistogramPass(GraphBuilder, View, EyeAdaptationParameters, HalfResolutionSceneColor, LastEyeAdaptationTexture);
  326.         }
  328.         // 人眼适应(自动曝光).
  329.         if (bEyeAdaptationEnabled)
  330.         {
  331.             const bool bBasicEyeAdaptationEnabled = bEyeAdaptationEnabled && (AutoExposureMethod == EAutoExposureMethod::AEM_Basic);
  333.             if (bBasicEyeAdaptationEnabled)
  334.             {
  335.                 const bool bLogLumaInAlpha = true;
  336.                 SceneDownsampleChain.Init(GraphBuilder, View, EyeAdaptationParameters, HalfResolutionSceneColor, DownsampleQuality, bLogLumaInAlpha);
  338.                 // Use the alpha channel in the last downsample (smallest) to compute eye adaptations values.
  339.                 EyeAdaptationTexture = AddBasicEyeAdaptationPass(GraphBuilder, View, EyeAdaptationParameters, SceneDownsampleChain.GetLastTexture(), LastEyeAdaptationTexture);
  340.             }
  341.             // Add histogram eye adaptation pass even if no histogram exists to support the manual clamping mode.
  342.             else
  343.             {
  344.                 EyeAdaptationTexture = AddHistogramEyeAdaptationPass(GraphBuilder, View, EyeAdaptationParameters, HistogramTexture);
  345.             }
  346.         }
  348.         FScreenPassTexture Bloom;
  350.         // 泛光.
  351.         if (bBloomEnabled)
  352.         {
  353.             FSceneDownsampleChain BloomDownsampleChain;
  355.             FBloomInputs PassInputs;
  356.             PassInputs.SceneColor = SceneColor;
  358.             const bool bBloomThresholdEnabled = View.FinalPostProcessSettings.BloomThreshold > -1.0f;
  360.             // Reuse the main scene downsample chain if a threshold isn\'t required for bloom.
  361.             if (SceneDownsampleChain.IsInitialized() && !bBloomThresholdEnabled)
  362.             {
  363.                 PassInputs.SceneDownsampleChain = &SceneDownsampleChain;
  364.             }
  365.             else
  366.             {
  367.                 FScreenPassTexture DownsampleInput = HalfResolutionSceneColor;
  369.                 if (bBloomThresholdEnabled)
  370.                 {
  371.                     const float BloomThreshold = View.FinalPostProcessSettings.BloomThreshold;
  373.                     FBloomSetupInputs SetupPassInputs;
  374.                     SetupPassInputs.SceneColor = DownsampleInput;
  375.                     SetupPassInputs.EyeAdaptationTexture = EyeAdaptationTexture;
  376.                     SetupPassInputs.Threshold = BloomThreshold;
  378.                     DownsampleInput = AddBloomSetupPass(GraphBuilder, View, SetupPassInputs);
  379.                 }
  381.                 const bool bLogLumaInAlpha = false;
  382.                 BloomDownsampleChain.Init(GraphBuilder, View, EyeAdaptationParameters, DownsampleInput, DownsampleQuality, bLogLumaInAlpha);
  384.                 PassInputs.SceneDownsampleChain = &BloomDownsampleChain;
  385.             }
  387.             FBloomOutputs PassOutputs = AddBloomPass(GraphBuilder, View, PassInputs);
  388.             SceneColor = PassOutputs.SceneColor;
  389.             Bloom = PassOutputs.Bloom;
  391.             FScreenPassTexture LensFlares = AddLensFlaresPass(GraphBuilder, View, Bloom, *PassInputs.SceneDownsampleChain);
  393.             if (LensFlares.IsValid())
  394.             {
  395.                 Bloom = LensFlares;
  396.             }
  397.         }
  399.         if (!Bloom.IsValid())
  400.         {
  401.             Bloom = BlackDummy;
  402.         }
  404.         SceneColorBeforeTonemap = SceneColor;
  406.         // 色调映射.
  407.         if (PassSequence.IsEnabled(EPass::Tonemap))
  408.         {
  409.             const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_ReplacingTonemapper);
  411.             if (MaterialChain.Num())
  412.             {
  413.                 const UMaterialInterface* HighestPriorityMaterial = MaterialChain[0];
  415.                 FPostProcessMaterialInputs PassInputs;
  416.                 PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
  417.                 PassInputs.SetInput(EPostProcessMaterialInput::SceneColor, SceneColor);
  418.                 PassInputs.SetInput(EPostProcessMaterialInput::SeparateTranslucency, SeparateTranslucency);
  419.                 PassInputs.SetInput(EPostProcessMaterialInput::CombinedBloom, Bloom);
  420.                 PassInputs.SceneTextures = GetSceneTextureShaderParameters(Inputs.SceneTextures);
  421.                 PassInputs.CustomDepthTexture = CustomDepth.Texture;
  423.                 SceneColor = AddPostProcessMaterialPass(GraphBuilder, View, PassInputs, HighestPriorityMaterial);
  424.             }
  425.             else
  426.             {
  427.                 FRDGTextureRef ColorGradingTexture = nullptr;
  429.                 if (bPrimaryView)
  430.                 {
  431.                     ColorGradingTexture = AddCombineLUTPass(GraphBuilder, View);
  432.                 }
  433.                 // We can re-use the color grading texture from the primary view.
  434.                 else if (View.GetTonemappingLUT())
  435.                 {
  436.                     ColorGradingTexture = TryRegisterExternalTexture(GraphBuilder, View.GetTonemappingLUT());
  437.                 }
  438.                 else
  439.                 {
  440.                     const FViewInfo* PrimaryView = static_cast<const FViewInfo*>(View.Family->Views[0]);
  441.                     ColorGradingTexture = TryRegisterExternalTexture(GraphBuilder, PrimaryView->GetTonemappingLUT());
  442.                 }
  444.                 FTonemapInputs PassInputs;
  445.                 PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
  446.                 PassInputs.SceneColor = SceneColor;
  447.                 PassInputs.Bloom = Bloom;
  448.                 PassInputs.EyeAdaptationTexture = EyeAdaptationTexture;
  449.                 PassInputs.ColorGradingTexture = ColorGradingTexture;
  450.                 PassInputs.bWriteAlphaChannel = AntiAliasingMethod == AAM_FXAA || IsPostProcessingWithAlphaChannelSupported();
  451.                 PassInputs.bOutputInHDR = bTonemapOutputInHDR;
  453.                 SceneColor = AddTonemapPass(GraphBuilder, View, PassInputs);
  454.             }
  455.         }
  456.         
  457.         SceneColor = AddAfterPass(EPass::Tonemap, SceneColor);
  458.         
  459.         SceneColorAfterTonemap = SceneColor;
  461.         // FXAA抗锯齿.
  462.         if (PassSequence.IsEnabled(EPass::FXAA))
  463.         {
  464.             FFXAAInputs PassInputs;
  465.             PassSequence.AcceptOverrideIfLastPass(EPass::FXAA, PassInputs.OverrideOutput);
  466.             PassInputs.SceneColor = SceneColor;
  467.             PassInputs.Quality = GetFXAAQuality();
  469.             SceneColor = AddFXAAPass(GraphBuilder, View, PassInputs);
  470.         }
  472.         SceneColor = AddAfterPass(EPass::FXAA, SceneColor);
  474.         // 后处理材质链 - 色调映射之后(After Tonemapping)
  475.         if (PassSequence.IsEnabled(EPass::PostProcessMaterialAfterTonemapping))
  476.         {
  477.             FPostProcessMaterialInputs PassInputs = GetPostProcessMaterialInputs(SceneColor);
  478.             PassSequence.AcceptOverrideIfLastPass(EPass::PostProcessMaterialAfterTonemapping, PassInputs.OverrideOutput);
  479.             PassInputs.SetInput(EPostProcessMaterialInput::PreTonemapHDRColor, SceneColorBeforeTonemap);
  480.             PassInputs.SetInput(EPostProcessMaterialInput::PostTonemapHDRColor, SceneColorAfterTonemap);
  481.             PassInputs.SceneTextures = GetSceneTextureShaderParameters(Inputs.SceneTextures);
  483.             SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, PassInputs, PostProcessMaterialAfterTonemappingChain);
  484.         }
  486.         (......)
  488.         SceneColor = AddAfterPass(EPass::VisualizeDepthOfField, SceneColor);
  489.     }
  490.     else // 视图不启用后处理, 则最小化后处理序列: 只混合透明纹理和Gamma校正.
  491.     {
  492.         PassSequence.SetEnabled(EPass::MotionBlur, false);
  493.         PassSequence.SetEnabled(EPass::Tonemap, true);
  494.         PassSequence.SetEnabled(EPass::FXAA, false);
  495.         PassSequence.SetEnabled(EPass::PostProcessMaterialAfterTonemapping, false);
  496.         PassSequence.SetEnabled(EPass::VisualizeDepthOfField, false);
  497.         PassSequence.Finalize();
  499.         SceneColor.Texture = AddSeparateTranslucencyCompositionPass(GraphBuilder, View, SceneColor.Texture, *Inputs.SeparateTranslucencyTextures);
  501.         SceneColorBeforeTonemap = SceneColor;
  503.         if (PassSequence.IsEnabled(EPass::Tonemap))
  504.         {
  505.             FTonemapInputs PassInputs;
  506.             PassSequence.AcceptOverrideIfLastPass(EPass::Tonemap, PassInputs.OverrideOutput);
  507.             PassInputs.SceneColor = SceneColor;
  508.             PassInputs.EyeAdaptationTexture = EyeAdaptationTexture;
  509.             PassInputs.bOutputInHDR = bViewFamilyOutputInHDR;
  510.             PassInputs.bGammaOnly = true;
  512.             SceneColor = AddTonemapPass(GraphBuilder, View, PassInputs);
  513.         }
  515.         SceneColor = AddAfterPass(EPass::Tonemap, SceneColor);
  517.         SceneColorAfterTonemap = SceneColor;
  518.     }
  520.     // 可视化后处理Pass.
  521.     if (PassSequence.IsEnabled(EPass::VisualizeStationaryLightOverlap))
  522.     {
  523.         (......)
  525.         SceneColor = AddVisualizeComplexityPass(GraphBuilder, View, PassInputs);
  526.     }
  528.     (......) // 忽略编辑器或可视化代码.
  530.     // 主放大Pass
  531.     if (PassSequence.IsEnabled(EPass::PrimaryUpscale))
  532.     {
  533.         FUpscaleInputs PassInputs;
  534.         PassSequence.AcceptOverrideIfLastPass(EPass::PrimaryUpscale, PassInputs.OverrideOutput);
  535.         PassInputs.SceneColor = SceneColor;
  536.         PassInputs.Method = GetUpscaleMethod();
  537.         PassInputs.Stage = PassSequence.IsEnabled(EPass::SecondaryUpscale) ? EUpscaleStage::PrimaryToSecondary : EUpscaleStage::PrimaryToOutput;
  539.         // 帕尼尼投影(Panini projection)由主放大通道处理。
  540.         PassInputs.PaniniConfig = PaniniConfig;
  542.         SceneColor = AddUpscalePass(GraphBuilder, View, PassInputs);
  543.     }
  545.     // 次放大Pass
  546.     if (PassSequence.IsEnabled(EPass::SecondaryUpscale))
  547.     {
  548.         FUpscaleInputs PassInputs;
  549.         PassSequence.AcceptOverrideIfLastPass(EPass::SecondaryUpscale, PassInputs.OverrideOutput);
  550.         PassInputs.SceneColor = SceneColor;
  551.         PassInputs.Method = View.Family->SecondaryScreenPercentageMethod == ESecondaryScreenPercentageMethod::LowerPixelDensitySimulation ? EUpscaleMethod::SmoothStep : EUpscaleMethod::Nearest;
  552.         PassInputs.Stage = EUpscaleStage::SecondaryToOutput;
  554.         SceneColor = AddUpscalePass(GraphBuilder, View, PassInputs);
  555.     }
  556. }

后处理材质会先声明一个TOverridePassSequence实例，然后按需开启或关闭它们，之后会根据视图是否启用后处理进入两个分支：如果启用，则按序列先后处理每个后处理效果；如果不启用，则只保留最小化的后处理序列，仅包含透明纹理混合和Gamma校正。

至于判断视图是否开启后处理，由以下接口实现：

  1. bool IsPostProcessingEnabled(const FViewInfo& View)
  2. {
  3.     if (View.GetFeatureLevel() >= ERHIFeatureLevel::SM5) // 高于SM5的设备
  4.     {
  5.         return
  6.             // 视图家族开启后处理
  7.              View.Family->EngineShowFlags.PostProcessing &&
  8.             // 并且不是可视化调试模式.
  9.             !View.Family->EngineShowFlags.VisualizeDistanceFieldAO &&
  10.             !View.Family->EngineShowFlags.VisualizeShadingModels &&
  11.             !View.Family->EngineShowFlags.VisualizeMeshDistanceFields &&
  12.             !View.Family->EngineShowFlags.VisualizeGlobalDistanceField &&
  13.             !View.Family->EngineShowFlags.ShaderComplexity;
  14.     }
  15.     // < SM5的设备
  16.     else
  17.     {
  18.         // 视图家族开启后处理且不开启着色复杂度调试模式且是移动端HDR管线.
  19.         return View.Family->EngineShowFlags.PostProcessing && !View.Family->EngineShowFlags.ShaderComplexity && IsMobileHDR();
  20.     }
  21. }

这些特定后处理Pass都有统一的形式：输入纹理、输入参数、输出纹理，输入纹理必然包含SceneColor，输出纹理通常也是SceneColor，并且上一个后处理Pass的SceneColor输出作为下一个后处理Pass的SceneColor输入，以实现不同后处理效果的叠加。

另外，需要注意的是，有一些后处理（屏幕空间）的效果并没有在PassSequence中体现，而是安插在后处理渲染管线的特定位置中。

由于后处理效果是叠加状态，意味着它们的混合（处理）顺序相关，如果处理顺序不当，将得到非预想的结果。

TOverridePassSequence就是给定一个枚举类型，按照特殊规则管理和有序地执行所有的Pass。它的定义如下：

  1. // Engine\Source\Runtime\Renderer\Private\OverridePassSequence.h
  3. template <typename EPass>
  4. class TOverridePassSequence final
  5. {
  6. public:
  7.     TOverridePassSequence(const FScreenPassRenderTarget& InOverrideOutput)
  8.         : OverrideOutput(InOverrideOutput)
  9.     {}
  11.     ~TOverridePassSequence();
  13.     // 设置名字
  14.     void SetName(EPass Pass, const TCHAR* Name);
  15.     void SetNames(const TCHAR* const* Names, uint32 NameCount);
  17.     // 开启指定Pass.
  18.     void SetEnabled(EPass Pass, bool bEnabled);
  19.     bool IsEnabled(EPass Pass) const;
  21.     // 是否最后一个Pass.
  22.     bool IsLastPass(EPass Pass) const;
  24.     // 接受Pass, 如果没有按顺序, 则会报错.
  25.     void AcceptPass(EPass Pass)
  26.     {
  27. #if RDG_ENABLE_DEBUG
  28.         const int32 PassIndex = (int32)Pass;
  30.         check(bFinalized);
  31.         checkf(NextPass == Pass, TEXT("Pass was accepted out of order: %s. Expected %s."), Passes[PassIndex].Name, Passes[(int32)NextPass].Name);
  32.         checkf(Passes[PassIndex].bEnabled, TEXT("Only accepted passes can be enabled: %s."), Passes[PassIndex].Name);
  34.         Passes[PassIndex].bAccepted = true;
  36.         // Walk the remaining passes until we hit one that\'s enabled. This will be the next pass to add.
  37.         for (int32 NextPassIndex = int32(NextPass) + 1; NextPassIndex < PassCountMax; ++NextPassIndex)
  38.         {
  39.             if (Passes[NextPassIndex].bEnabled)
  40.             {
  41.                 NextPass = EPass(NextPassIndex);
  42.                 break;
  43.             }
  44.         }
  45. #endif
  46.     }
  48.     // 如果Pass是最后一个, 则接受覆盖的RT.
  49.     bool AcceptOverrideIfLastPass(EPass Pass, FScreenPassRenderTarget& OutTargetToOverride, const TOptional<int32>& AfterPassCallbackIndex = TOptional<int32>())
  50.     {
  51.         bool bLastAfterPass = AfterPass[(int32)Pass].Num() == 0;
  53.         if (AfterPassCallbackIndex)
  54.         {
  55.             bLastAfterPass = AfterPassCallbackIndex.GetValue() == AfterPass[(int32)Pass].Num() - 1;
  56.         }
  57.         else
  58.         {
  59.             // Display debug information for a Pass unless it is an after pass.
  60.             AcceptPass(Pass);
  61.         }
  63.         // We need to override output only if this is the last pass and the last after pass.
  64.         if (IsLastPass(Pass) && bLastAfterPass)
  65.         {
  66.             OutTargetToOverride = OverrideOutput;
  67.             return true;
  68.         }
  70.         return false;
  71.     }
  73.     // Pass开启结束.
  74.     void Finalize()
  75.     {
  76. #if RDG_ENABLE_DEBUG
  77.         check(!bFinalized);
  78.         bFinalized = true;
  80.         for (int32 PassIndex = 0; PassIndex < PassCountMax; ++PassIndex)
  81.         {
  82.             checkf(Passes[PassIndex].bAssigned, TEXT("Pass was not assigned to enabled or disabled: %s."), Passes[PassIndex].Name);
  83.         }
  84. #endif
  86.         bool bFirstPass = true;
  88.         for (int32 PassIndex = 0; PassIndex < PassCountMax; ++PassIndex)
  89.         {
  90.             if (Passes[PassIndex].bEnabled)
  91.             {
  92.                 if (bFirstPass)
  93.                 {
  94. #if RDG_ENABLE_DEBUG
  95.                     NextPass = (EPass)PassIndex;
  96. #endif
  97.                     bFirstPass = false;
  98.                 }
  99.                 LastPass = (EPass)PassIndex;
  100.             }
  101.         }
  102.     }
  104.     FAfterPassCallbackDelegateArray& GetAfterPassCallbacks(EPass Pass);
  106. private:
  107.     static const int32 PassCountMax = (int32)EPass::MAX;
  109.     struct FPassInfo
  110.     {
  111. #if RDG_ENABLE_DEBUG
  112.         const TCHAR* Name = nullptr;
  113.         bool bAssigned = false;
  114.         bool bAccepted = false;
  115. #endif
  116.         bool bEnabled = false;
  117.     };
  119.     FScreenPassRenderTarget OverrideOutput;
  120.     TStaticArray<FPassInfo, PassCountMax> Passes;
  121.     TStaticArray<FAfterPassCallbackDelegateArray, PassCountMax> AfterPass;
  122.     EPass LastPass = EPass::MAX;
  124. #if RDG_ENABLE_DEBUG
  125.     EPass NextPass = EPass(0);
  126.     bool bFinalized = false;
  127. #endif
  128. };

通过TOverridePassSequence可以方便地实现、管理、执行一组有序的后处理效果。但也需要注意以下几点：

  • PassSequence在处理完通道开启和关闭之后，需要手动调用一次Finalize，否则开发者模式下会报错。

  • TOverridePassSequence需要显示开启和关闭指定通道，如果开启或关闭的通道和实际加入的Pass不一致，则会报错。下面详细地按某些情形讨论PassSequence是否会产生报错（开发模式下）：

    • 通道A被开启，没有向GraphBuilder添加Pass，没有调用AcceptOverrideIfLastPass，会报错。
    • 通道A被开启，向GraphBuilder添加了Pass，没有调用AcceptOverrideIfLastPass，会报错。
    • 通道A被开启，没有向GraphBuilder添加Pass，有调用AcceptOverrideIfLastPass，不会报错。PassSequence无法察觉到这种情况的异常！！
    • 通道A被关闭，向GraphBuilder添加了Pass，有调用AcceptOverrideIfLastPass，会报错。
    • 通道A被关闭，向GraphBuilder添加了Pass，没有调用AcceptOverrideIfLastPass，不会报错。PassSequence无法察觉到这种情况的异常！！
    • 如果通道A和B都被开启，但B在A之前向GraphBuilder添加了Pass并调用AcceptOverrideIfLastPass，会报错。

    举个具体的例子，有以下代码：

    1. // 关闭通道序列的FXAA.
    2. PassSequence.SetEnabled(EPass::FXAA, false);
    4. (......)
    6. // 构造FXAA输入参数
    7. FFXAAInputs PassInputs;
    8. // 调用Pass接受.
    9. PassSequence.AcceptOverrideIfLastPass(EPass::FXAA, PassInputs.OverrideOutput);
    10. PassInputs.SceneColor = SceneColor;
    11. PassInputs.Quality = GetFXAAQuality();
    13. // 加入FXAA通道.
    14. SceneColor = AddFXAAPass(GraphBuilder, View, PassInputs);

    由于以上代码中已经关闭了PassSequence的FXAA通道，但又尝试进行对其添加通道并调用AcceptOverrideIfLastPass，则开发者模式下会报以下错误：

    意思是说Pass没有按照开启的Pass顺序被接受，是在AcceptOverrideIfLastPass内部触发的。

BlendableLocation就是后处理材质的混合位置，它的定义如下：

  1. enum EBlendableLocation
  2. {
  3.     // 色调映射之后.
  4.     BL_AfterTonemapping,
  5.     // 色调映射之前.
  6.     BL_BeforeTonemapping,
  7.     // 半透明组合之前.
  8.     BL_BeforeTranslucency,
  9.     // 替换掉色调映射.
  10.     BL_ReplacingTonemapper,
  11.     // SSR输入.
  12.     BL_SSRInput,
  14.     BL_MAX,
  15. };

EBlendableLocation可在材质编辑器的属性面板中指定：

默认的混合阶段是在色调映射之后（After Tonemapping），但是，我们可以改变混合位置来实现不同的效果。比如，我们的后处理效果需要用到色调映射之前的场景颜色，那么就需要将混合位置改成Before Tonemapping；如果需要自定义色调映射算法，以代替UE的默认色调映射效果，那么可以改成Replacing the Tonemapper；如果我们的后处理效果不希望影响透明物体，则可以改成Before Translucency；如果想实现自定义的SSR算法，则可以改成SSR Input。

为了阐明BlendableLocation在后处理管线中的作用及处理过程，抽取其相关的类型、代码和步骤：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessMaterial.h
  3. using FPostProcessMaterialChain = TArray<const UMaterialInterface*, TInlineAllocator<10>>;
  4. FPostProcessMaterialChain GetPostProcessMaterialChain(const FViewInfo& View, EBlendableLocation Location);
  6. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessMaterial.cpp
  7.     
  8. FPostProcessMaterialChain GetPostProcessMaterialChain(const FViewInfo& View, EBlendableLocation Location)
  9. {
  10.     if (!IsPostProcessMaterialsEnabledForView(View))
  11.     {
  12.         return {};
  13.     }
  15.     const FSceneViewFamily& ViewFamily = *View.Family;
  17.     TArray<FPostProcessMaterialNode, TInlineAllocator<10>> Nodes;
  18.     FBlendableEntry* Iterator = nullptr;
  20.     (......)
  22.     // 遍历视图的后处理设置, 获取所有后处理材质节点. 注意, 这里的迭代器已经指明了Location, 意味着添加到Nodes的都是在Location的材质.
  23.     while (FPostProcessMaterialNode* Data = IteratePostProcessMaterialNodes(View.FinalPostProcessSettings, Location, Iterator))
  24.     {
  25.         check(Data->GetMaterialInterface());
  26.         Nodes.Add(*Data);
  27.     }
  29.     if (!Nodes.Num())
  30.     {
  31.         return {};
  32.     }
  34.     // 按优先级排序.
  35.     ::Sort(Nodes.GetData(), Nodes.Num(), FPostProcessMaterialNode::FCompare());
  37.     FPostProcessMaterialChain OutputChain;
  38.     OutputChain.Reserve(Nodes.Num());
  40.     // 添加材质到输出列表.
  41.     for (const FPostProcessMaterialNode& Node : Nodes)
  42.     {
  43.         OutputChain.Add(Node.GetMaterialInterface());
  44.     }
  46.     return OutputChain;
  47. }
  49. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessing.cpp
  51. void AddPostProcessingPasses(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FPostProcessingInputs& Inputs)
  52. {
  53.     (......)
  54.     
  55.     const FPostProcessMaterialChain PostProcessMaterialAfterTonemappingChain = GetPostProcessMaterialChain(View, BL_AfterTonemapping);
  56.     
  57.     (......)
  58.     
  59.     // 后处理材质链 - Before Translucency
  60.     const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_BeforeTranslucency);
  61.     SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, GetPostProcessMaterialInputs(SceneColor), MaterialChain);
  62.     
  63.     (......)
  64.     
  65.     // 组合半透明纹理到场景颜色纹理中.
  66.     LocalSceneColorTexture = AddSeparateTranslucencyCompositionPass(GraphBuilder, View, SceneColor.Texture, *Inputs.SeparateTranslucencyTextures);
  67.     
  68.     (......)
  69.     
  70.     // 后处理材质链 - Before Tonemapping
  71.     const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_BeforeTonemapping);
  72.     SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, GetPostProcessMaterialInputs(SceneColor), MaterialChain);
  73.     
  74.     (......)
  75.     
  76.     // 后处理材质链 - SSR Input
  77.     const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_SSRInput);
  78.     GraphBuilder.QueueTextureExtraction(PassOutput.Texture, &View.ViewState->PrevFrameViewInfo.CustomSSRInput);
  79.     
  80.     (......)
  81.     
  82.     // 色调映射
  83.     if (PassSequence.IsEnabled(EPass::Tonemap))
  84.     {
  85.         const FPostProcessMaterialChain MaterialChain = GetPostProcessMaterialChain(View, BL_ReplacingTonemapper);
  87.         // 如果存在需要替换UE默认色调映射的材质, 则执行之.
  88.         if (MaterialChain.Num())
  89.         {
  90.             SceneColor = AddPostProcessMaterialPass(GraphBuilder, View, PassInputs, HighestPriorityMaterial);
  91.         }
  92.         // 不存在需要替换UE默认色调映射的材质, 执行UE默认的色调映射.
  93.         else
  94.         {
  95.             SceneColor = AddTonemapPass(GraphBuilder, View, PassInputs);
  96.         }
  97.     }
  99.     // 后处理材质链 - After Tonemapping
  100.     SceneColor = AddPostProcessMaterialChain(GraphBuilder, View, PassInputs, PostProcessMaterialAfterTonemappingChain);
  102.     (......)
  103. }

由以上代码可知，BlendableLocation名符其实，单看Location的字面意思就已经知道它的运行位置。其中最重要的是色调映射，在之前、之中、之后都可以自定义后处理材质，为引擎可扩展性添砖加瓦。

PostProcessMaterial就是处理和渲染BlendableLocation的后处理材质类，其定义和相关类型如下：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessMaterial.h
  3. // 后处理材质输入槽. 
  4. enum class EPostProcessMaterialInput : uint32
  5. {
  6.     SceneColor = 0, // 场景颜色, 总是激活(可用)状态. 来自上一个后处理的输出.
  7.     SeparateTranslucency = 1, // 透明纹理, 总是激活状态.
  8.     CombinedBloom = 2, // 组合的泛光.
  10.     // 仅用于可视化.
  11.     PreTonemapHDRColor = 2,
  12.     PostTonemapHDRColor = 3,
  14.     // 速度.
  15.     Velocity = 4
  16. };
  18. // 后处理材质Uniform Buffer.
  19. BEGIN_SHADER_PARAMETER_STRUCT(FPostProcessMaterialParameters, )
  20.     SHADER_PARAMETER_STRUCT_REF(FViewUniformShaderParameters, View)
  21.     SHADER_PARAMETER_STRUCT_INCLUDE(FSceneTextureShaderParameters, SceneTextures)
  22.     SHADER_PARAMETER_STRUCT(FScreenPassTextureViewportParameters, PostProcessOutput)
  23.     SHADER_PARAMETER_STRUCT_ARRAY(FScreenPassTextureInput, PostProcessInput, [kPostProcessMaterialInputCountMax])
  24.     SHADER_PARAMETER_SAMPLER(SamplerState, PostProcessInput_BilinearSampler)
  25.     SHADER_PARAMETER_RDG_TEXTURE(Texture2D, MobileCustomStencilTexture)
  26.     SHADER_PARAMETER_SAMPLER(SamplerState, MobileCustomStencilTextureSampler)
  27.     SHADER_PARAMETER_RDG_TEXTURE(Texture2D, EyeAdaptationTexture)
  28.     SHADER_PARAMETER_SRV(Buffer<float4>, EyeAdaptationBuffer)
  29.     SHADER_PARAMETER(int32, MobileStencilValueRef)
  30.     SHADER_PARAMETER(uint32, bFlipYAxis)
  31.     SHADER_PARAMETER(uint32, bMetalMSAAHDRDecode)
  32.     RENDER_TARGET_BINDING_SLOTS()
  33. END_SHADER_PARAMETER_STRUCT()
  35. // 后处理材质输入.
  36. struct FPostProcessMaterialInputs
  37. {
  38.     inline void SetInput(EPostProcessMaterialInput Input, FScreenPassTexture Texture)
  39.     {
  40.         Textures[(uint32)Input] = Texture;
  41.     }
  43.     inline FScreenPassTexture GetInput(EPostProcessMaterialInput Input) const
  44.     {
  45.         return Textures[(uint32)Input];
  46.     }
  48.     // 验证纹理有效性.
  49.     inline void Validate() const
  50.     {
  51.         ValidateInputExists(EPostProcessMaterialInput::SceneColor);
  52.         ValidateInputExists(EPostProcessMaterialInput::SeparateTranslucency);
  54.         // Either override output format is valid or the override output texture is; not both.
  55.         if (OutputFormat != PF_Unknown)
  56.         {
  57.             check(OverrideOutput.Texture == nullptr);
  58.         }
  59.         if (OverrideOutput.Texture)
  60.         {
  61.             check(OutputFormat == PF_Unknown);
  62.         }
  64.         check(SceneTextures.SceneTextures || SceneTextures.MobileSceneTextures);
  65.     }
  67.     inline void ValidateInputExists(EPostProcessMaterialInput Input) const
  68.     {
  69.         const FScreenPassTexture Texture = GetInput(EPostProcessMaterialInput::SceneColor);
  70.         check(Texture.IsValid());
  71.     }
  73.     // 可选的, 渲染到指定的RT. 如果没有, 则新的纹理被创建.
  74.     FScreenPassRenderTarget OverrideOutput;
  75.     // 纹理列表.
  76.     TStaticArray<FScreenPassTexture, kPostProcessMaterialInputCountMax> Textures;
  77.     // 输出RT格式.
  78.     EPixelFormat OutputFormat = PF_Unknown;
  79.     // 自定义深度纹理.
  80.     FRDGTextureRef CustomDepthTexture = nullptr;
  82.     // 场景的GBuffer.
  83.     FSceneTextureShaderParameters SceneTextures;
  85.     // 是否翻转Y轴.
  86.     bool bFlipYAxis = false;
  87.     // 是否允许输入的场景颜色作为输出.
  88.     bool bAllowSceneColorInputAsOutput = true;
  89.     // Metal MSAA特殊标记.
  90.     bool bMetalMSAAHDRDecode = false;
  91. };
  93. // 增加后处理材质Pass.
  94. FScreenPassTexture AddPostProcessMaterialPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FPostProcessMaterialInputs& Inputs, const UMaterialInterface* MaterialInterface);
  96. // 增加后处理材质链.
  97. FScreenPassTexture AddPostProcessMaterialChain(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FPostProcessMaterialInputs& Inputs, const FPostProcessMaterialChain& MaterialChain);

下面继续分析在后处理管线需要调用到的AddPostProcessMaterialChain：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessMaterial.cpp
  3. FScreenPassTexture AddPostProcessMaterialChain(
  4.     FRDGBuilder& GraphBuilder,
  5.     const FViewInfo& View,
  6.     const FPostProcessMaterialInputs& InputsTemplate,
  7.     const FPostProcessMaterialChain& Materials)
  8. {
  9.     // 初始化输出为场景颜色的输入.
  10.     FScreenPassTexture Outputs = InputsTemplate.GetInput(EPostProcessMaterialInput::SceneColor);
  12.     (......)
  13.     
  14.     // 遍历材质链, 给每个材质添加一个通道.
  15.     for (const UMaterialInterface* MaterialInterface : Materials)
  16.     {
  17.         FPostProcessMaterialInputs Inputs = InputsTemplate;
  18.         Inputs.SetInput(EPostProcessMaterialInput::SceneColor, Outputs);
  19.         
  20.         (......)
  22.         // 如果不是最后一个材质, 则不应用输出覆盖.
  23.         if (MaterialInterface != Materials.Last())
  24.         {
  25.             Inputs.OverrideOutput = FScreenPassRenderTarget();
  26.             Inputs.bFlipYAxis = false;
  27.         }
  29.         // 增加单个后处理材质通道. (见后面分析)
  30.         Outputs = AddPostProcessMaterialPass(GraphBuilder, View, Inputs, MaterialInterface);
  31.     }
  33.     return Outputs;
  34. }
  36. // 增加单个后处理材质通道.
  37. FScreenPassTexture AddPostProcessMaterialPass(
  38.     FRDGBuilder& GraphBuilder,
  39.     const FViewInfo& View,
  40.     const FPostProcessMaterialInputs& Inputs,
  41.     const UMaterialInterface* MaterialInterface)
  42. {
  43.     // 验证输入有效性.
  44.     Inputs.Validate();
  46.     // 初始化输入数据.
  47.     const FScreenPassTexture SceneColor = Inputs.GetInput(EPostProcessMaterialInput::SceneColor);
  48.     const ERHIFeatureLevel::Type FeatureLevel = View.GetFeatureLevel();
  50.     const FMaterial* Material = nullptr;
  51.     const FMaterialRenderProxy* MaterialRenderProxy = nullptr;
  52.     const FMaterialShaderMap* MaterialShaderMap = nullptr;
  53.     GetMaterialInfo(MaterialInterface, FeatureLevel, Inputs.OutputFormat, Material, MaterialRenderProxy, MaterialShaderMap);
  55.     FRHIDepthStencilState* DefaultDepthStencilState = FScreenPassPipelineState::FDefaultDepthStencilState::GetRHI();
  56.     FRHIDepthStencilState* DepthStencilState = DefaultDepthStencilState;
  58.     FRDGTextureRef DepthStencilTexture = nullptr;
  60.     // Allocate custom depth stencil texture(s) and depth stencil state.
  61.     const ECustomDepthPolicy CustomStencilPolicy = GetMaterialCustomDepthPolicy(Material, FeatureLevel);
  63.     if (CustomStencilPolicy == ECustomDepthPolicy::Enabled)
  64.     {
  65.         check(Inputs.CustomDepthTexture);
  66.         DepthStencilTexture = Inputs.CustomDepthTexture;
  67.         DepthStencilState = GetMaterialStencilState(Material);
  68.     }
  70.     // 混合状态.
  71.     FRHIBlendState* DefaultBlendState = FScreenPassPipelineState::FDefaultBlendState::GetRHI();
  72.     FRHIBlendState* BlendState = DefaultBlendState;
  73.     
  74.     if (IsMaterialBlendEnabled(Material))
  75.     {
  76.         BlendState = GetMaterialBlendState(Material);
  77.     }
  79.     // 处理各种标记.
  80.     const bool bCompositeWithInput = DepthStencilState != DefaultDepthStencilState || BlendState != DefaultBlendState;
  81.     const bool bPrimeOutputColor = bCompositeWithInput || !View.IsFirstInFamily();
  82.     const bool bBackbufferWithDepthStencil = (DepthStencilTexture != nullptr && !GRHISupportsBackBufferWithCustomDepthStencil && Inputs.OverrideOutput.IsValid());
  83.     const bool bCompositeWithInputAndFlipY = bCompositeWithInput && Inputs.bFlipYAxis;
  84.     const bool bCompositeWithInputAndDecode = Inputs.bMetalMSAAHDRDecode && bCompositeWithInput;
  85.     const bool bForceIntermediateTarget = bBackbufferWithDepthStencil || bCompositeWithInputAndFlipY || bCompositeWithInputAndDecode;
  87.     // 渲染输出.
  88.     FScreenPassRenderTarget Output = Inputs.OverrideOutput;
  90.     // 将场景颜色作为输出.
  91.     if (!Output.IsValid() && !MaterialShaderMap->UsesSceneTexture(PPI_PostProcessInput0) && bPrimeOutputColor && !bForceIntermediateTarget && Inputs.bAllowSceneColorInputAsOutput)
  92.     {
  93.         Output = FScreenPassRenderTarget(SceneColor, ERenderTargetLoadAction::ELoad);
  94.     }
  95.     else
  96.     {
  97.         // 创新新的纹理作为输出.
  98.         if (!Output.IsValid() || bForceIntermediateTarget)
  99.         {
  100.             FRDGTextureDesc OutputDesc = SceneColor.Texture->Desc;
  101.             OutputDesc.Reset();
  102.             if (Inputs.OutputFormat != PF_Unknown)
  103.             {
  104.                 OutputDesc.Format = Inputs.OutputFormat;
  105.             }
  106.             OutputDesc.ClearValue = FClearValueBinding(FLinearColor::Black);
  107.             OutputDesc.Flags |= GFastVRamConfig.PostProcessMaterial;
  109.             Output = FScreenPassRenderTarget(GraphBuilder.CreateTexture(OutputDesc, TEXT("PostProcessMaterial")), SceneColor.ViewRect, View.GetOverwriteLoadAction());
  110.         }
  112.         if (bPrimeOutputColor || bForceIntermediateTarget)
  113.         {
  114.             // Copy existing contents to new output and use load-action to preserve untouched pixels.
  115.             if (Inputs.bMetalMSAAHDRDecode)
  116.             {
  117.                 AddMobileMSAADecodeAndDrawTexturePass(GraphBuilder, View, SceneColor, Output);
  118.             }
  119.             else
  120.             {
  121.                 AddDrawTexturePass(GraphBuilder, View, SceneColor, Output);
  122.             }
  123.             Output.LoadAction = ERenderTargetLoadAction::ELoad;
  124.         }
  125.     }
  127.     const FScreenPassTextureViewport SceneColorViewport(SceneColor);
  128.     const FScreenPassTextureViewport OutputViewport(Output);
  130.     RDG_EVENT_SCOPE(GraphBuilder, "PostProcessMaterial %dx%d Material=%s", SceneColorViewport.Rect.Width(), SceneColorViewport.Rect.Height(), *Material->GetFriendlyName());
  132.     const uint32 MaterialStencilRef = Material->GetStencilRefValue();
  134.     const bool bMobilePlatform = IsMobilePlatform(View.GetShaderPlatform());
  136.     // 处理后处理材质参数.
  137.     FPostProcessMaterialParameters* PostProcessMaterialParameters = GraphBuilder.AllocParameters<FPostProcessMaterialParameters>();
  138.     PostProcessMaterialParameters->SceneTextures = Inputs.SceneTextures;
  139.     PostProcessMaterialParameters->View = View.ViewUniformBuffer;
  140.     if (bMobilePlatform)
  141.     {
  142.         PostProcessMaterialParameters->EyeAdaptationBuffer = GetEyeAdaptationBuffer(View);
  143.     }
  144.     else
  145.     {
  146.         PostProcessMaterialParameters->EyeAdaptationTexture = GetEyeAdaptationTexture(GraphBuilder, View);
  147.     }
  148.     PostProcessMaterialParameters->PostProcessOutput = GetScreenPassTextureViewportParameters(OutputViewport);
  149.     PostProcessMaterialParameters->MobileCustomStencilTexture = DepthStencilTexture;
  150.     PostProcessMaterialParameters->MobileCustomStencilTextureSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
  151.     PostProcessMaterialParameters->MobileStencilValueRef = MaterialStencilRef;
  152.     PostProcessMaterialParameters->RenderTargets[0] = Output.GetRenderTargetBinding();
  153.     PostProcessMaterialParameters->bMetalMSAAHDRDecode = Inputs.bMetalMSAAHDRDecode ? 1 : 0;
  155.     // 处理深度模板缓冲.
  156.     if (DepthStencilTexture && !bMobilePlatform)
  157.     {
  158.         PostProcessMaterialParameters->RenderTargets.DepthStencil = FDepthStencilBinding(
  159.             DepthStencilTexture,
  160.             ERenderTargetLoadAction::ELoad,
  161.             ERenderTargetLoadAction::ELoad,
  162.             FExclusiveDepthStencil::DepthRead_StencilRead);
  163.     }
  164.     else if (!DepthStencilTexture && bMobilePlatform && Material->IsStencilTestEnabled())
  165.     {
  166.         PostProcessMaterialParameters->MobileCustomStencilTexture = GSystemTextures.GetBlackDummy(GraphBuilder);
  167.         
  168.         switch (Material->GetStencilCompare())
  169.         {
  170.         case EMaterialStencilCompare::MSC_Less:
  171.             PostProcessMaterialParameters->MobileStencilValueRef = -1;
  172.             break;
  173.         case EMaterialStencilCompare::MSC_LessEqual:
  174.         case EMaterialStencilCompare::MSC_GreaterEqual:
  175.         case EMaterialStencilCompare::MSC_Equal:
  176.             PostProcessMaterialParameters->MobileStencilValueRef = 0;
  177.             break;
  178.         case EMaterialStencilCompare::MSC_Greater:
  179.         case EMaterialStencilCompare::MSC_NotEqual:
  180.             PostProcessMaterialParameters->MobileStencilValueRef = 1;
  181.             break;
  182.         case EMaterialStencilCompare::MSC_Always:
  183.             PostProcessMaterialParameters->MobileStencilValueRef = 256;
  184.             break;
  185.         default:
  186.             break;
  187.         }
  188.     }
  190.     // 系统纹理和采样器.
  191.     PostProcessMaterialParameters->PostProcessInput_BilinearSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();;
  192.     const FScreenPassTexture BlackDummy(GSystemTextures.GetBlackDummy(GraphBuilder));
  193.     GraphBuilder.RemoveUnusedTextureWarning(BlackDummy.Texture);
  194.     FRHISamplerState* PointClampSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
  196.     // 处理材质后处理参数的输入槽(PostProcessInput0~PostProcessInput4).
  197.     for (uint32 InputIndex = 0; InputIndex < kPostProcessMaterialInputCountMax; ++InputIndex)
  198.     {
  199.         FScreenPassTexture Input = Inputs.GetInput((EPostProcessMaterialInput)InputIndex);
  201.         // 如果指定插槽的输入纹理不存在或后处理材质没有用到该插槽，则将输入纹理置空。
  202.         if (!Input.Texture || !MaterialShaderMap->UsesSceneTexture(PPI_PostProcessInput0 + InputIndex))
  203.         {
  204.             Input = BlackDummy;
  205.         }
  207.         PostProcessMaterialParameters->PostProcessInput[InputIndex] = GetScreenPassTextureInput(Input, PointClampSampler);
  208.     }
  210.     const bool bIsMobile = FeatureLevel <= ERHIFeatureLevel::ES3_1;
  211.     PostProcessMaterialParameters->bFlipYAxis = Inputs.bFlipYAxis && !bForceIntermediateTarget;
  213.     // 处理后处理材质的VS和PS.
  214.     FPostProcessMaterialShader::FPermutationDomain PermutationVector;
  215.     PermutationVector.Set<FPostProcessMaterialShader::FMobileDimension>(bIsMobile);
  217.     TShaderRef<FPostProcessMaterialVS> VertexShader = MaterialShaderMap->GetShader<FPostProcessMaterialVS>(PermutationVector);
  218.     TShaderRef<FPostProcessMaterialPS> PixelShader = MaterialShaderMap->GetShader<FPostProcessMaterialPS>(PermutationVector);
  219.     ClearUnusedGraphResources(VertexShader, PixelShader, PostProcessMaterialParameters);
  221.     EScreenPassDrawFlags ScreenPassFlags = EScreenPassDrawFlags::AllowHMDHiddenAreaMask;
  223.     if (PostProcessMaterialParameters->bFlipYAxis)
  224.     {
  225.         ScreenPassFlags |= EScreenPassDrawFlags::FlipYAxis;
  226.     }
  228.     // 增加全屏幕绘制.
  229.     AddDrawScreenPass(
  230.         GraphBuilder,
  231.         RDG_EVENT_NAME("PostProcessMaterial"),
  232.         View,
  233.         OutputViewport,
  234.         SceneColorViewport,
  235.         FScreenPassPipelineState(VertexShader, PixelShader, BlendState, DepthStencilState),
  236.         PostProcessMaterialParameters,
  237.         ScreenPassFlags,
  238.         [&View, VertexShader, PixelShader, MaterialRenderProxy, PostProcessMaterialParameters, MaterialStencilRef](FRHICommandListImmediate& RHICmdList)
  239.     {
  240.         FPostProcessMaterialVS::SetParameters(RHICmdList, VertexShader, View, MaterialRenderProxy, *PostProcessMaterialParameters);
  241.         FPostProcessMaterialPS::SetParameters(RHICmdList, PixelShader, View, MaterialRenderProxy, *PostProcessMaterialParameters);
  242.         RHICmdList.SetStencilRef(MaterialStencilRef);
  243.     });
  245.     // 处理翻转和输出覆盖.
  246.     if (bForceIntermediateTarget && !bCompositeWithInputAndDecode)
  247.     {
  248.         if (!Inputs.bFlipYAxis)
  249.         {
  250.             // We shouldn\'t get here unless we had an override target.
  251.             check(Inputs.OverrideOutput.IsValid());
  252.             AddDrawTexturePass(GraphBuilder, View, Output.Texture, Inputs.OverrideOutput.Texture);
  253.             Output = Inputs.OverrideOutput;
  254.         }
  255.         else
  256.         {
  257.             FScreenPassRenderTarget TempTarget = Output;
  258.             if (Inputs.OverrideOutput.IsValid())
  259.             {
  260.                 Output = Inputs.OverrideOutput;
  261.             }
  262.             else
  263.             {
  264.                 Output = FScreenPassRenderTarget(SceneColor, ERenderTargetLoadAction::ENoAction);
  265.             }
  267.             AddCopyAndFlipTexturePass(GraphBuilder, View, TempTarget.Texture, Output.Texture);
  268.         }
  269.     }
  271.     return MoveTemp(Output);
  272. }

需要注意，在后处理材质中，处理的PostProcessInput0~PostProcessInput4对应着材质编辑器SceneTexture节点的PostProcessInput（下图）。

除了PostProcessInput0被SceneColor占用，其它插槽可以搭载自定义的纹理，以便在材质编辑器中访问。示例：

  1. for (uint32 InputIndex = 0; InputIndex < kPostProcessMaterialInputCountMax; ++InputIndex)
  2. {
  3.     FScreenPassTexture Input = Inputs.GetInput((EPostProcessMaterialInput)InputIndex);
  5.     if (!Input.Texture || !MaterialShaderMap->UsesSceneTexture(PPI_PostProcessInput0 + InputIndex))
  6.     {
  7.         // 如果自定义的输入纹理有效, 则放到插槽4.
  8.         if(MyInput.Texture && InputIndex == 4)
  9.         {
  10.             Input = MyInput;
  11.         }
  12.         else
  13.         {
  14.             Input = BlackDummy;
  15.         }
  16.     }
  18.     PostProcessMaterialParameters->PostProcessInput[InputIndex] = GetScreenPassTextureInput(Input, PointClampSampler);
  19. }

这样就实现了搭载自定义的纹理。当然这种方式带点侵入性，如果需要更加优雅的方式，则需要扩展EPostProcessMaterialInput并修改相关代码。

 

本章将阐述UE内置的常见的后处理技术，包含部分屏幕空间的渲染技术。

对图形学或PBR有所了解的同学应该清楚，现代图形引擎中存在线性空间的渲染管线和传统的sRGB空间的渲染管线，它们之间的区别如下图所示：

上：Gamma空间渲染管线。在渲染前后不会对纹理颜色执行线性转换。

下：线性空间渲染管线。在shader前期去除了Gamma校正，在shader后期恢复Gamma校正。

为什么线性空间的渲染管线要在前期和后期分别去掉又加回Gamma校正呢？

这其实是历史遗留的问题。

早期的电视机采用CRT显像管，由于电压的强度与人眼感知的亮度不成正比，成指数为0.45的指数级曲线。为了解决这个问题，就引入指数为2.2的Gamma校正，强行提升显示图像的数据让电压与人眼感知亮度成线性比例。久而久之，之后的很多硬件设备、色彩空间(如sRGB)、文件格式（如jpeg,png等）、DDC软件（如ps）默认都执行了Gamma校正，并且一直沿用至今。

虽然当今的液晶显示器不再需要Gamma校正，但为了兼容已经广泛存在的有着Gamma校正的色彩空间及标准，也不得不保留Gamma校正。所以在shader后期还是要恢复Gamma校正，以便图片能够在显示设备正常显示。

两个不同的渲染管线，对最终的光照结果会产生较大的差异：

上半部分是线性空间，在不同光强度的反应下，能够得到更加物理正确的结果；下半部分是Gamma空间的计算，对光强度的反应过于强烈，得到过暗或过曝的画面。

Gamma和线性空间的颜色是可以互相转换的，利用简单的指数运算即可：

\[c\’= f(c) = c^n = pow(c, n)
\]

其中，\(c\)是输入颜色，\(c\’\)是输出颜色，\(n\)是Gamma校正指数。下图中，分别是\(n\)分别取0.45, 1.0, 2.2的Gamma校正曲线图：

1.0是线性空间，输入输出值一样；0.45和2.2是Gamma曲线，处于此空间的色彩将被提亮或压暗，并且0.45⋅2.2≈1.00.45⋅2.2≈1.0，以保证两次Gamma校正之后能够恢复到线性空间：

\[c\’ = f_{gamma2.2}(f_{gamma0.45}(c)) = ({c^{0.45}})^{2.2} = c^{0.45 \cdot 2.2} = c^{0.99} \approx c
\]

默认情况下，UE的渲染管线已经是线性空间的，意味着所有纹理和颜色在shader计算过程中需要在保持在线性空间状态，最后呈现到屏幕前又需要经过Gamma校正转换成sRGB（如果显示器支持HDR或线性空间，则可以不需要）。

通常情况下，UE在导入原始的纹理资源时，已经将纹理转换成了线性空间：

导入sRGB的图片后，UE默认将其转换成线性空间。

如果导入的图片已经是线性空间的，则需要去掉sRGB的勾选。如果想在材质编辑器中动态地转换Gamma校正，则可以使用类似以下的材质节点：

当然，绝大多数情况下，在材质编辑器中，我们不需要关心Gamma和线性空间的转换，因为UE已经在背后为我们进行了处理。通常情况下，Gamma恢复会和色调映射一起处理。

HDR（High Dynamic Range）即高动态范围，拥有更高的对比度和更广的色域，可分为基于软件的后处理HDR和基于硬件的显示设备HDR。

与HDR相对立的是LDR（Low Dynamic Range，低动态范围）。

由于UE等现代引擎都已经支持了线性空间的渲染管线，由此在光照计算过程中可能产生大于普通白色（颜色值为1.0）的成百上千倍的亮度，此时，如果不用某些曲线将其压缩到合理的值域，在很多设备都会显示异常。

色调映射（Tone Mapping）就是将过高的颜色值调整到和显示设备兼容的色彩范围。

UE支持基于物理的色调映射技术，被称为ACES Tonemapper。ACES Tonemapper采用以下的曲线来映射线性空间的颜色：

实现代码如下：

  1. float3 ACESToneMapping(float3 color, float adapted_lum)
  2. {
  3.     const float A = 2.51f;
  4.     const float B = 0.03f;
  5.     const float C = 2.43f;
  6.     const float D = 0.59f;
  7.     const float E = 0.14f;
  9.     color *= adapted_lum;
  10.     return (color * (A * color + B)) / (color * (C * color + D) + E);
  11. }

相较旧的色调映射器，ACES Tonemapper的渲染结果更加接近物理真实：

上图是UE旧的色调映射，下图采用了ACES的色调映射。可见新的色调映射在自发光率足够大时，颜色开始变白，更符合物理真实。

UE的实际实现代码远上面介绍的复杂，对应的C++实现代码如下：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessTonemap.cpp
  3. FScreenPassTexture AddTonemapPass(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FTonemapInputs& Inputs)
  4. {
  5.     const FSceneViewFamily& ViewFamily = *(View.Family);
  6.     const FPostProcessSettings& PostProcessSettings = View.FinalPostProcessSettings;
  8.     const bool bIsEyeAdaptationResource = (View.GetFeatureLevel() >= ERHIFeatureLevel::SM5) ? Inputs.EyeAdaptationTexture != nullptr : Inputs.EyeAdaptationBuffer != nullptr;
  9.     const bool bEyeAdaptation = ViewFamily.EngineShowFlags.EyeAdaptation && bIsEyeAdaptationResource;
  11.     const FScreenPassTextureViewport SceneColorViewport(Inputs.SceneColor);
  13.     FScreenPassRenderTarget Output = Inputs.OverrideOutput;
  15.     // 创建输出纹理.
  16.     if (!Output.IsValid())
  17.     {
  18.         FRDGTextureDesc OutputDesc = Inputs.SceneColor.Texture->Desc;
  19.         OutputDesc.Reset();
  20.         OutputDesc.Flags |= View.bUseComputePasses ? TexCreate_UAV : TexCreate_RenderTargetable;
  21.         OutputDesc.Flags |= GFastVRamConfig.Tonemap;
  22.         // RGB is the color in LDR, A is the luminance for PostprocessAA
  23.         OutputDesc.Format = Inputs.bOutputInHDR ? GRHIHDRDisplayOutputFormat : PF_B8G8R8A8;
  24.         OutputDesc.ClearValue = FClearValueBinding(FLinearColor(0, 0, 0, 0));
  26.         const FTonemapperOutputDeviceParameters OutputDeviceParameters = GetTonemapperOutputDeviceParameters(*View.Family);
  27.         const ETonemapperOutputDevice OutputDevice = static_cast<ETonemapperOutputDevice>(OutputDeviceParameters.OutputDevice);
  29.         if (OutputDevice == ETonemapperOutputDevice::LinearEXR)
  30.         {
  31.             OutputDesc.Format = PF_A32B32G32R32F;
  32.         }
  33.         if (OutputDevice == ETonemapperOutputDevice::LinearNoToneCurve || OutputDevice == ETonemapperOutputDevice::LinearWithToneCurve)
  34.         {
  35.             OutputDesc.Format = PF_FloatRGBA;
  36.         }
  38.         Output = FScreenPassRenderTarget(
  39.             GraphBuilder.CreateTexture(OutputDesc, TEXT("Tonemap")),
  40.             Inputs.SceneColor.ViewRect,
  41.             ERenderTargetLoadAction::EClear);
  42.     }
  44.     const FScreenPassTextureViewport OutputViewport(Output);
  46.     FRHITexture* BloomDirtMaskTexture = GBlackTexture->TextureRHI;
  48.     if (PostProcessSettings.BloomDirtMask && PostProcessSettings.BloomDirtMask->Resource)
  49.     {
  50.         BloomDirtMaskTexture = PostProcessSettings.BloomDirtMask->Resource->TextureRHI;
  51.     }
  53.     // 采样器.
  54.     FRHISamplerState* BilinearClampSampler = TStaticSamplerState<SF_Bilinear, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
  55.     FRHISamplerState* PointClampSampler = TStaticSamplerState<SF_Point, AM_Clamp, AM_Clamp, AM_Clamp>::GetRHI();
  57.     const float DefaultEyeExposure = bEyeAdaptation ? 0.0f : GetEyeAdaptationFixedExposure(View);
  59.     const float SharpenDiv6 = FMath::Clamp(CVarTonemapperSharpen.GetValueOnRenderThread(), 0.0f, 10.0f) / 6.0f;
  61.     // 处理色差参数.
  62.     FVector4 ChromaticAberrationParams;
  63.     {
  64.         // 处理场景颜色边缘
  65.         // 从百分比到分数
  66.         float Offset = 0.0f;
  67.         float StartOffset = 0.0f;
  68.         float Multiplier = 1.0f;
  70.         if (PostProcessSettings.ChromaticAberrationStartOffset < 1.0f - KINDA_SMALL_NUMBER)
  71.         {
  72.             Offset = PostProcessSettings.SceneFringeIntensity * 0.01f;
  73.             StartOffset = PostProcessSettings.ChromaticAberrationStartOffset;
  74.             Multiplier = 1.0f / (1.0f - StartOffset);
  75.         }
  77.         // 基色的波长，单位是纳米.
  78.         const float PrimaryR = 611.3f;
  79.         const float PrimaryG = 549.1f;
  80.         const float PrimaryB = 464.3f;
  82.         // 简单透镜的色差在波长上大致是线性的.
  83.         float ScaleR = 0.007f * (PrimaryR - PrimaryB);
  84.         float ScaleG = 0.007f * (PrimaryG - PrimaryB);
  85.         ChromaticAberrationParams = FVector4(Offset * ScaleR * Multiplier, Offset * ScaleG * Multiplier, StartOffset, 0.f);
  86.     }
  88.     // 处理色调映射参数.
  89.     FTonemapParameters CommonParameters;
  90.     CommonParameters.View = View.ViewUniformBuffer;
  91.     CommonParameters.FilmGrain = GetFilmGrainParameters(View);
  92.     CommonParameters.OutputDevice = GetTonemapperOutputDeviceParameters(ViewFamily);
  93.     CommonParameters.Color = GetScreenPassTextureViewportParameters(SceneColorViewport);
  94.     if (Inputs.Bloom.Texture)
  95.     {
  96.         const FScreenPassTextureViewport BloomViewport(Inputs.Bloom);
  97.         CommonParameters.Bloom = GetScreenPassTextureViewportParameters(BloomViewport);
  98.         CommonParameters.ColorToBloom = GetScreenPassTextureViewportTransform(CommonParameters.Color, CommonParameters.Bloom);
  99.     }
  100.     CommonParameters.Output = GetScreenPassTextureViewportParameters(OutputViewport);
  101.     CommonParameters.ColorTexture = Inputs.SceneColor.Texture;
  102.     CommonParameters.BloomTexture = Inputs.Bloom.Texture;
  103.     CommonParameters.EyeAdaptationTexture = Inputs.EyeAdaptationTexture;
  104.     CommonParameters.ColorGradingLUT = Inputs.ColorGradingTexture;
  105.     CommonParameters.BloomDirtMaskTexture = BloomDirtMaskTexture;
  106.     CommonParameters.ColorSampler = BilinearClampSampler;
  107.     CommonParameters.BloomSampler = BilinearClampSampler;
  108.     CommonParameters.ColorGradingLUTSampler = BilinearClampSampler;
  109.     CommonParameters.BloomDirtMaskSampler = BilinearClampSampler;
  110.     CommonParameters.ColorScale0 = PostProcessSettings.SceneColorTint;
  111.     CommonParameters.ColorScale1 = FLinearColor::White * PostProcessSettings.BloomIntensity;
  112.     CommonParameters.BloomDirtMaskTint = PostProcessSettings.BloomDirtMaskTint * PostProcessSettings.BloomDirtMaskIntensity;
  113.     CommonParameters.ChromaticAberrationParams = ChromaticAberrationParams;
  114.     CommonParameters.TonemapperParams = FVector4(PostProcessSettings.VignetteIntensity, SharpenDiv6, 0.0f, 0.0f);
  115.     CommonParameters.SwitchVerticalAxis = Inputs.bFlipYAxis;
  116.     CommonParameters.DefaultEyeExposure = DefaultEyeExposure;
  117.     CommonParameters.EditorNITLevel = EditorNITLevel;
  118.     CommonParameters.bOutputInHDR = ViewFamily.bIsHDR;
  119.     CommonParameters.LensPrincipalPointOffsetScale = View.LensPrincipalPointOffsetScale;
  120.     CommonParameters.LensPrincipalPointOffsetScaleInverse.X = -View.LensPrincipalPointOffsetScale.X / View.LensPrincipalPointOffsetScale.Z;
  121.     CommonParameters.LensPrincipalPointOffsetScaleInverse.Y = -View.LensPrincipalPointOffsetScale.Y / View.LensPrincipalPointOffsetScale.W;
  122.     CommonParameters.LensPrincipalPointOffsetScaleInverse.Z = 1.0f / View.LensPrincipalPointOffsetScale.Z;
  123.     CommonParameters.LensPrincipalPointOffsetScaleInverse.W = 1.0f / View.LensPrincipalPointOffsetScale.W;
  124.     CommonParameters.EyeAdaptationBuffer = Inputs.EyeAdaptationBuffer;
  126.     // 处理桌面版色调映射的排列.
  127.     TonemapperPermutation::FDesktopDomain DesktopPermutationVector;
  128.     {
  129.         TonemapperPermutation::FCommonDomain CommonDomain = TonemapperPermutation::BuildCommonPermutationDomain(View, Inputs.bGammaOnly, Inputs.bFlipYAxis, Inputs.bMetalMSAAHDRDecode);
  130.         DesktopPermutationVector.Set<TonemapperPermutation::FCommonDomain>(CommonDomain);
  132.         if (!CommonDomain.Get<TonemapperPermutation::FTonemapperGammaOnlyDim>())
  133.         {
  134.             // 量化颗粒.
  135.             {
  136.                 static TConsoleVariableData<int32>* CVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.Tonemapper.GrainQuantization"));
  137.                 const int32 Value = CVar->GetValueOnRenderThread();
  138.                 DesktopPermutationVector.Set<TonemapperPermutation::FTonemapperGrainQuantizationDim>(Value > 0);
  139.             }
  141.             DesktopPermutationVector.Set<TonemapperPermutation::FTonemapperColorFringeDim>(PostProcessSettings.SceneFringeIntensity > 0.01f);
  142.         }
  144.         DesktopPermutationVector.Set<TonemapperPermutation::FTonemapperOutputDeviceDim>(ETonemapperOutputDevice(CommonParameters.OutputDevice.OutputDevice));
  146.         DesktopPermutationVector = TonemapperPermutation::RemapPermutation(DesktopPermutationVector, View.GetFeatureLevel());
  147.     }
  149.     const bool bComputePass = (Output.Texture->Desc.Flags & TexCreate_UAV) == TexCreate_UAV ? View.bUseComputePasses : false;
  151.     if (bComputePass) // 启用CS.
  152.     {
  153.         FTonemapCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FTonemapCS::FParameters>();
  154.         PassParameters->Tonemap = CommonParameters;
  155.         PassParameters->RWOutputTexture = GraphBuilder.CreateUAV(Output.Texture);
  157.         FTonemapCS::FPermutationDomain PermutationVector;
  158.         PermutationVector.Set<TonemapperPermutation::FDesktopDomain>(DesktopPermutationVector);
  159.         PermutationVector.Set<TonemapperPermutation::FTonemapperEyeAdaptationDim>(bEyeAdaptation);
  161.         TShaderMapRef<FTonemapCS> ComputeShader(View.ShaderMap, PermutationVector);
  163.         FComputeShaderUtils::AddPass(
  164.             GraphBuilder,
  165.             RDG_EVENT_NAME("Tonemap %dx%d (CS GammaOnly=%d)", OutputViewport.Rect.Width(), OutputViewport.Rect.Height(), Inputs.bGammaOnly),
  166.             ComputeShader,
  167.             PassParameters,
  168.             FComputeShaderUtils::GetGroupCount(OutputViewport.Rect.Size(), FIntPoint(GTonemapComputeTileSizeX, GTonemapComputeTileSizeY)));
  169.     }
  170.     else // 启用PS
  171.     {
  172.         FTonemapPS::FParameters* PassParameters = GraphBuilder.AllocParameters<FTonemapPS::FParameters>();
  173.         PassParameters->Tonemap = CommonParameters;
  174.         PassParameters->RenderTargets[0] = Output.GetRenderTargetBinding();
  176.         FTonemapVS::FPermutationDomain VertexPermutationVector;
  177.         VertexPermutationVector.Set<TonemapperPermutation::FTonemapperSwitchAxis>(Inputs.bFlipYAxis);
  178.         VertexPermutationVector.Set<TonemapperPermutation::FTonemapperEyeAdaptationDim>(bEyeAdaptation);
  180.         TShaderMapRef<FTonemapVS> VertexShader(View.ShaderMap, VertexPermutationVector);
  181.         TShaderMapRef<FTonemapPS> PixelShader(View.ShaderMap, DesktopPermutationVector);
  183.         const bool bIsStereo = IStereoRendering::IsStereoEyeView(View);
  184.         FRHIBlendState* BlendState = Inputs.bWriteAlphaChannel || bIsStereo ? FScreenPassPipelineState::FDefaultBlendState::GetRHI() : TStaticBlendStateWriteMask<CW_RGB>::GetRHI();
  185.         FRHIDepthStencilState* DepthStencilState = FScreenPassPipelineState::FDefaultDepthStencilState::GetRHI();
  187.         EScreenPassDrawFlags DrawFlags = EScreenPassDrawFlags::AllowHMDHiddenAreaMask;
  189.         // 绘制全屏纹理.
  190.         AddDrawScreenPass(
  191.             GraphBuilder,
  192.             RDG_EVENT_NAME("Tonemap %dx%d (PS GammaOnly=%d)", OutputViewport.Rect.Width(), OutputViewport.Rect.Height(), Inputs.bGammaOnly),
  193.             View,
  194.             OutputViewport,
  195.             SceneColorViewport,
  196.             FScreenPassPipelineState(VertexShader, PixelShader, BlendState, DepthStencilState),
  197.             PassParameters,
  198.             DrawFlags,
  199.             [VertexShader, PixelShader, PassParameters](FRHICommandList& RHICmdList)
  200.         {
  201.             SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), PassParameters->Tonemap);
  202.             SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
  203.         });
  204.     }
  206.     return MoveTemp(Output);
  207. }

由于在笔者的PC电脑上，运行的是PS分支的色调映射，下面就分析其使用的PS及相关代码：

  1. // Engine\Shaders\Private\PostProcessTonemap.usf
  3. // PS入口.
  4. void MainPS(
  5.     in noperspective float2 UV : TEXCOORD0,
  6.     in noperspective float3 InExposureScaleVignette : TEXCOORD1,
  7.     in noperspective float4 GrainUV : TEXCOORD2,
  8.     in noperspective float2 ScreenPos : TEXCOORD3,
  9.     in noperspective float2 FullViewUV : TEXCOORD4,
  10.     float4 SvPosition : SV_POSITION,        // after all interpolators
  11.     out float4 OutColor : SV_Target0
  12.     )
  13. {
  14.     OutColor = TonemapCommonPS(UV, InExposureScaleVignette, GrainUV, ScreenPos, FullViewUV, SvPosition);
  15. }

PS主入口会调用TonemapCommonPS，由于TonemapCommonPS存在大量宏定义，影响正常主流程分析，下面直接用RenderDoc截帧得到的简化版代码：

  1. // 注意是RenderDoc截帧得到的简化版代码, 非原版代码.
  2. float4 TonemapCommonPS(
  3.     float2 UV,
  4.     float3 ExposureScaleVignette,
  5.     float4 GrainUV,
  6.     float2 ScreenPos,
  7.     float2 FullViewUV,
  8.     float4 SvPosition
  9.     )
  10. {
  11.     float4 OutColor = 0;
  13.     const float OneOverPreExposure = View_OneOverPreExposure;
  14.     float  Grain = GrainFromUV(GrainUV.zw);
  15.     float2 SceneUV = UV.xy;
  16.     
  17.     // 获取场景颜色
  18.     float4  SceneColor = SampleSceneColor(SceneUV);
  19.     SceneColor.rgb *= OneOverPreExposure;
  20.     
  21.     float ExposureScale = ExposureScaleVignette.x;
  22.     float SharpenMultiplierDiv6 = TonemapperParams.y;
  23.     
  24.     float3  LinearColor = SceneColor.rgb * ColorScale0.rgb;
  25.     
  26.     // Bloom
  27.     float2 BloomUV = ColorToBloom_Scale * UV + ColorToBloom_Bias;
  28.     BloomUV = clamp(BloomUV, Bloom_UVViewportBilinearMin, Bloom_UVViewportBilinearMax);
  29.     float4 CombinedBloom = Texture2DSample(BloomTexture, BloomSampler, BloomUV);
  30.     CombinedBloom.rgb *= OneOverPreExposure;
  32.     // 暗角参数.
  33.     float2 DirtLensUV = ConvertScreenViewportSpaceToLensViewportSpace(ScreenPos) * float2(1.0f, -1.0f);
  34.     float3 BloomDirtMaskColor = Texture2DSample(BloomDirtMaskTexture, BloomDirtMaskSampler, DirtLensUV * .5f + .5f).rgb * BloomDirtMaskTint.rgb;
  35.     
  36.     LinearColor += CombinedBloom.rgb * (ColorScale1.rgb + BloomDirtMaskColor);
  37.     LinearColor *= ExposureScale;
  38.     // 暗角.
  39.     LinearColor.rgb *= ComputeVignetteMask( ExposureScaleVignette.yz, TonemapperParams.x );
  41.     // LUT
  42.     float3  OutDeviceColor = ColorLookupTable(LinearColor);
  44.     // 颗粒.
  45.     float  LuminanceForPostProcessAA = dot(OutDeviceColor,  float3 (0.299f, 0.587f, 0.114f));
  46.     float  GrainQuantization = 1.0/256.0;
  47.     float  GrainAdd = (Grain * GrainQuantization) + (-0.5 * GrainQuantization);
  48.     OutDeviceColor.rgb += GrainAdd;
  50.     OutColor = float4(OutDeviceColor, saturate(LuminanceForPostProcessAA));
  52.     // HDR输出.
  53.     [branch]
  54.     if(bOutputInHDR)
  55.     {
  56.         OutColor.rgb = ST2084ToLinear(OutColor.rgb);
  57.         OutColor.rgb = OutColor.rgb / EditorNITLevel;
  58.         OutColor.rgb = LinearToPostTonemapSpace(OutColor.rgb);
  59.     }
  61.     return OutColor;
  62. }

色调映射阶段处理和组合了颗粒、暗角、Bloom、曝光、LUT、HDR等处理，不过，这里有点奇怪，为什么没有找到色调映射相关的代码？

结合RenderDoc截帧，可以发现端倪，原来答案就藏在ColorLookupTable，这里的LUT查找不是简单的ColorGrading之类的效果，而是将执行了色调映射。下面进入ColorLookupTable：

  1. Texture3D ColorGradingLUT;
  2. SamplerState ColorGradingLUTSampler;
  3. static const float LUTSize = 32;
  5. float3 LinToLog( float3 LinearColor )
  6. {
  7.     const float LinearRange = 14;
  8.     const float LinearGrey = 0.18;
  9.     const float ExposureGrey = 444;
  11.     // 使用剥离，“纯对数”公式。参数化的灰点和动态范围覆盖。
  12.     float3 LogColor = log2(LinearColor) / LinearRange - log2(LinearGrey) / LinearRange + ExposureGrey / 1023.0;
  13.     LogColor = saturate( LogColor );
  15.     return LogColor;
  16. }
  18. float3  ColorLookupTable(  float3  LinearColor )
  19. {
  20.     float3 LUTEncodedColor;
  21.     // 线性转Log空间.
  22.     LUTEncodedColor = LinToLog( LinearColor + LogToLin( 0 ) );
  24.     // 将float转成int.
  25.     float3 UVW = LUTEncodedColor * ((LUTSize - 1) / LUTSize) + (0.5f / LUTSize);
  26.     // 采样3D的ColorGradingLUT纹理.
  27.     float3  OutDeviceColor = Texture3DSample( ColorGradingLUT, ColorGradingLUTSampler, UVW ).rgb;
  29.     return OutDeviceColor * 1.05;
  30. }

下面简单分析ColorGradingLUT的生成过程。从截帧数据可以看到ColorGradingLUT是在Tonemap之前的CombineLUT生成的：

它是一个32x32x32的3D纹理，下图是切片0的颜色值（放大8倍）：

需要注意的是，ColorGradingLUT会每帧动态生成，根据场景颜色动态调整，不是生成一次之后就缓存起来。下面直接进入其使用的PS代码（RenderDoc截帧的简化版本）：

  1. // Engine\Shaders\Private\PostProcessCombineLUTs.usf
  3. // 校正颜色.
  4. float3 ColorCorrect( float3 WorkingColor,
  5.     float4 ColorSaturation,
  6.     float4 ColorContrast,
  7.     float4 ColorGamma,
  8.     float4 ColorGain,
  9.     float4 ColorOffset )
  10. {
  11.     float Luma = dot( WorkingColor, AP1_RGB2Y );
  12.     WorkingColor = max( 0, lerp( Luma.xxx, WorkingColor, ColorSaturation.xyz*ColorSaturation.w ) );
  13.     WorkingColor = pow( WorkingColor * (1.0 / 0.18), ColorContrast.xyz*ColorContrast.w ) * 0.18;
  14.     WorkingColor = pow( WorkingColor, 1.0 / (ColorGamma.xyz*ColorGamma.w) );
  15.     WorkingColor = WorkingColor * (ColorGain.xyz * ColorGain.w) + (ColorOffset.xyz + ColorOffset.w);
  16.     return WorkingColor;
  17. }
  19. // 对颜色的阴影/中调/高调执行校正.
  20. float3 ColorCorrectAll( float3 WorkingColor )
  21. {
  22.     float Luma = dot( WorkingColor, AP1_RGB2Y );
  24.     float3 CCColorShadows = ColorCorrect(...);
  25.     float CCWeightShadows = 1- smoothstep(0, ColorCorrectionShadowsMax, Luma);
  27.     float3 CCColorHighlights = ColorCorrect(...);
  28.     float CCWeightHighlights = smoothstep(ColorCorrectionHighlightsMin, 1, Luma);
  30.     float3 CCColorMidtones = ColorCorrect...);
  31.     float CCWeightMidtones = 1 - CCWeightShadows - CCWeightHighlights;
  33.     float3 WorkingColorSMH = CCColorShadows*CCWeightShadows + CCColorMidtones*CCWeightMidtones + CCColorHighlights*CCWeightHighlights;
  35.     return WorkingColorSMH;
  36. }
  38. float BlueCorrection;
  39. float ExpandGamut;
  40. float ToneCurveAmount;
  42. float4 CombineLUTsCommon(float2 InUV, uint InLayerIndex)
  43. {
  44.     // 计算自然色彩.
  45.     float4 Neutral;
  46.     {
  47.         float2 UV = InUV - float2(0.5f / LUTSize, 0.5f / LUTSize);
  48.         Neutral = float4(UV * LUTSize / (LUTSize - 1), InLayerIndex / (LUTSize - 1), 0);
  49.     }
  51.     float4 OutColor = 0;
  53.     // 初始化颜色转换系数.
  54.     const float3x3 sRGB_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
  55.     const float3x3 AP1_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
  56.     const float3x3 AP0_2_AP1 = mul( XYZ_2_AP1_MAT, AP0_2_XYZ_MAT );
  57.     const float3x3 AP1_2_AP0 = mul( XYZ_2_AP0_MAT, AP1_2_XYZ_MAT );
  58.     const float3x3 AP1_2_Output = OuputGamutMappingMatrix( OutputGamut );
  60.     float3 LUTEncodedColor = Neutral.rgb;
  61.     float3 LinearColor;
  63.     if (GetOutputDevice() >= 3)
  64.         LinearColor = ST2084ToLinear(LUTEncodedColor) * LinearToNitsScaleInverse;
  65.     else
  66.         LinearColor = LogToLin( LUTEncodedColor ) - LogToLin( 0 );
  68.     // 色彩平衡.
  69.     float3 BalancedColor = WhiteBalance( LinearColor );
  70.     
  71.     // 计算颜色调整系数.
  72.     float3 ColorAP1 = mul( sRGB_2_AP1, BalancedColor );
  73.     if (!bUseMobileTonemapper)
  74.     {
  75.         float LumaAP1 = dot( ColorAP1, AP1_RGB2Y );
  76.         float3 ChromaAP1 = ColorAP1 / LumaAP1;
  77.         float ChromaDistSqr = dot( ChromaAP1 - 1, ChromaAP1 - 1 );
  78.         float ExpandAmount = ( 1 - exp2( -4 * ChromaDistSqr ) ) * ( 1 - exp2( -4 * ExpandGamut * LumaAP1*LumaAP1 ) );
  80.         const float3x3 Wide_2_XYZ_MAT =
  81.         {
  82.             0.5441691, 0.2395926, 0.1666943,
  83.             0.2394656, 0.7021530, 0.0583814,
  84.             -0.0023439, 0.0361834, 1.0552183,
  85.         };
  87.         const float3x3 Wide_2_AP1 = mul( XYZ_2_AP1_MAT, Wide_2_XYZ_MAT );
  88.         const float3x3 ExpandMat = mul( Wide_2_AP1, AP1_2_sRGB );
  90.         float3 ColorExpand = mul( ExpandMat, ColorAP1 );
  91.         ColorAP1 = lerp( ColorAP1, ColorExpand, ExpandAmount );
  92.     }
  94.     // 校正颜色的高中低调.
  95.     ColorAP1 = ColorCorrectAll( ColorAP1 );
  96.     float3 GradedColor = mul( AP1_2_sRGB, ColorAP1 );
  98.     // 蓝色校正.
  99.     const float3x3 BlueCorrect =
  100.     {
  101.         0.9404372683, -0.0183068787, 0.0778696104,
  102.         0.0083786969, 0.8286599939, 0.1629613092,
  103.         0.0005471261, -0.0008833746, 1.0003362486
  104.     };
  105.     const float3x3 BlueCorrectInv =
  106.     {
  107.         1.06318, 0.0233956, -0.0865726,
  108.         -0.0106337, 1.20632, -0.19569,
  109.         -0.000590887, 0.00105248, 0.999538
  110.     };
  111.     const float3x3 BlueCorrectAP1 = mul( AP0_2_AP1, mul( BlueCorrect, AP1_2_AP0 ) );
  112.     const float3x3 BlueCorrectInvAP1 = mul( AP0_2_AP1, mul( BlueCorrectInv, AP1_2_AP0 ) );
  114.     ColorAP1 = lerp( ColorAP1, mul( BlueCorrectAP1, ColorAP1 ), BlueCorrection );
  115.     
  116.     // Film色调映射.
  117.     float3 ToneMappedColorAP1 = FilmToneMap( ColorAP1 );
  118.     
  119.     ColorAP1 = lerp(ColorAP1, ToneMappedColorAP1, ToneCurveAmount);
  120.     ColorAP1 = lerp( ColorAP1, mul( BlueCorrectInvAP1, ColorAP1 ), BlueCorrection );
  122.     float3 FilmColor = max(0, mul( AP1_2_sRGB, ColorAP1 ));
  123.     FilmColor = ColorCorrection( FilmColor );
  124.     
  125.     float3 FilmColorNoGamma = lerp( FilmColor * ColorScale, OverlayColor.rgb, OverlayColor.a );
  126.     GradedColor = lerp(GradedColor * ColorScale, OverlayColor.rgb, OverlayColor.a);
  127.     
  128.     FilmColor = pow( max(0, FilmColorNoGamma), InverseGamma.y );
  130.     float3  OutDeviceColor = 0;
  131.     
  132.     // 根据输出设备的类型调用不同的色彩处理, 默认是0.
  133.     if( GetOutputDevice() == 0 )
  134.     {
  135.         // 高阶(原始)颜色是FilmColor.
  136.         float3 OutputGamutColor = FilmColor;
  137.         // 线性空间转到sRGB.
  138.         OutDeviceColor = LinearToSrgb( OutputGamutColor );
  139.     }
  140.     else if( GetOutputDevice() == 1 )
  141.     {
  142.         float3 OutputGamutColor = mul( AP1_2_Output, mul( sRGB_2_AP1, FilmColor ) );
  143.         OutDeviceColor = LinearTo709Branchless( OutputGamutColor );
  144.     }
  145.     else if( GetOutputDevice() == 3 || GetOutputDevice() == 5 )
  146.     {
  147.         float3 ODTColor = ACESOutputTransforms1000( GradedColor );
  148.         ODTColor = mul( AP1_2_Output, ODTColor );
  149.         OutDeviceColor = LinearToST2084( ODTColor );
  150.     }
  151.     else if( GetOutputDevice() == 4 || GetOutputDevice() == 6 )
  152.     {
  153.         float3 ODTColor = ACESOutputTransforms2000( GradedColor );
  154.         ODTColor = mul( AP1_2_Output, ODTColor );
  155.         OutDeviceColor = LinearToST2084( ODTColor );
  156.     }
  157.     else if( GetOutputDevice() == 7 )
  158.     {
  159.         float3 OutputGamutColor = mul( AP1_2_Output, mul( sRGB_2_AP1, GradedColor ) );
  160.         OutDeviceColor = LinearToST2084( OutputGamutColor );
  161.     }
  162.     else if( GetOutputDevice() == 8 )
  163.     {
  164.         OutDeviceColor = GradedColor;
  165.     }
  166.     else if (GetOutputDevice() == 9)
  167.     {
  168.         float3 OutputGamutColor = mul(AP1_2_Output, mul(sRGB_2_AP1, FilmColorNoGamma));
  169.         OutDeviceColor = OutputGamutColor;
  170.     }
  171.     else
  172.     {
  173.         float3 OutputGamutColor = mul( AP1_2_Output, mul( sRGB_2_AP1, FilmColor ) );
  174.         OutDeviceColor = pow( OutputGamutColor, InverseGamma.z );
  175.     }
  177.     OutColor.rgb = OutDeviceColor / 1.05;
  178.     OutColor.a = 0;
  180.     return OutColor;
  181. }
  183. // PS主入口.
  184. void MainPS(FWriteToSliceGeometryOutput Input, out float4 OutColor : SV_Target0)
  185. {
  186.     OutColor = CombineLUTsCommon(Input.Vertex.UV, Input.LayerIndex);
  187. }

上面密密麻麻布满了颜色的系数计算、空间转换，着实让人眼花，不过我们只需要重点关注FilmToneMap：

  1. // Engine\Shaders\Private\TonemapCommon.ush
  3. // 在后处理体积中编辑得到, 然后由C++传入.
  4. float FilmSlope;
  5. float FilmToe;
  6. float FilmShoulder;
  7. float FilmBlackClip;
  8. float FilmWhiteClip;
  10. half3 FilmToneMap( half3 LinearColor ) 
  11. {
  12.     const float3x3 sRGB_2_AP0 = mul( XYZ_2_AP0_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
  13.     const float3x3 sRGB_2_AP1 = mul( XYZ_2_AP1_MAT, mul( D65_2_D60_CAT, sRGB_2_XYZ_MAT ) );
  15.     const float3x3 AP0_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP0_2_XYZ_MAT ) );
  16.     const float3x3 AP1_2_sRGB = mul( XYZ_2_sRGB_MAT, mul( D60_2_D65_CAT, AP1_2_XYZ_MAT ) );
  17.     
  18.     const float3x3 AP0_2_AP1 = mul( XYZ_2_AP1_MAT, AP0_2_XYZ_MAT );
  19.     const float3x3 AP1_2_AP0 = mul( XYZ_2_AP0_MAT, AP1_2_XYZ_MAT );
  20.     
  21.     float3 ColorAP1 = LinearColor;
  23. #if 1
  24.     // 发光模块常数
  25.     const float RRT_GLOW_GAIN = 0.05;
  26.     const float RRT_GLOW_MID = 0.08;
  28.     float saturation = rgb_2_saturation( ColorAP0 );
  29.     float ycIn = rgb_2_yc( ColorAP0 );
  30.     float s = sigmoid_shaper( (saturation - 0.4) / 0.2);
  31.     float addedGlow = 1 + glow_fwd( ycIn, RRT_GLOW_GAIN * s, RRT_GLOW_MID);
  32.     ColorAP0 *= addedGlow;
  33. #endif
  35. #if 1
  36.     // --- 红色修改系数 --- //
  37.     const float RRT_RED_SCALE = 0.82;
  38.     const float RRT_RED_PIVOT = 0.03;
  39.     const float RRT_RED_HUE = 0;
  40.     const float RRT_RED_WIDTH = 135;
  41.     float hue = rgb_2_hue( ColorAP0 );
  42.     float centeredHue = center_hue( hue, RRT_RED_HUE );
  43.     float hueWeight = Square( smoothstep( 0, 1, 1 - abs( 2 * centeredHue / RRT_RED_WIDTH ) ) );
  44.         
  45.     ColorAP0.r += hueWeight * saturation * (RRT_RED_PIVOT - ColorAP0.r) * (1. - RRT_RED_SCALE);
  46. #endif
  47.     
  48.     // 使用ACEScg基数作为工作空间.
  49.     float3 WorkingColor = mul( AP0_2_AP1_MAT, ColorAP0 );
  51.     WorkingColor = max( 0, WorkingColor );
  53.     // 准备降低饱和度.
  54.     WorkingColor = lerp( dot( WorkingColor, AP1_RGB2Y ), WorkingColor, 0.96 );
  55.     
  56.     const half ToeScale            = 1 + FilmBlackClip - FilmToe;
  57.     const half ShoulderScale    = 1 + FilmWhiteClip - FilmShoulder;
  58.     
  59.     const float InMatch = 0.18;
  60.     const float OutMatch = 0.18;
  62.     float ToeMatch;
  63.     if( FilmToe > 0.8 )
  64.     {
  65.         // 0.18 will be on straight segment
  66.         ToeMatch = ( 1 - FilmToe  - OutMatch ) / FilmSlope + log10( InMatch );
  67.     }
  68.     else
  69.     {
  70.         // 0.18 will be on toe segment
  72.         // Solve for ToeMatch such that input of InMatch gives output of OutMatch.
  73.         const float bt = ( OutMatch + FilmBlackClip ) / ToeScale - 1;
  74.         ToeMatch = log10( InMatch ) - 0.5 * log( (1+bt)/(1-bt) ) * (ToeScale / FilmSlope);
  75.     }
  77.     float StraightMatch = ( 1 - FilmToe ) / FilmSlope - ToeMatch;
  78.     float ShoulderMatch = FilmShoulder / FilmSlope - StraightMatch;
  79.     
  80.     half3 LogColor = log10( WorkingColor );
  81.     half3 StraightColor = FilmSlope * ( LogColor + StraightMatch );
  82.     
  83.     half3 ToeColor        = (    -FilmBlackClip ) + (2 *      ToeScale) / ( 1 + exp( (-2 * FilmSlope /      ToeScale) * ( LogColor -      ToeMatch ) ) );
  84.     half3 ShoulderColor    = ( 1 + FilmWhiteClip ) - (2 * ShoulderScale) / ( 1 + exp( ( 2 * FilmSlope / ShoulderScale) * ( LogColor - ShoulderMatch ) ) );
  86.     ToeColor        = LogColor <      ToeMatch ?      ToeColor : StraightColor;
  87.     ShoulderColor    = LogColor > ShoulderMatch ? ShoulderColor : StraightColor;
  89.     half3 t = saturate( ( LogColor - ToeMatch ) / ( ShoulderMatch - ToeMatch ) );
  90.     t = ShoulderMatch < ToeMatch ? 1 - t : t;
  91.     t = (3-2*t)*t*t;
  92.     half3 ToneColor = lerp( ToeColor, ShoulderColor, t );
  94.     // 后置降饱和度
  95.     ToneColor = lerp( dot( float3(ToneColor), AP1_RGB2Y ), ToneColor, 0.93 );
  97.     return max( 0, ToneColor );
  98. }

可知UE的Film Tonemapping（电影色调映射）除了常规的色彩空间转换和曲线映射，还增加了Slope（斜率）、Toe（脚趾）、Shoulder（肩部）、Black Clip（黑色裁剪）、White Clip（白色裁剪）等不同色阶的调整，以便艺术家精确地控制画面效果。

它们在后处理体积中可以编辑：

上图是UE的默认值，但实际上在代码中，UE还给出了不同游戏和配置的参考系数：

  1. // Default settings
  2. Slope = 0.88;
  3. Toe = 0.55;
  4. Shoulder = 0.26;
  5. BlackClip= 0;
  6. WhiteClip = 0.04;
  8. // Uncharted settings
  9. Slope = 0.63;
  10. Toe = 0.55;
  11. Shoulder = 0.47;
  12. BlackClip= 0;
  13. WhiteClip = 0.01;
  15. // HP settings
  16. Slope = 0.65;
  17. Toe = 0.63;
  18. Shoulder = 0.45;
  19. BlackClip = 0;
  20. WhiteClip = 0;
  22. // Legacy settings
  23. Slope = 0.98;
  24. Toe = 0.3;
  25. Shoulder = 0.22;
  26. BlackClip = 0;
  27. WhiteClip = 0.025;
  29. // ACES settings
  30. Slope = 0.91;
  31. Toe = 0.53;
  32. Shoulder = 0.23;
  33. BlackClip = 0;
  34. WhiteClip = 0.035;

更加具体的参数含义和效果变化参加官方文档：Color Grading and Filmic Tonemapper。

值得一提的是，前述代码隐含了大量的色彩空间转换、色调曲线映射等知识点，如果没有接触过这类知识，将会云里雾里。幸好，它们可以在这篇文献Tone Mapping找到理论依据和参考实现，值得一读。通篇理解之后，将会豁然开朗，之前的很多疑团将被解开！

参考文献Tone Mapping展示XYZ色彩空间转换到sRGB的过程和公式。

UE存在屏幕百分比（Screen Percentage）技术，用于比显示屏幕分辨率更低的分辨率进行渲染，然后上采样到指定屏幕分辨率。它有两种屏幕百分比：Primary Screen Percentage（主屏幕百分比）和Secondary Screen Percentage（次屏幕百分比）。

Primary Screen Percentage是用户可以设置和修改的分辨率比例，它基于以较低的分辨率渲染帧，然后在用户界面(UI)绘制之前将其升级的想法。Secondary Screen Percentage在Primary Screen Percentage之后再一次也是最后一次执行的分辨率上采样通道，它不可在运行时动态地修改，用于高DPI但性能较低的设备，以便使用较低的分辨率然后上采样到高DPI分辨率。

渲染阶段的较低分辨率经过主屏幕百分比后放大纹理分辨率，经过各种后处理效果后再由次屏幕百分比放大到适配屏幕的分辨率，之后再处理UI。

在场景视图中可以调整主屏幕百分比：

在后处理体积中也可以设置主屏幕百分比：

当然，还可以通过控制台命令来更改：

  1. r.ScreenPercentage 100

它们的实现在后处理渲染管线的最后阶段：

  1. void AddPostProcessingPasses(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FPostProcessingInputs& Inputs)
  2. {
  3.     (......)
  4.     
  5.     // 主放大
  6.     if (PassSequence.IsEnabled(EPass::PrimaryUpscale))
  7.     {
  8.         FUpscaleInputs PassInputs;
  9.         PassSequence.AcceptOverrideIfLastPass(EPass::PrimaryUpscale, PassInputs.OverrideOutput);
  10.         PassInputs.SceneColor = SceneColor;
  11.         PassInputs.Method = GetUpscaleMethod();
  12.         PassInputs.Stage = PassSequence.IsEnabled(EPass::SecondaryUpscale) ? EUpscaleStage::PrimaryToSecondary : EUpscaleStage::PrimaryToOutput;
  14.         // Panini projection is handled by the primary upscale pass.
  15.         PassInputs.PaniniConfig = PaniniConfig;
  17.         SceneColor = AddUpscalePass(GraphBuilder, View, PassInputs);
  18.     }
  20.     // 次放大
  21.     if (PassSequence.IsEnabled(EPass::SecondaryUpscale))
  22.     {
  23.         FUpscaleInputs PassInputs;
  24.         PassSequence.AcceptOverrideIfLastPass(EPass::SecondaryUpscale, PassInputs.OverrideOutput);
  25.         PassInputs.SceneColor = SceneColor;
  26.         PassInputs.Method = View.Family->SecondaryScreenPercentageMethod == ESecondaryScreenPercentageMethod::LowerPixelDensitySimulation ? EUpscaleMethod::SmoothStep : EUpscaleMethod::Nearest;
  27.         PassInputs.Stage = EUpscaleStage::SecondaryToOutput;
  29.         SceneColor = AddUpscalePass(GraphBuilder, View, PassInputs);
  30.     }
  31. }

主放大和次放大都调用了AddUpscalePass：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\PostProcessUpscale.cpp
  3. FScreenPassTexture AddUpscalePass(FRDGBuilder& GraphBuilder, const FViewInfo& View, const FUpscaleInputs& Inputs)
  4. {
  5.     FScreenPassRenderTarget Output = Inputs.OverrideOutput;
  7.     // 创建新的输出纹理.
  8.     if (!Output.IsValid())
  9.     {
  10.         FRDGTextureDesc OutputDesc = Inputs.SceneColor.Texture->Desc;
  11.         OutputDesc.Reset();
  13.         if (Inputs.Stage == EUpscaleStage::PrimaryToSecondary)
  14.         {
  15.             const FIntPoint SecondaryViewRectSize = View.GetSecondaryViewRectSize();
  16.             QuantizeSceneBufferSize(SecondaryViewRectSize, OutputDesc.Extent);
  17.             Output.ViewRect.Min = FIntPoint::ZeroValue;
  18.             Output.ViewRect.Max = SecondaryViewRectSize;
  19.         }
  20.         else
  21.         {
  22.             OutputDesc.Extent = View.UnscaledViewRect.Max;
  23.             Output.ViewRect = View.UnscaledViewRect;
  24.         }
  26.         OutputDesc.Flags |= GFastVRamConfig.Upscale;
  28.         Output.Texture = GraphBuilder.CreateTexture(OutputDesc, TEXT("Upscale"));
  29.         Output.LoadAction = ERenderTargetLoadAction::EClear;
  30.     }
  32.     const FScreenPassTextureViewport InputViewport(Inputs.SceneColor);
  33.     const FScreenPassTextureViewport OutputViewport(Output);
  35.     // Panini投影.
  36.     FPaniniProjectionConfig PaniniConfig = Inputs.PaniniConfig;
  37.     PaniniConfig.Sanitize();
  39.     const bool bUsePaniniProjection = PaniniConfig.IsEnabled();
  41.     // 上采用参数.
  42.     FUpscaleParameters* PassParameters = GraphBuilder.AllocParameters<FUpscaleParameters>();
  43.     PassParameters->RenderTargets[0] = Output.GetRenderTargetBinding();
  44.     PassParameters->Input = GetScreenPassTextureViewportParameters(InputViewport);
  45.     PassParameters->Output = GetScreenPassTextureViewportParameters(OutputViewport);
  46.     PassParameters->SceneColorTexture = Inputs.SceneColor.Texture;
  47.     PassParameters->SceneColorSampler = TStaticSamplerState<SF_Bilinear, AM_Border, AM_Border, AM_Border>::GetRHI();
  48.     PassParameters->PointSceneColorTexture = Inputs.SceneColor.Texture;
  49.     PassParameters->PointSceneColorTextureArray = Inputs.SceneColor.Texture;
  50.     PassParameters->PointSceneColorSampler = TStaticSamplerState<SF_Point, AM_Border, AM_Border, AM_Border>::GetRHI();
  51.     PassParameters->Panini = GetPaniniProjectionParameters(PaniniConfig, View);
  52.     PassParameters->UpscaleSoftness = FMath::Clamp(CVarUpscaleSoftness.GetValueOnRenderThread(), 0.0f, 1.0f);
  53.     PassParameters->View = View.ViewUniformBuffer;
  55.     // 处理FUpscalePS.
  56.     FUpscalePS::FPermutationDomain PixelPermutationVector;
  57.     PixelPermutationVector.Set<FUpscalePS::FMethodDimension>(Inputs.Method);
  58.     TShaderMapRef<FUpscalePS> PixelShader(View.ShaderMap, PixelPermutationVector);
  60.     const TCHAR* const StageNames[] = { TEXT("PrimaryToSecondary"), TEXT("PrimaryToOutput"), TEXT("SecondaryToOutput") };
  61.     static_assert(UE_ARRAY_COUNT(StageNames) == static_cast<uint32>(EUpscaleStage::MAX), "StageNames does not match EUpscaleStage");
  62.     const TCHAR* StageName = StageNames[static_cast<uint32>(Inputs.Stage)];
  64.     GraphBuilder.AddPass(
  65.         RDG_EVENT_NAME("Upscale (%s) %dx%d", StageName, Output.ViewRect.Width(), Output.ViewRect.Height()),
  66.         PassParameters,
  67.         ERDGPassFlags::Raster,
  68.         [&View, bUsePaniniProjection, PixelShader, PassParameters, InputViewport, OutputViewport](FRHICommandList& RHICmdList)
  69.     {
  70.         RHICmdList.SetViewport(OutputViewport.Rect.Min.X, OutputViewport.Rect.Min.Y, 0.0f, OutputViewport.Rect.Max.X, OutputViewport.Rect.Max.Y, 1.0f);
  72.         TShaderRef<FShader> VertexShader;
  73.         // Panini投影使用特殊的VS. 亦即在VS里处理Panini投影.
  74.         if (bUsePaniniProjection)
  75.         {
  76.             TShaderMapRef<FUpscaleVS> TypedVertexShader(View.ShaderMap);
  77.             SetScreenPassPipelineState(RHICmdList, FScreenPassPipelineState(TypedVertexShader, PixelShader));
  78.             SetShaderParameters(RHICmdList, TypedVertexShader, TypedVertexShader.GetVertexShader(), *PassParameters);
  79.             VertexShader = TypedVertexShader;
  80.         }
  81.         else
  82.         {
  83.             TShaderMapRef<FScreenPassVS> TypedVertexShader(View.ShaderMap);
  84.             SetScreenPassPipelineState(RHICmdList, FScreenPassPipelineState(TypedVertexShader, PixelShader));
  85.             VertexShader = TypedVertexShader;
  86.         }
  87.         check(VertexShader.IsValid());
  89.         SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
  91.         // 全屏绘制.
  92.         DrawRectangle(
  93.             RHICmdList,
  94.             // Output Rect (RHI viewport relative).
  95.             0, 0, OutputViewport.Rect.Width(), OutputViewport.Rect.Height(),
  96.             // Input Rect
  97.             InputViewport.Rect.Min.X, InputViewport.Rect.Min.Y, InputViewport.Rect.Width(), InputViewport.Rect.Height(),
  98.             OutputViewport.Rect.Size(),
  99.             InputViewport.Extent,
  100.             VertexShader,
  101.             // Panini投影使用曲面细分.
  102.             bUsePaniniProjection ? EDRF_UseTesselatedIndexBuffer : EDRF_UseTriangleOptimization);
  103.     });
  105.     return MoveTemp(Output);
  106. }

以上可知根据是否Panini投影，会使用不同的VS，但PS一样，都是FUpscaleVS，下面分析FUpscaleVS的shader代码：

  1. // Engine\Shaders\Private\PostProcessUpscale.usf
  3. void MainPS(noperspective float4 UVAndScreenPos : TEXCOORD0, float4 SvPosition : SV_POSITION, out float4 OutColor : SV_Target0)
  4. {
  5.     OutColor = 0;
  7.     // 最近点上采样.(不会模糊, 但有块状)
  8. #if METHOD == UPSCALE_METHOD_NEAREST
  9.     #if ES3_1_PROFILE
  10.         #if MOBILE_MULTI_VIEW
  11.             OutColor = Texture2DArraySample(PointSceneColorTextureArray, PointSceneColorSampler, float3(UVAndScreenPos.xy,0));
  12.         #else
  13.             OutColor = Texture2DSample(PointSceneColorTexture, PointSceneColorSampler, UVAndScreenPos.xy);
  14.         #endif
  15.     #else
  16.         #if MOBILE_MULTI_VIEW
  17.             OutColor = PointSceneColorTextureArray.SampleLevel(PointSceneColorSampler, vec3(UVAndScreenPos.xy,0), 0, int2(0, 0));
  18.         #else
  19.             OutColor = PointSceneColorTexture.SampleLevel(PointSceneColorSampler, UVAndScreenPos.xy, 0, int2(0, 0));
  20.         #endif
  21.     #endif
  23.     // 双线性上采样.(快, 但有锯齿)
  24. #elif METHOD == UPSCALE_METHOD_BILINEAR
  25.     OutColor.rgb = SampleSceneColorRGB(UVAndScreenPos.xy);
  27.     // 定向模糊上采样, 使用了与不锐利的蒙版.
  28. #elif METHOD == UPSCALE_METHOD_DIRECTIONAL
  29.     float2 UV = UVAndScreenPos.xy;
  30.     float X = 0.5;
  31.     float3 ColorNW = SampleSceneColorRGB(UV + float2(-X, -X) * Input_ExtentInverse);
  32.     float3 ColorNE = SampleSceneColorRGB(UV + float2( X, -X) * Input_ExtentInverse);
  33.     float3 ColorSW = SampleSceneColorRGB(UV + float2(-X,  X) * Input_ExtentInverse);
  34.     float3 ColorSE = SampleSceneColorRGB(UV + float2( X,  X) * Input_ExtentInverse);
  35.     OutColor.rgb = (ColorNW * 0.25) + (ColorNE * 0.25) + (ColorSW * 0.25) + (ColorSE * 0.25);
  36.     
  37.     float LumaNW = Luma(ColorNW);
  38.     float LumaNE = Luma(ColorNE);
  39.     float LumaSW = Luma(ColorSW);
  40.     float LumaSE = Luma(ColorSE);
  42.     float2 IsoBrightnessDir;
  43.     float DirSWMinusNE = LumaSW - LumaNE;
  44.     float DirSEMinusNW = LumaSE - LumaNW;
  45.     IsoBrightnessDir.x = DirSWMinusNE + DirSEMinusNW;
  46.     IsoBrightnessDir.y = DirSWMinusNE - DirSEMinusNW;
  48.     // avoid NaN on zero vectors by adding 2^-24 (float ulp when length==1, and also minimum representable half)
  49.     IsoBrightnessDir = IsoBrightnessDir * (0.125 * rsqrt(dot(IsoBrightnessDir, IsoBrightnessDir) + 6e-8));
  51.     float3 ColorN = SampleSceneColorRGB(UV - IsoBrightnessDir * Input_ExtentInverse);
  52.     float3 ColorP = SampleSceneColorRGB(UV + IsoBrightnessDir * Input_ExtentInverse);
  54.     float UnsharpMask = 0.25;
  55.     OutColor.rgb = (ColorN + ColorP) * ((UnsharpMask + 1.0) * 0.5) - (OutColor.rgb * UnsharpMask);
  57.     // 双立方的Catmull-Rom上采样, 每像素使用5个采样点.
  58. #elif METHOD == UPSCALE_METHOD_CATMULL_ROM
  59.     FCatmullRomSamples Samples = GetBicubic2DCatmullRomSamples(UVAndScreenPos.xy, Input_Extent, Input_ExtentInverse);
  60.     for (uint i = 0; i < Samples.Count; i++)
  61.     {
  62.         OutColor.rgb += SampleSceneColorRGB(Samples.UV[i]) * Samples.Weight[i];
  63.     }
  64.     OutColor *= Samples.FinalMultiplier;
  66.     // LANCZOS上采样.
  67. #elif METHOD == UPSCALE_METHOD_LANCZOS
  68.     {
  69.         // Lanczos 3
  70.         float2 UV = UVAndScreenPos.xy * Input_Extent;
  71.         float2 tc = floor(UV - 0.5) + 0.5;
  72.         float2 f = UV - tc + 2;
  74.         // compute at f, f-1, f-2, f-3, f-4, and f-5 using trig angle addition
  75.         float2 fpi = f*PI, fpi3 = f * (PI / 3.0);
  76.         float2 sinfpi = sin(fpi), sinfpi3 = sin(fpi3), cosfpi3 = cos(fpi3);
  77.         const float r3 = sqrt(3.0);
  78.         float2 w0 = ( sinfpi *       sinfpi3              ) / ( f       * f       );
  79.         float2 w1 = (-sinfpi * (     sinfpi3 - r3*cosfpi3)) / ((f - 1.0)*(f - 1.0));
  80.         float2 w2 = ( sinfpi * (    -sinfpi3 - r3*cosfpi3)) / ((f - 2.0)*(f - 2.0));
  81.         float2 w3 = (-sinfpi * (-2.0*sinfpi3             )) / ((f - 3.0)*(f - 3.0));
  82.         float2 w4 = ( sinfpi * (    -sinfpi3 + r3*cosfpi3)) / ((f - 4.0)*(f - 4.0));
  83.         float2 w5 = (-sinfpi * (     sinfpi3 + r3*cosfpi3)) / ((f - 5.0)*(f - 5.0));
  85.         // use bilinear texture weights to merge center two samples in each dimension
  86.         float2 Weight[5];
  87.         Weight[0] = w0;
  88.         Weight[1] = w1;
  89.         Weight[2] = w2 + w3;
  90.         Weight[3] = w4;
  91.         Weight[4] = w5;
  93.         float2 Sample[5];
  94.         Sample[0] = Input_ExtentInverse * (tc - 2);
  95.         Sample[1] = Input_ExtentInverse * (tc - 1);
  96.         Sample[2] = Input_ExtentInverse * (tc + w3 / Weight[2]);
  97.         Sample[3] = Input_ExtentInverse * (tc + 2);
  98.         Sample[4] = Input_ExtentInverse * (tc + 3);
  100.         OutColor = 0;
  102.         // 5x5 footprint with corners dropped to give 13 texture taps
  103.         OutColor += float4(SampleSceneColorRGB(float2(Sample[0].x, Sample[2].y)), 1) * Weight[0].x * Weight[2].y;
  105.         OutColor += float4(SampleSceneColorRGB(float2(Sample[1].x, Sample[1].y)), 1) * Weight[1].x * Weight[1].y;
  106.         OutColor += float4(SampleSceneColorRGB(float2(Sample[1].x, Sample[2].y)), 1) * Weight[1].x * Weight[2].y;
  107.         OutColor += float4(SampleSceneColorRGB(float2(Sample[1].x, Sample[3].y)), 1) * Weight[1].x * Weight[3].y;
  109.         OutColor += float4(SampleSceneColorRGB(float2(Sample[2].x, Sample[0].y)), 1) * Weight[2].x * Weight[0].y;
  110.         OutColor += float4(SampleSceneColorRGB(float2(Sample[2].x, Sample[1].y)), 1) * Weight[2].x * Weight[1].y;
  111.         OutColor += float4(SampleSceneColorRGB(float2(Sample[2].x, Sample[2].y)), 1) * Weight[2].x * Weight[2].y;
  112.         OutColor += float4(SampleSceneColorRGB(float2(Sample[2].x, Sample[3].y)), 1) * Weight[2].x * Weight[3].y;
  113.         OutColor += float4(SampleSceneColorRGB(float2(Sample[2].x, Sample[4].y)), 1) * Weight[2].x * Weight[4].y;
  115.         OutColor += float4(SampleSceneColorRGB(float2(Sample[3].x, Sample[1].y)), 1) * Weight[3].x * Weight[1].y;
  116.         OutColor += float4(SampleSceneColorRGB(float2(Sample[3].x, Sample[2].y)), 1) * Weight[3].x * Weight[2].y;
  117.         OutColor += float4(SampleSceneColorRGB(float2(Sample[3].x, Sample[3].y)), 1) * Weight[3].x * Weight[3].y;
  119.         OutColor += float4(SampleSceneColorRGB(float2(Sample[4].x, Sample[2].y)), 1) * Weight[4].x * Weight[2].y;
  121.         OutColor /= OutColor.w;
  122.     }
  124.     // 高斯上采样.
  125. #elif METHOD == UPSCALE_METHOD_GAUSSIAN
  126.     {
  127.         // Gaussian filtered unsharp mask
  128.         float2 UV = UVAndScreenPos.xy * Input_Extent;
  129.         float2 tc = floor(UV) + 0.5;
  131.         // estimate pixel value and derivatives
  132.         OutColor = 0;
  133.         float3 Laplacian = 0;
  134.         UNROLL for (int i = -3; i <= 2; ++i)
  135.         {
  136.             UNROLL for (int j = -3; j <= 2; ++j)
  137.             {
  138.                 float2 TexelOffset = float2(i, j) + 0.5;
  140.                 // skip corners: eliminated entirely by UNROLL
  141.                 if (dot(TexelOffset, TexelOffset) > 9) continue;
  143.                 float2 Texel = tc + TexelOffset;
  144.                 float2 Offset = UV - Texel;
  145.                 float OffsetSq = 2 * dot(Offset, Offset);    // texel loop is optimized for variance = 0.5
  146.                 float Weight = exp(-0.5 * OffsetSq);
  147.                 float4 Sample = Weight * float4(SampleSceneColorRGB(Texel * Input_ExtentInverse), 1);
  149.                 OutColor += Sample;
  150.                 Laplacian += Sample.rgb * (OffsetSq - 2);
  151.             }
  152.         }
  153.         OutColor /= OutColor.a;
  154.         Laplacian /= OutColor.a;
  156.         float UnsharpScale = UpscaleSoftness * (1 - Input_Extent.x * Input_Extent.y * Output_ViewportSizeInverse.x * Output_ViewportSizeInverse.y);
  157.         OutColor.rgb -= UnsharpScale * Laplacian;
  158.     }
  160.     // 平滑采样.
  161. #elif METHOD == UPSCALE_METHOD_SMOOTHSTEP
  162.     OutColor.rgb = SampleSceneColorRGB(GetSmoothstepUV(UVAndScreenPos.xy, Input_Extent, Input_ExtentInverse));
  163. #endif
  164. }

上面涉及到了部分纹理过滤和采样技术：最近点、双线性、双立方、Lanczos等，其中部分采样曲线示意图如下：

部分曲线的效果对比图如下：

这里说一下最复杂的Lanczos采样算法。Lanczos的卷积核普态公式如下：

\[L(x) = \begin{cases}
1 & \text{if}\ x = 0, \\
\dfrac{a \sin(\pi x) \sin(\pi x / a)}{\pi^2 x^2} & \text{if}\ -a \leq x < a \ \text{and}\ x \neq 0, \\
0 & \text{otherwise}.
\end{cases}
\]

其中\(a\)是正整数，通常是2或3，表示卷积核的尺寸。当\(a=2\)和\(=3\)时，卷积核曲线如下所示：

利用卷积核公式，可以获得Lanczos的插值（采样）公式：

\[S(x) = \sum_{i=\lfloor x \rfloor – a + 1}^{\lfloor x \rfloor + a} s_{i} L(x – i)
\]

其中\(x\)是采样位置，\(a\)是过滤尺寸大小，\(\lfloor x \rfloor\)是floor函数。

不过上面的PS的shader代码中并没有完全按照公式实现，而是对三角函数运算和循环语句做了优化。

此外，上面的C++代码中涉及到了Panini Projection，它是用来校正广角FOV的透视畸变。

上：未采用Panini Projection，画面产生了明显的畸变；下：采用了Panini Projection，画面恢复正常。

UE的内置抗锯齿算法有MSAA、FXAA、TAA，MSAA主要用于前向渲染的基于硬件抗锯齿的算法，TAA主要用于延迟渲染的抗锯齿算法，而FXAA是基于后处理的抗锯齿算法。它们的比较如下表：

适用管线 效果 消耗 其它描述
MSAA 前向 清晰度高，抗锯齿好 带宽中，显存中 需要额外记录采样覆盖数据
FXAA 前向，延迟 清晰度较高，抗锯齿较好 带宽低，显存低 不需要额外记录数据，计算量较大
TAA 延迟 清晰度较低，存在延时、闪烁、鬼影等，但静态画面抗锯齿非常好 带宽高，显存高 需要速度缓冲和额外记录历史帧数据

UE4.26延迟渲染管线下的TAA和FXAA对比图。上面是TAA，下面是FXAA。

FXAA全称Fast approXimate Anti-Aliasing，是就职于NVIDIA的Timothy Lottes首次提出的一种快速近似MSAA的后处理抗锯齿方法，他分别在2009年、2011年发表了文献FXAA和Filtering Approaches for Real-Time Anti-Aliasing。

FXAA的核心算法如下图和文字所示（序号和图片一一对应）：

1、输入一副没有抗锯齿的sRGB颜色空间的纹理，在Shader逻辑中，它将内部转换为亮度的估计标量值。

2、检查局部对比度以避免处理非边缘的部分。检测到的边缘数据放到R通道，用向黄色混合来表示检测到的子像素锯齿量。

这一步实现中做了优化，会对低对比度（非边缘）的像素进行早期返回（Early Exit）。

3、通过局部对比度检测的像素被分类为水平（金色）或垂直（蓝色）。

4、给定边缘方向，选择与边缘成90度的最高对比度的像素作为一对（Pair），用蓝/绿表示。

5、在边缘的正负（红/蓝）方向上搜索边缘末端（end-of-edge）。检查沿边缘高对比度像素对（Pair）的平均亮度的显著变化。

6、给定边缘末端，将边缘上的像素位置转换为垂直于边缘的子像素偏移90度，以减少锯齿。其中，红/蓝是减少/增加水平偏移，金色/天空蓝是减少/增加垂直偏移。

7、给定子像素偏移量，对输入纹理重新采样。

8、最后根据检测到的子像素锯齿量加入一个低通滤波器。

关于FXAA需要补充几点说明：

  • 由于FXAA不需要额外的纹理数据，输入和输出纹理只有一张，所以可以在一个Pass处理完，带宽和显存消耗低。
  • 要求输入纹理是sRGB，如果是XYZ或线性空间的颜色将得不到预想的效果。
  • 由于FXAA需要进行多次步骤的计算，因此计算消耗理论上要比MSAA高，相当于时间换空间。
  • FXAA是基于屏幕空间的后处理算法，不需要用到法线、深度等GBuffer数据。
  • 由于FXAA只根据颜色的亮度来查找边缘，所以效果有限，无法检测出深度边缘和曲面边缘。
  • UE4.26的实现正是基于第二篇文献的算法，有很多种预设（Preset），它们是针对不同平台和质量等级执行的优化和适配。

下面分析UE的FXAA在PC平台的算法，其它平台核心算法类似，此文不涉及。下面代码涉及的很多后缀，它们的含义如下图：

上图的各个缩写含义如下：

  • M：Median，中心像素。
  • N：North，M上面的像素。
  • S：South，M下面的像素。
  • W：West，M左边的像素。
  • E：East，M右边的像素。
  • NW：Northwest，M左上角的像素。
  • NE：Northeast，M右上角的像素。
  • SW：Southwest，M左下角的像素。
  • SE：Southeast，M右下角的像素。
  1. // Engine\Shaders\Private\FXAAShader.usf
  3. // 包含NVIDIA的FXAA实现文件.
  4. #include "Fxaa3_11.ush"
  6. // FXAA的PS主入口.
  7. void FxaaPS(noperspective float2 TexCenter : TEXCOORD0, noperspective float4 TexCorners : TEXCOORD1, out float4 OutColor : SV_Target0)
  8. {
  9.     FxaaTex TextureAndSampler;
  10.     TextureAndSampler.tex = Input_Texture;
  11.     TextureAndSampler.smpl = Input_Sampler;
  12.     TextureAndSampler.UVMinMax = float4(Input_UVViewportBilinearMin, Input_UVViewportBilinearMax);
  14.     OutColor = FxaaPixelShader(
  15.         TexCenter, TexCorners,
  16.         TextureAndSampler,
  17.         TextureAndSampler,
  18.         TextureAndSampler,
  19.         Input_ExtentInverse,
  20.         fxaaConsoleRcpFrameOpt,
  21.         fxaaConsoleRcpFrameOpt2,
  22.         fxaaConsole360RcpFrameOpt2,
  23.         fxaaQualitySubpix,
  24.         fxaaQualityEdgeThreshold,
  25.         fxaaQualityEdgeThresholdMin,
  26.         fxaaConsoleEdgeSharpness,
  27.         fxaaConsoleEdgeThreshold,
  28.         fxaaConsoleEdgeThresholdMin,
  29.         fxaaConsole360ConstDir);
  31.     #if (POST_PROCESS_ALPHA != 2)
  32.         OutColor.a = 1.0;
  33.     #endif
  34. }

下面直接分析PC平台的FxaaPixelShader：

  1. // Engine\Shaders\Private\Fxaa3_11.ush
  3. #if (FXAA_PC == 1) // 表明是PC平台
  5. FxaaFloat4 FxaaPixelShader(
  6.     FxaaFloat2 pos, // 是像素中心, 这里使用非透视插值 (关闭透视插值).
  7.     FxaaFloat4 fxaaConsolePosPos, // 只用于Console平台.
  8.     FxaaTex tex, // 输入纹理
  9.     FxaaTex fxaaConsole360TexExpBiasNegOne, // 只用于360平台.
  10.     FxaaTex fxaaConsole360TexExpBiasNegTwo, // 只用于360平台.
  11.     FxaaFloat2 fxaaQualityRcpFrame, // 只用于FXAA的质量, 必须是constant/uniform, {x_} = 1.0/screenWidthInPixels, {_y} = 1.0/screenHeightInPixels
  12.     FxaaFloat4 fxaaConsoleRcpFrameOpt, // 只用于360平台.
  13.     FxaaFloat4 fxaaConsoleRcpFrameOpt2, // 只用于360平台.
  14.     FxaaFloat4 fxaaConsole360RcpFrameOpt2, // 只用于360平台.
  15.     FxaaFloat fxaaQualitySubpix, // 只用于FXAA的质量. 控制锐利度.
  16.     FxaaFloat fxaaQualityEdgeThreshold, // 边缘阈值. 只用于FXAA的质量. 
  17.     FxaaFloat fxaaQualityEdgeThresholdMin, // 最小边缘阈值. 只用于FXAA的质量. 
  18.     FxaaFloat fxaaConsoleEdgeSharpness, // 只用于360平台.
  19.     FxaaFloat fxaaConsoleEdgeThreshold,
  20.     FxaaFloat fxaaConsoleEdgeThresholdMin,
  21.     FxaaFloat4 fxaaConsole360ConstDir
  22. ) {
  23.     FxaaFloat2 posM;
  24.     posM.x = pos.x;
  25.     posM.y = pos.y;
  26.     
  27.     // 从输入纹理采样数据, 计算亮度值.
  28.     #if (FXAA_GATHER4_ALPHA == 1)
  29.         #if (FXAA_DISCARD == 0)
  30.             FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
  31.             #if (FXAA_GREEN_AS_LUMA == 0)
  32.                 #define lumaM rgbyM.w
  33.             #else
  34.                 #define lumaM rgbyM.y
  35.             #endif
  36.         #endif
  37.         #if (FXAA_GREEN_AS_LUMA == 0)
  38.             FxaaFloat4 luma4A = FxaaTexAlpha4(tex, posM);
  39.             FxaaFloat4 luma4B = FxaaTexOffAlpha4(tex, posM, FxaaInt2(-1, -1));
  40.         #else
  41.             FxaaFloat4 luma4A = FxaaTexGreen4(tex, posM);
  42.             FxaaFloat4 luma4B = FxaaTexOffGreen4(tex, posM, FxaaInt2(-1, -1));
  43.         #endif
  44.         #if (FXAA_DISCARD == 1)
  45.             #define lumaM luma4A.w
  46.         #endif
  47.         #define lumaE luma4A.z
  48.         #define lumaS luma4A.x
  49.         #define lumaSE luma4A.y
  50.         #define lumaNW luma4B.w
  51.         #define lumaN luma4B.z
  52.         #define lumaW luma4B.x
  53.     #else
  54.         FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
  55.         #if (FXAA_GREEN_AS_LUMA == 0)
  56.             #define lumaM rgbyM.w
  57.         #else
  58.             #define lumaM rgbyM.y
  59.         #endif
  60.         FxaaFloat lumaS = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
  61.         FxaaFloat lumaE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
  62.         FxaaFloat lumaN = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
  63.         FxaaFloat lumaW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
  64.     #endif
  65. /*--------------------------------------------------------------------------*/
  66.     // 计算各个方向上的亮度最大最小值, 检测是否可提前退出.
  67.     FxaaFloat maxSM = max(lumaS, lumaM);
  68.     FxaaFloat minSM = min(lumaS, lumaM);
  69.     FxaaFloat maxESM = max(lumaE, maxSM);
  70.     FxaaFloat minESM = min(lumaE, minSM);
  71.     FxaaFloat maxWN = max(lumaN, lumaW);
  72.     FxaaFloat minWN = min(lumaN, lumaW);
  73.     FxaaFloat rangeMax = max(maxWN, maxESM);
  74.     FxaaFloat rangeMin = min(minWN, minESM);
  75.     FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
  76.     FxaaFloat range = rangeMax - rangeMin;
  77.     FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
  78.     FxaaBool earlyExit = range < rangeMaxClamped;
  79. /*--------------------------------------------------------------------------*/
  80.     if(earlyExit)
  81.         #if (FXAA_DISCARD == 1)
  82.             FxaaDiscard;
  83.         #else
  84.             return rgbyM;
  85.         #endif
  86. /*--------------------------------------------------------------------------*/
  87.     // 计算对角方向的亮度值.
  88.     #if (FXAA_GATHER4_ALPHA == 0)
  89.         FxaaFloat lumaNW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
  90.         FxaaFloat lumaSE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
  91.         FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
  92.         FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
  93.     #else
  94.         FxaaFloat lumaNE = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(1, -1), fxaaQualityRcpFrame.xy));
  95.         FxaaFloat lumaSW = FxaaLuma(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
  96.     #endif
  97. /*--------------------------------------------------------------------------*/
  98.     // 下面计算各个方向的边缘在水平和竖直的值, 以及子像素的值.
  99. /*--------------------------------------------------------------------------*/
  100.     FxaaFloat lumaNS = lumaN + lumaS;
  101.     FxaaFloat lumaWE = lumaW + lumaE;
  102.     FxaaFloat subpixRcpRange = 1.0/range;
  103.     FxaaFloat subpixNSWE = lumaNS + lumaWE;
  104.     FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
  105.     FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
  106. /*--------------------------------------------------------------------------*/
  107.     FxaaFloat lumaNESE = lumaNE + lumaSE;
  108.     FxaaFloat lumaNWNE = lumaNW + lumaNE;
  109.     FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
  110.     FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
  111. /*--------------------------------------------------------------------------*/
  112.     FxaaFloat lumaNWSW = lumaNW + lumaSW;
  113.     FxaaFloat lumaSWSE = lumaSW + lumaSE;
  114.     FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
  115.     FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
  116.     FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
  117.     FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
  118.     FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
  119.     FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
  120. /*--------------------------------------------------------------------------*/
  121.     FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
  122.     FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
  123.     // 如果水平方向的边缘长度>竖直边缘长度, 说明是水平方向的边缘.
  124.     FxaaBool horzSpan = edgeHorz >= edgeVert;
  125.     FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
  126. /*--------------------------------------------------------------------------*/
  127.     // 如果不是水平边缘, 则将N和S换成W和E.(这样后面就避免了重复的代码)
  128.     if(!horzSpan) lumaN = lumaW;
  129.     if(!horzSpan) lumaS = lumaE;
  130.     if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
  131.     FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
  132. /*--------------------------------------------------------------------------*/
  133.     // 根据梯度计算配对.
  134.     FxaaFloat gradientN = lumaN - lumaM;
  135.     FxaaFloat gradientS = lumaS - lumaM;
  136.     FxaaFloat lumaNN = lumaN + lumaM;
  137.     FxaaFloat lumaSS = lumaS + lumaM;
  138.     FxaaBool pairN = abs(gradientN) >= abs(gradientS);
  139.     FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
  140.     if(pairN) lengthSign = -lengthSign;
  141.     FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
  142. /*--------------------------------------------------------------------------*/
  143.     // 计算偏移.
  144.     FxaaFloat2 posB;
  145.     posB.x = posM.x;
  146.     posB.y = posM.y;
  147.     FxaaFloat2 offNP;
  148.     offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
  149.     offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
  150.     if(!horzSpan) posB.x += lengthSign * 0.5;
  151.     if( horzSpan) posB.y += lengthSign * 0.5;
  152. /*--------------------------------------------------------------------------*/
  153.     // 计算偏移后的位置.
  154.     // 上面的像素位置.
  155.     FxaaFloat2 posN; 
  156.     posN.x = posB.x - offNP.x * FXAA_QUALITY__P0;
  157.     posN.y = posB.y - offNP.y * FXAA_QUALITY__P0;
  158.     // 下面的像素位置.
  159.     FxaaFloat2 posP; 
  160.     posP.x = posB.x + offNP.x * FXAA_QUALITY__P0;
  161.     posP.y = posB.y + offNP.y * FXAA_QUALITY__P0;
  162.     FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
  163.     FxaaFloat lumaEndN = FxaaLuma(FxaaTexTop(tex, posN));
  164.     FxaaFloat subpixE = subpixC * subpixC;
  165.     FxaaFloat lumaEndP = FxaaLuma(FxaaTexTop(tex, posP));
  166. /*--------------------------------------------------------------------------*/
  167.     if(!pairN) lumaNN = lumaSS;
  168.     // 梯度缩放.
  169.     FxaaFloat gradientScaled = gradient * 1.0/4.0;
  170.     FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
  171.     FxaaFloat subpixF = subpixD * subpixE;
  172.     FxaaBool lumaMLTZero = lumaMM < 0.0;
  173. /*--------------------------------------------------------------------------*/
  174.     // 第1次边缘末端查找.
  175.     lumaEndN -= lumaNN * 0.5;
  176.     lumaEndP -= lumaNN * 0.5;
  177.     FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
  178.     FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
  179.     if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P1;
  180.     if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P1;
  181.     FxaaBool doneNP = (!doneN) || (!doneP);
  182.     if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P1;
  183.     if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P1;
  184. /*--------------------------------------------------------------------------*/
  185.     // 第2次边缘末端查找.
  186.     if(doneNP) {
  187.         if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
  188.         if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
  189.         if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
  190.         if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
  191.         doneN = abs(lumaEndN) >= gradientScaled;
  192.         doneP = abs(lumaEndP) >= gradientScaled;
  193.         if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P2;
  194.         if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P2;
  195.         doneNP = (!doneN) || (!doneP);
  196.         if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P2;
  197.         if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P2;
  198. /*--------------------------------------------------------------------------*/
  199.         // 第3次边缘末端查找.
  200.         #if (FXAA_QUALITY__PS > 3)
  201.         if(doneNP) {
  202.             if(!doneN) lumaEndN = FxaaLuma(FxaaTexTop(tex, posN.xy));
  203.             if(!doneP) lumaEndP = FxaaLuma(FxaaTexTop(tex, posP.xy));
  204.             if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
  205.             if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
  206.             doneN = abs(lumaEndN) >= gradientScaled;
  207.             doneP = abs(lumaEndP) >= gradientScaled;
  208.             if(!doneN) posN.x -= offNP.x * FXAA_QUALITY__P3;
  209.             if(!doneN) posN.y -= offNP.y * FXAA_QUALITY__P3;
  210.             doneNP = (!doneN) || (!doneP);
  211.             if(!doneP) posP.x += offNP.x * FXAA_QUALITY__P3;
  212.             if(!doneP) posP.y += offNP.y * FXAA_QUALITY__P3;
  213. /*--------------------------------------------------------------------------*/
  214.             #if (FXAA_QUALITY__PS > 4)
  215.                 (......) // 最多到12个以上的采样像素.
  216.             #endif
  217. /*--------------------------------------------------------------------------*/
  218.         }
  219.         #endif
  220. /*--------------------------------------------------------------------------*/
  221.     }
  222. /*--------------------------------------------------------------------------*/
  223.     FxaaFloat dstN = posM.x - posN.x;
  224.     FxaaFloat dstP = posP.x - posM.x;
  225.     if(!horzSpan) dstN = posM.y - posN.y;
  226.     if(!horzSpan) dstP = posP.y - posM.y;
  227. /*--------------------------------------------------------------------------*/
  228.     FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
  229.     FxaaFloat spanLength = (dstP + dstN);
  230.     FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
  231.     FxaaFloat spanLengthRcp = 1.0/spanLength;
  232. /*--------------------------------------------------------------------------*/
  233.     FxaaBool directionN = dstN < dstP;
  234.     FxaaFloat dstMin = min(dstN, dstP);
  235.     FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
  236.     FxaaFloat subpixG = subpixF * subpixF;
  237.     FxaaFloat pixelOffset = (dstMin * (-spanLengthRcp)) + 0.5;
  238.     FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
  239. /*--------------------------------------------------------------------------*/
  240.     // 计算最终的采样位置并从输入纹理中采样.
  241.     FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
  242.     FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
  243.     if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
  244.     if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
  245.     // 注意FxaaTexTop使用了纹理的双线性采样, 所以才能呈现出混合过渡的效果.
  246.     #if ((FXAA_DISCARD == 1) || (POST_PROCESS_ALPHA == 2))
  247.         return FxaaTexTop(tex, posM);
  248.     #else
  249.         return FxaaFloat4(FxaaTexTop(tex, posM).xyz, lumaM);
  250.     #endif
  251. }
  252. #endif

以上代码须知，最终计算出来的是当前像素偏移后的采样位置，并且使用了双线性采样，所以才能达到混合过渡的抗锯齿效果。

FXAA在延迟渲染的表现不甚理想，综合抗锯齿效果上不如TAA或SMAA好。不过SMAA需要额外集成或实现，SMAA在UE的实现在GitHub上可以找到：https://github.com/inequation/UnrealEngine/tree/SMAA-4.12。

FXAA、TAA和SMAA的效果对比图。

TAA全称是Temporal Anti-Aliasing，通常被翻译成时间抗锯齿（或临时抗锯齿）。它是Epic Game的Brian Karis（很熟悉的名字吧，本系列文章数次提及他）实现并提出的UE当家抗锯齿技术，并且在SIGGRAPH2014发表了演讲High Quality Temporal Supersampling。2016年，NVIDIA的研究员Marco Salvi发表了改进篇An Excursion in Temporal Superampling。

TAA的核心思想是将MSAA在同一帧的空间采样分摊到时间轴上的多帧采样，然后按照某种权重混合它们：

由于要在多帧中生成采样偏移量（被称为Jitter），可以通过修改投影矩阵达成：

当然，Jitter也可以通过特殊的Pattern或Halton等低差异序列算法生成：

对于移动平均数（Moving Average），可以使用简单的多帧历史数据和当前帧数据混合，但这种采样不足，受限于历史帧的数量，太大会导致带宽暴增。可以用指数型移动平均数，可以模拟几乎无穷大的样本与固定存储：

当当前帧的混合权重\(\alpha\)（UE默认是0.04）足够小时，可以近似等于Simple的方法（这样就可以只保留一帧历史数据）：

但是，以上方法只是适用于静态场景，对于动态场景，需要配合某些方法（如速度缓冲、深度、材质索引、颜色差别、法线变化等）丢弃无效的采样样本（如突然出现或消失在屏幕的像素）。

UE使用的是结合了速度缓冲的重投影（Reprojection）和邻居截取（Neighborhood Clamping）的技术。其中速度缓冲和运动模糊的一致，需要根据速度缓冲重投影或删除Jitter：

这就对速度缓冲的精度要求非常高，需要记录所有像素的运动向量，需要R16G16精度的速度缓冲，对于程序化的动画、滚动的纹理以及半透明物体可能产生瑕疵：

UE为了防止Ghost鬼影，采用了邻居截取（Neighborhood Clamping），先对当前的像素以及周围数个像素的颜色建立一个颜色空间Bounding Box，然后在使用历史的颜色样本之前，先将这个历史的颜色Clamp在这个包围盒的区域内。直观的理解就是，当历史样本的颜色和当前的颜色差别特别大的时候，用这个Clamping尽量拉回到和当前帧这个像素周围差不多的颜色。

需要注意的是，Clamping使用的颜色空间是YCoCg，可以将min和max的基数视作RGB空间的AABB，且可以将Box的朝向定位到亮度方向上：

关于YCoCg颜色空间

也被称为YCgCo，其中Y是亮度值，Cg是绿色量，Co是橙色量。可以和sRGB空间互转，公式如下：

\[\begin{bmatrix} Y \\ Co \\ Cg \end{bmatrix}
=
\begin{bmatrix} \frac{1}{4} & \frac{1}{2} & \frac{1}{4} \\
\frac{1}{2} & 0 & -\frac{1}{2} \\
-\frac{1}{4} & \frac{1}{2} & -\frac{1}{4}\end{bmatrix}
\cdot
\begin{bmatrix} R \\ G \\ B \end{bmatrix}
\]

\[\begin{bmatrix} R \\ G \\ B \end{bmatrix}
=
\begin{bmatrix} 1 & 1 & -1 \\
1 & 0 & 1 \\
1 & -1 & -1\end{bmatrix}
\cdot
\begin{bmatrix} Y \\ Co \\ Cg \end{bmatrix}
\]

下图是正常图片被分解成YCoCg空间的图例（从上到下依次是正常、亮度Y、绿色Cg、橙色Co）：

有了YCoCg的AABB的Box，便可以裁剪历史数据到这个Box的边缘：

NVIDIA版本提出一种改进的方式，叫方差裁剪（Variance Clipping）。先计算最早的两个颜色的矩（Moment），用来建立一个改进的AABB；利用两个矩可以计算出平均值和标准方差，进一步地可以计算出新的基数minc和maxc，用它们来代替旧的AABB：

根据新的AABB计算出一个Gaussian模型，然后用它可以生成更加紧凑的包围盒：

理论部分已经说完了，接下来分析UE的具体实现代码。首先分析TAA的Jitter生成，在InitViews阶段的PreVisibilityFrameSetup：

  1. // Engine\Source\Runtime\Renderer\Private\SceneVisibility.cpp
  3. void FSceneRenderer::PreVisibilityFrameSetup(FRHICommandListImmediate& RHICmdList)
  4. {
  5.     RHICmdList.BeginScene();
  6.     
  7.     (......)
  9.     for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++)
  10.     {
  11.         FViewInfo& View = Views[ViewIndex];
  12.         FSceneViewState* ViewState = View.ViewState;
  14.         (......)
  15.         
  16.         // TAA子像素采样数量.
  17.         int32 CVarTemporalAASamplesValue = CVarTemporalAASamples.GetValueOnRenderThread();
  19.         bool bTemporalUpsampling = View.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::TemporalUpscale;
  20.         
  21.         // 计算视图的TAA子像素偏移量(Jitter).
  22.         if (View.AntiAliasingMethod == AAM_TemporalAA && ViewState && (CVarTemporalAASamplesValue > 0 || bTemporalUpsampling) && View.bAllowTemporalJitter)
  23.         {
  24.             float EffectivePrimaryResolutionFraction = float(View.ViewRect.Width()) / float(View.GetSecondaryViewRectSize().X);
  26.             // 计算TAA采样数量.
  27.             int32 TemporalAASamples = CVarTemporalAASamplesValue;
  28.             {
  29.                 if (Scene->GetFeatureLevel() < ERHIFeatureLevel::SM5)
  30.                 {
  31.                     // 移动端只能使用2采样数量.
  32.                     TemporalAASamples = 2;
  33.                 }
  34.                 else if (bTemporalUpsampling)
  35.                 {
  36.                     // 屏幕百分比<100%的TAA上采样需要额外的时间采样数量, 为最终输出纹理获得稳定的时间采样密度, 避免输出像素对齐的收敛问题.
  37.                     TemporalAASamples = float(TemporalAASamples) * FMath::Max(1.f, 1.f / (EffectivePrimaryResolutionFraction * EffectivePrimaryResolutionFraction));
  38.                 }
  39.                 else if (CVarTemporalAASamplesValue == 5)
  40.                 {
  41.                     TemporalAASamples = 4;
  42.                 }
  44.                 TemporalAASamples = FMath::Clamp(TemporalAASamples, 1, 255);
  45.             }
  47.             // 计算在时间序列的采样点的索引.
  48.             int32 TemporalSampleIndex            = ViewState->TemporalAASampleIndex + 1;
  49.             if(TemporalSampleIndex >= TemporalAASamples || View.bCameraCut)
  50.             {
  51.                 TemporalSampleIndex = 0;
  52.             }
  54.             // 更新view state.
  55.             if (!View.bStatePrevViewInfoIsReadOnly && !bFreezeTemporalSequences)
  56.             {
  57.                 ViewState->TemporalAASampleIndex          = TemporalSampleIndex;
  58.                 ViewState->TemporalAASampleIndexUnclamped = ViewState->TemporalAASampleIndexUnclamped+1;
  59.             }
  61.             // 在时间序列上选择一个子像素采样坐标.
  62.             float SampleX, SampleY;
  63.             if (Scene->GetFeatureLevel() < ERHIFeatureLevel::SM5)
  64.             {
  65.                 float SamplesX[] = { -8.0f/16.0f, 0.0/16.0f };
  66.                 float SamplesY[] = { /* - */ 0.0f/16.0f, 8.0/16.0f };
  67.                 check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
  68.                 SampleX = SamplesX[ TemporalSampleIndex ];
  69.                 SampleY = SamplesY[ TemporalSampleIndex ];
  70.             }
  71.             else if (View.PrimaryScreenPercentageMethod == EPrimaryScreenPercentageMethod::TemporalUpscale)
  72.             {
  73.                 // 均匀分布时域Jitter在[-0.5, 0.5]，因为不再有任何输入和输出像素对齐. 注意此处用的Halton序列.
  74.                 SampleX = Halton(TemporalSampleIndex + 1, 2) - 0.5f;
  75.                 SampleY = Halton(TemporalSampleIndex + 1, 3) - 0.5f;
  77.                 View.MaterialTextureMipBias = -(FMath::Max(-FMath::Log2(EffectivePrimaryResolutionFraction), 0.0f) ) + CVarMinAutomaticViewMipBiasOffset.GetValueOnRenderThread();
  78.                 View.MaterialTextureMipBias = FMath::Max(View.MaterialTextureMipBias, CVarMinAutomaticViewMipBias.GetValueOnRenderThread());
  79.             }
  80.             else if( CVarTemporalAASamplesValue == 2 )
  81.             {
  82.                 // 2xMSAA
  83.                 // Pattern docs: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476218(v=vs.85).aspx
  84.                 //   N.
  85.                 //   .S
  86.                 float SamplesX[] = { -4.0f/16.0f, 4.0/16.0f };
  87.                 float SamplesY[] = { -4.0f/16.0f, 4.0/16.0f };
  88.                 check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
  89.                 SampleX = SamplesX[ TemporalSampleIndex ];
  90.                 SampleY = SamplesY[ TemporalSampleIndex ];
  91.             }
  92.             else if( CVarTemporalAASamplesValue == 3 )
  93.             {
  94.                 // 3xMSAA
  95.                 //   A..
  96.                 //   ..B
  97.                 //   .C.
  98.                 // Rolling circle pattern (A,B,C).
  99.                 float SamplesX[] = { -2.0f/3.0f,  2.0/3.0f,  0.0/3.0f };
  100.                 float SamplesY[] = { -2.0f/3.0f,  0.0/3.0f,  2.0/3.0f };
  101.                 check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
  102.                 SampleX = SamplesX[ TemporalSampleIndex ];
  103.                 SampleY = SamplesY[ TemporalSampleIndex ];
  104.             }
  105.             else if( CVarTemporalAASamplesValue == 4 )
  106.             {
  107.                 // 4xMSAA
  108.                 // Pattern docs: http://msdn.microsoft.com/en-us/library/windows/desktop/ff476218(v=vs.85).aspx
  109.                 //   .N..
  110.                 //   ...E
  111.                 //   W...
  112.                 //   ..S.
  113.                 // Rolling circle pattern (N,E,S,W).
  114.                 float SamplesX[] = { -2.0f/16.0f,  6.0/16.0f, 2.0/16.0f, -6.0/16.0f };
  115.                 float SamplesY[] = { -6.0f/16.0f, -2.0/16.0f, 6.0/16.0f,  2.0/16.0f };
  116.                 check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
  117.                 SampleX = SamplesX[ TemporalSampleIndex ];
  118.                 SampleY = SamplesY[ TemporalSampleIndex ];
  119.             }
  120.             else if( CVarTemporalAASamplesValue == 5 )
  121.             {
  122.                 // Compressed 4 sample pattern on same vertical and horizontal line (less temporal flicker).
  123.                 // Compressed 1/2 works better than correct 2/3 (reduced temporal flicker).
  124.                 //   . N .
  125.                 //   W . E
  126.                 //   . S .
  127.                 // Rolling circle pattern (N,E,S,W).
  128.                 float SamplesX[] = {  0.0f/2.0f,  1.0/2.0f,  0.0/2.0f, -1.0/2.0f };
  129.                 float SamplesY[] = { -1.0f/2.0f,  0.0/2.0f,  1.0/2.0f,  0.0/2.0f };
  130.                 check(TemporalAASamples == UE_ARRAY_COUNT(SamplesX));
  131.                 SampleX = SamplesX[ TemporalSampleIndex ];
  132.                 SampleY = SamplesY[ TemporalSampleIndex ];
  133.             }
  134.             else // 大于5采样数, 则使用Halton序列.
  135.             {
  136.                 float u1 = Halton( TemporalSampleIndex + 1, 2 );
  137.                 float u2 = Halton( TemporalSampleIndex + 1, 3 );
  139.                 // 生成正态分布的样本.
  140.                 // exp( x^2 / Sigma^2 )
  141.                     
  142.                 static auto CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.TemporalAAFilterSize"));
  143.                 float FilterSize = CVar->GetFloat();
  145.                 // 缩放分布以设置非单位方差.
  146.                 // Variance = Sigma^2
  147.                 float Sigma = 0.47f * FilterSize;
  149.                 float OutWindow = 0.5f;
  150.                 float InWindow = FMath::Exp( -0.5 * FMath::Square( OutWindow / Sigma ) );
  151.                     
  152.                 // Box-Muller变换
  153.                 float Theta = 2.0f * PI * u2;
  154.                 float r = Sigma * FMath::Sqrt( -2.0f * FMath::Loge( (1.0f - u1) * InWindow + u1 ) );
  155.                 
  156.                 SampleX = r * FMath::Cos( Theta );
  157.                 SampleY = r * FMath::Sin( Theta );
  158.             }
  160.             // 保存采样数据到View.
  161.             View.TemporalJitterSequenceLength = TemporalAASamples;
  162.             View.TemporalJitterIndex = TemporalSampleIndex;
  163.             View.TemporalJitterPixels.X = SampleX;
  164.             View.TemporalJitterPixels.Y = SampleY;
  166.             View.ViewMatrices.HackAddTemporalAAProjectionJitter(FVector2D(SampleX * 2.0f / View.ViewRect.Width(), SampleY * -2.0f / View.ViewRect.Height()));
  167.         }
  169.     (......)
  170. }

由于UE在PC平台默认的采样数量是8，所以默认使用Halton序列来采样子像素。其中Halton的生成序列如下图所示：

相比随机采样，Halton获得的采样序列更加均匀，且可以获得没有上限的样本数（UE默认限制在8以内）。除此之外，还有Sobel、Niederreiter、Kronecker等低差异序列算法，它们的比较如下图：

对于UE的默认设置，利用Halton生成的前8个序列计算出来的SampleX和SampleY分别是：

  1. 0: (-0.163972363, 0.284008324)
  2. 1: (-0.208000556, -0.360267729)
  3. 2: (0.172162965, 0.144461900)
  4. 3: (-0.430473328, 0.156679258)
  5. 4: (0.0485312343, -0.275233328)
  6. 5: (0.0647613853, 0.367280841)
  7. 6: (-0.147184864, -0.0535709597)
  8. 7: (0.366960347, -0.307915747)

由于有正数有负数，且处于[-0.5, 0.5]之间，说明是基于像素中心(0.5, 0.5)的子像素偏移量。图形化后的坐标点如下：

解析完了Jitter，继续分析TAA是如何在C++组织绘制逻辑的（UE4.26支持第4代和第5代TAA，此处以第4代为分析对象）：

  1. // Engine\Source\Runtime\Renderer\Private\PostProcess\TemporalAA.cpp
  3. FTAAOutputs AddTemporalAAPass(
  4.     FRDGBuilder& GraphBuilder,
  5.     const FViewInfo& View,
  6.     const FTAAPassParameters& Inputs,
  7.     const FTemporalAAHistory& InputHistory,
  8.     FTemporalAAHistory* OutputHistory)
  9. {
  10.     // 记录标记等.
  11.     const bool bSupportsAlpha = IsPostProcessingWithAlphaChannelSupported();
  12.     const int32 IntputTextureCount = (IsDOFTAAConfig(Inputs.Pass) && bSupportsAlpha) ? 2 : 1;
  13.     const bool bIsMainPass = IsMainTAAConfig(Inputs.Pass);
  14.     const bool bCameraCut = !InputHistory.IsValid() || View.bCameraCut;
  16.     const FIntPoint OutputExtent = Inputs.GetOutputExtent();
  18.     // 记录输入区域.
  19.     const FIntRect SrcRect = Inputs.InputViewRect;
  20.     const FIntRect DestRect = Inputs.OutputViewRect;
  21.     const FIntRect PracticableSrcRect = FIntRect::DivideAndRoundUp(SrcRect, Inputs.ResolutionDivisor);
  22.     const FIntRect PracticableDestRect = FIntRect::DivideAndRoundUp(DestRect, Inputs.ResolutionDivisor);
  24.     const uint32 PassIndex = static_cast<uint32>(Inputs.Pass);
  25.     const TCHAR* PassName = kTAAPassNames[PassIndex];
  27.     // 输出纹理.
  28.     FTAAOutputs Outputs;
  29.     // 当前帧的历史纹理.
  30.     TStaticArray<FRDGTextureRef, FTemporalAAHistory::kRenderTargetCount> NewHistoryTexture;
  32.     // 创建输出和历史帧纹理.
  33.     {
  34.         EPixelFormat HistoryPixelFormat = PF_FloatRGBA;
  35.         if (bIsMainPass && Inputs.bUseFast && !bSupportsAlpha && CVarTAAR11G11B10History.GetValueOnRenderThread())
  36.         {
  37.             HistoryPixelFormat = PF_FloatR11G11B10;
  38.         }
  40.         FRDGTextureDesc SceneColorDesc = FRDGTextureDesc::Create2D(
  41.             OutputExtent,
  42.             HistoryPixelFormat,
  43.             FClearValueBinding::Black,
  44.             TexCreate_ShaderResource | TexCreate_UAV);
  46.         if (Inputs.bOutputRenderTargetable)
  47.         {
  48.             SceneColorDesc.Flags |= TexCreate_RenderTargetable;
  49.         }
  51.         const TCHAR* OutputName = kTAAOutputNames[PassIndex];
  53.         for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  54.         {
  55.             NewHistoryTexture[i] = GraphBuilder.CreateTexture(
  56.                 SceneColorDesc,
  57.                 OutputName,
  58.                 ERDGTextureFlags::MultiFrame);
  59.         }
  61.         NewHistoryTexture[0] = Outputs.SceneColor = NewHistoryTexture[0];
  63.         if (IntputTextureCount == 2)
  64.         {
  65.             Outputs.SceneMetadata = NewHistoryTexture[1];
  66.         }
  68.         if (Inputs.bDownsample)
  69.         {
  70.             const FRDGTextureDesc HalfResSceneColorDesc = FRDGTextureDesc::Create2D(
  71.                 SceneColorDesc.Extent / 2,
  72.                 Inputs.DownsampleOverrideFormat != PF_Unknown ? Inputs.DownsampleOverrideFormat : Inputs.SceneColorInput->Desc.Format,
  73.                 FClearValueBinding::Black,
  74.                 TexCreate_ShaderResource | TexCreate_UAV | GFastVRamConfig.Downsample);
  76.             Outputs.DownsampledSceneColor = GraphBuilder.CreateTexture(HalfResSceneColorDesc, TEXT("SceneColorHalfRes"));
  77.         }
  78.     }
  80.     RDG_GPU_STAT_SCOPE(GraphBuilder, TAA);
  82.     TStaticArray<bool, FTemporalAAHistory::kRenderTargetCount> bUseHistoryTexture;
  84.     // 处理FTAAStandaloneCS参数.
  85.     {
  86.         FTAAStandaloneCS::FPermutationDomain PermutationVector;
  87.         PermutationVector.Set<FTAAStandaloneCS::FTAAPassConfigDim>(Inputs.Pass);
  88.         PermutationVector.Set<FTAAStandaloneCS::FTAAFastDim>(Inputs.bUseFast);
  89.         PermutationVector.Set<FTAAStandaloneCS::FTAADownsampleDim>(Inputs.bDownsample);
  90.         PermutationVector.Set<FTAAStandaloneCS::FTAAUpsampleFilteredDim>(true);
  92.         if (IsTAAUpsamplingConfig(Inputs.Pass))
  93.         {
  94.             const bool bUpsampleFiltered = CVarTemporalAAUpsampleFiltered.GetValueOnRenderThread() != 0 || Inputs.Pass != ETAAPassConfig::MainUpsampling;
  95.             PermutationVector.Set<FTAAStandaloneCS::FTAAUpsampleFilteredDim>(bUpsampleFiltered);
  97.             // 根据屏幕百分比设置排列.
  98.             if (SrcRect.Width() > DestRect.Width() ||
  99.                 SrcRect.Height() > DestRect.Height())
  100.             {
  101.                 PermutationVector.Set<FTAAStandaloneCS::FTAAScreenPercentageDim>(2);
  102.             }
  103.             else if (SrcRect.Width() * 100 < 50 * DestRect.Width() &&
  104.                 SrcRect.Height() * 100 < 50 * DestRect.Height() &&
  105.                 Inputs.Pass == ETAAPassConfig::MainSuperSampling)
  106.             {
  107.                 PermutationVector.Set<FTAAStandaloneCS::FTAAScreenPercentageDim>(3);
  108.             }
  109.             else if (SrcRect.Width() * 100 < 71 * DestRect.Width() &&
  110.                 SrcRect.Height() * 100 < 71 * DestRect.Height())
  111.             {
  112.                 PermutationVector.Set<FTAAStandaloneCS::FTAAScreenPercentageDim>(1);
  113.             }
  114.         }
  116.         FTAAStandaloneCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FTAAStandaloneCS::FParameters>();
  118.         // 设置通用的着色器参数.
  119.         const FIntPoint InputExtent = Inputs.SceneColorInput->Desc.Extent;
  120.         const FIntRect InputViewRect = Inputs.InputViewRect;
  121.         const FIntRect OutputViewRect = Inputs.OutputViewRect;
  123.         if (!IsTAAUpsamplingConfig(Inputs.Pass))
  124.         {
  125.             SetupSampleWeightParameters(PassParameters, Inputs, View.TemporalJitterPixels);
  126.         }
  128.         const float ResDivisor = Inputs.ResolutionDivisor;
  129.         const float ResDivisorInv = 1.0f / ResDivisor;
  131.         PassParameters->ViewUniformBuffer = View.ViewUniformBuffer;
  132.         PassParameters->CurrentFrameWeight = CVarTemporalAACurrentFrameWeight.GetValueOnRenderThread();
  133.         PassParameters->bCameraCut = bCameraCut;
  135.         PassParameters->SceneDepthTexture = Inputs.SceneDepthTexture;
  136.         PassParameters->GBufferVelocityTexture = Inputs.SceneVelocityTexture;
  138.         PassParameters->SceneDepthTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  139.         PassParameters->GBufferVelocityTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  141.         PassParameters->StencilTexture = GraphBuilder.CreateSRV(FRDGTextureSRVDesc::CreateWithPixelFormat(Inputs.SceneDepthTexture, PF_X24_G8));
  143.         // 速度缓冲.
  144.         if (!PassParameters->GBufferVelocityTexture)
  145.         {
  146.             PassParameters->GBufferVelocityTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.BlackDummy);;
  147.         }
  149.         // 输入缓冲着色器参数.
  150.         {
  151.             PassParameters->InputSceneColorSize = FVector4(
  152.                 InputExtent.X,
  153.                 InputExtent.Y,
  154.                 1.0f / float(InputExtent.X),
  155.                 1.0f / float(InputExtent.Y));
  156.             PassParameters->InputMinPixelCoord = PracticableSrcRect.Min;
  157.             PassParameters->InputMaxPixelCoord = PracticableSrcRect.Max - FIntPoint(1, 1);
  158.             PassParameters->InputSceneColor = Inputs.SceneColorInput;
  159.             PassParameters->InputSceneColorSampler = TStaticSamplerState<SF_Point>::GetRHI();
  160.             PassParameters->InputSceneMetadata = Inputs.SceneMetadataInput;
  161.             PassParameters->InputSceneMetadataSampler = TStaticSamplerState<SF_Point>::GetRHI();
  162.         }
  164.         PassParameters->OutputViewportSize = FVector4(
  165.             PracticableDestRect.Width(), PracticableDestRect.Height(), 1.0f / float(PracticableDestRect.Width()), 1.0f / float(PracticableDestRect.Height()));
  166.         PassParameters->OutputViewportRect = FVector4(PracticableDestRect.Min.X, PracticableDestRect.Min.Y, PracticableDestRect.Max.X, PracticableDestRect.Max.Y);
  167.         PassParameters->OutputQuantizationError = ComputePixelFormatQuantizationError(NewHistoryTexture[0]->Desc.Format);
  169.         // 设置历史着色器参数.
  170.         {
  171.             FRDGTextureRef BlackDummy = GraphBuilder.RegisterExternalTexture(GSystemTextures.BlackDummy);
  173.             if (bCameraCut)
  174.             {
  175.                 PassParameters->ScreenPosToHistoryBufferUV = FVector4(1.0f, 1.0f, 1.0f, 1.0f);
  176.                 PassParameters->ScreenPosAbsMax = FVector2D(0.0f, 0.0f);
  177.                 PassParameters->HistoryBufferUVMinMax = FVector4(0.0f, 0.0f, 0.0f, 0.0f);
  178.                 PassParameters->HistoryBufferSize = FVector4(1.0f, 1.0f, 1.0f, 1.0f);
  180.                 for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  181.                 {
  182.                     PassParameters->HistoryBuffer[i] = BlackDummy;
  183.                 }
  185.                 // Remove dependency of the velocity buffer on camera cut, given it\'s going to be ignored by the shader.
  186.                 PassParameters->GBufferVelocityTexture = BlackDummy;
  187.             }
  188.             else
  189.             {
  190.                 FIntPoint ReferenceViewportOffset = InputHistory.ViewportRect.Min;
  191.                 FIntPoint ReferenceViewportExtent = InputHistory.ViewportRect.Size();
  192.                 FIntPoint ReferenceBufferSize = InputHistory.ReferenceBufferSize;
  194.                 float InvReferenceBufferSizeX = 1.f / float(InputHistory.ReferenceBufferSize.X);
  195.                 float InvReferenceBufferSizeY = 1.f / float(InputHistory.ReferenceBufferSize.Y);
  197.                 PassParameters->ScreenPosToHistoryBufferUV = FVector4(
  198.                     ReferenceViewportExtent.X * 0.5f * InvReferenceBufferSizeX,
  199.                     -ReferenceViewportExtent.Y * 0.5f * InvReferenceBufferSizeY,
  200.                     (ReferenceViewportExtent.X * 0.5f + ReferenceViewportOffset.X) * InvReferenceBufferSizeX,
  201.                     (ReferenceViewportExtent.Y * 0.5f + ReferenceViewportOffset.Y) * InvReferenceBufferSizeY);
  203.                 FIntPoint ViewportOffset = ReferenceViewportOffset / Inputs.ResolutionDivisor;
  204.                 FIntPoint ViewportExtent = FIntPoint::DivideAndRoundUp(ReferenceViewportExtent, Inputs.ResolutionDivisor);
  205.                 FIntPoint BufferSize = ReferenceBufferSize / Inputs.ResolutionDivisor;
  207.                 PassParameters->ScreenPosAbsMax = FVector2D(1.0f - 1.0f / float(ViewportExtent.X), 1.0f - 1.0f / float(ViewportExtent.Y));
  209.                 float InvBufferSizeX = 1.f / float(BufferSize.X);
  210.                 float InvBufferSizeY = 1.f / float(BufferSize.Y);
  212.                 PassParameters->HistoryBufferUVMinMax = FVector4(
  213.                     (ViewportOffset.X + 0.5f) * InvBufferSizeX,
  214.                     (ViewportOffset.Y + 0.5f) * InvBufferSizeY,
  215.                     (ViewportOffset.X + ViewportExtent.X - 0.5f) * InvBufferSizeX,
  216.                     (ViewportOffset.Y + ViewportExtent.Y - 0.5f) * InvBufferSizeY);
  218.                 PassParameters->HistoryBufferSize = FVector4(BufferSize.X, BufferSize.Y, InvBufferSizeX, InvBufferSizeY);
  220.                 for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  221.                 {
  222.                     if (InputHistory.RT[i].IsValid())
  223.                     {
  224.                         PassParameters->HistoryBuffer[i] = GraphBuilder.RegisterExternalTexture(InputHistory.RT[i]);
  225.                     }
  226.                     else
  227.                     {
  228.                         PassParameters->HistoryBuffer[i] = BlackDummy;
  229.                     }
  230.                 }
  231.             }
  233.             for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  234.             {
  235.                 PassParameters->HistoryBufferSampler[i] = TStaticSamplerState<SF_Bilinear>::GetRHI();
  236.             }
  237.         }
  239.         PassParameters->MaxViewportUVAndSvPositionToViewportUV = FVector4(
  240.             (PracticableDestRect.Width() - 0.5f * ResDivisor) / float(PracticableDestRect.Width()),
  241.             (PracticableDestRect.Height() - 0.5f * ResDivisor) / float(PracticableDestRect.Height()),
  242.             ResDivisor / float(DestRect.Width()),
  243.             ResDivisor / float(DestRect.Height()));
  245.         PassParameters->HistoryPreExposureCorrection = View.PreExposure / View.PrevViewInfo.SceneColorPreExposure;
  247.         {
  248.             float InvSizeX = 1.0f / float(InputExtent.X);
  249.             float InvSizeY = 1.0f / float(InputExtent.Y);
  250.             PassParameters->ViewportUVToInputBufferUV = FVector4(
  251.                 ResDivisorInv * InputViewRect.Width() * InvSizeX,
  252.                 ResDivisorInv * InputViewRect.Height() * InvSizeY,
  253.                 ResDivisorInv * InputViewRect.Min.X * InvSizeX,
  254.                 ResDivisorInv * InputViewRect.Min.Y * InvSizeY);
  255.         }
  257.         PassParameters->EyeAdaptationTexture = GetEyeAdaptationTexture(GraphBuilder, View);
  259.         // 时间上采样特定的参数.
  260.         {
  261.             float InputViewSizeInvScale = Inputs.ResolutionDivisor;
  262.             float InputViewSizeScale = 1.0f / InputViewSizeInvScale;
  264.             PassParameters->TemporalJitterPixels = InputViewSizeScale * View.TemporalJitterPixels;
  265.             PassParameters->ScreenPercentage = float(InputViewRect.Width()) / float(OutputViewRect.Width());
  266.             PassParameters->UpscaleFactor = float(OutputViewRect.Width()) / float(InputViewRect.Width());
  267.             PassParameters->InputViewMin = InputViewSizeScale * FVector2D(InputViewRect.Min.X, InputViewRect.Min.Y);
  268.             PassParameters->InputViewSize = FVector4(
  269.                 InputViewSizeScale * InputViewRect.Width(), InputViewSizeScale * InputViewRect.Height(),
  270.                 InputViewSizeInvScale / InputViewRect.Width(), InputViewSizeInvScale / InputViewRect.Height());
  271.         }
  273.         // UAVs
  274.         {
  275.             for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  276.             {
  277.                 PassParameters->OutComputeTex[i] = GraphBuilder.CreateUAV(NewHistoryTexture[i]);
  278.             }
  280.             if (Outputs.DownsampledSceneColor)
  281.             {
  282.                 PassParameters->OutComputeTexDownsampled = GraphBuilder.CreateUAV(Outputs.DownsampledSceneColor);
  283.             }
  284.         }
  286.         // Debug UAVs
  287.         {
  288.             FRDGTextureDesc DebugDesc = FRDGTextureDesc::Create2D(
  289.                 OutputExtent,
  290.                 PF_FloatRGBA,
  291.                 FClearValueBinding::None,
  292.                 /* InFlags = */ TexCreate_ShaderResource | TexCreate_UAV);
  294.             FRDGTextureRef DebugTexture = GraphBuilder.CreateTexture(DebugDesc, TEXT("Debug.TAA"));
  295.             PassParameters->DebugOutput = GraphBuilder.CreateUAV(DebugTexture);
  296.         }
  298.         TShaderMapRef<FTAAStandaloneCS> ComputeShader(View.ShaderMap, PermutationVector);
  300.         ClearUnusedGraphResources(ComputeShader, PassParameters);
  301.         for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  302.         {
  303.             bUseHistoryTexture[i] = PassParameters->HistoryBuffer[i] != nullptr;
  304.         }
  306.         // 增加TAA处理CS通道.
  307.         FComputeShaderUtils::AddPass(
  308.             GraphBuilder,
  309.             RDG_EVENT_NAME("TAA %s%s %dx%d -> %dx%d",
  310.                 PassName, Inputs.bUseFast ? TEXT(" Fast") : TEXT(""),
  311.                 PracticableSrcRect.Width(), PracticableSrcRect.Height(),
  312.                 PracticableDestRect.Width(), PracticableDestRect.Height()),
  313.             ComputeShader,
  314.             PassParameters,
  315.             FComputeShaderUtils::GetGroupCount(PracticableDestRect.Size(), GTemporalAATileSizeX));
  316.     }
  317.     
  318.     // 处理历史输出数据.
  319.     if (!View.bStatePrevViewInfoIsReadOnly)
  320.     {
  321.         OutputHistory->SafeRelease();
  323.         for (int32 i = 0; i < FTemporalAAHistory::kRenderTargetCount; i++)
  324.         {
  325.             if (bUseHistoryTexture[i])
  326.             {
  327.                 GraphBuilder.QueueTextureExtraction(NewHistoryTexture[i], &OutputHistory->RT[i]);
  328.             }
  329.         }
  331.         OutputHistory->ViewportRect = DestRect;
  332.         OutputHistory->ReferenceBufferSize = OutputExtent * Inputs.ResolutionDivisor;
  333.     }
  335.     return Outputs;
  336. } // AddTemporalAAPass()

下面分析FTAAStandaloneCS使用的CS shader：

  1. // Engine\Shaders\Private\TemporalAA\TAAStandalone.usf
  3. [numthreads(THREADGROUP_SIZEX, THREADGROUP_SIZEY, 1)]
  4. void MainCS(
  5.     uint2 DispatchThreadId : SV_DispatchThreadID,
  6.     uint2 GroupId : SV_GroupID,
  7.     uint2 GroupThreadId : SV_GroupThreadID,
  8.     uint GroupThreadIndex : SV_GroupIndex)
  9. {
  10.     // 获取视口UV.
  11.     float2 ViewportUV = (float2(DispatchThreadId) + 0.5f) * OutputViewportSize.zw;
  12.     
  13.     #if AA_LOWER_RESOLUTION
  14.     {
  15.         ViewportUV = (float2(DispatchThreadId) + 0.5f) * MaxViewportUVAndSvPositionToViewportUV.zw;
  16.         ViewportUV = min(ViewportUV, MaxViewportUVAndSvPositionToViewportUV.xy);
  17.     }
  18.     #endif
  20.     // 曝光缩放.
  21.     float FrameExposureScale = EyeAdaptationLookup();
  22.     FTAAHistoryPayload OutputPayload = TemporalAASample(GroupId, GroupThreadId, GroupThreadIndex, ViewportUV, FrameExposureScale);
  24.     float4 OutColor0 = 0;
  25.     float4 OutColor1 = 0;
  27.     // 处理输出数据.
  28.     #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_COC
  29.     {
  30.         OutColor0.rgb = OutputPayload.Color.rgb;
  31.         OutColor0.a = OutputPayload.CocRadius;
  32.     }
  33.     #elif AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_OPACITY_COC
  34.     {
  35.         OutColor0 = OutputPayload.Color;
  36.         OutColor1.r = OutputPayload.CocRadius;
  37.     }
  38.     #else
  39.     {
  40.         OutColor0 = OutputPayload.Color;
  41.     }
  42.     #endif
  44.     uint2 PixelPos = DispatchThreadId + OutputViewportRect.xy;
  45.     if (all(PixelPos < OutputViewportRect.zw))
  46.     {
  47.         float4 FinalOutput0 = min(MaxHalfFloat.xxxx, OutColor0);
  48.         // 随机量化采样.
  49.         #if AA_ENABLE_STOCASTIC_QUANTIZATION
  50.         {
  51.             uint2 Random = Rand3DPCG16(int3(PixelPos, View.StateFrameIndexMod8)).xy;
  52.             float2 E = Hammersley16(0, 1, Random);
  54.             FinalOutput0.rgb += FinalOutput0.rgb * (E.x * OutputQuantizationError);
  55.         }
  56.         #endif
  58.         // 存储最终的颜色输出.
  59.         OutComputeTex_0[PixelPos] = FinalOutput0;
  61.         #if HISTORY_RENDER_TARGETS == 2
  62.             OutComputeTex_1[PixelPos] = OutColor1;
  63.         #endif
  64.     }
  66.     // 下采样.
  67.     #if TAA_DOWNSAMPLE
  68.     {
  69.         uint P0 = GroupThreadId.x + GroupThreadId.y * THREADGROUP_SIZEX;
  70.         uint P1 = P0 + 1;
  71.         uint P2 = P0 + THREADGROUP_SIZEX;
  72.         uint P3 = P2 + 1;
  74.         GroupSharedDownsampleArray[P0] = OutColor0;
  76.         GroupMemoryBarrierWithGroupSync();
  78.         if (((GroupThreadId.x | GroupThreadId.y) & 1) == 0)
  79.         {
  80.             OutComputeTexDownsampled[PixelPos / 2] =
  81.                 (OutColor0 + GroupSharedDownsampleArray[P1] + GroupSharedDownsampleArray[P2] + GroupSharedDownsampleArray[P3]) * 0.25;
  82.         }
  83.     }
  84.     #endif //TAA_DOWNSAMPLE
  85. }

TAA的主要逻辑在TemporalAASample：

  1. FTAAHistoryPayload TemporalAASample(uint2 GroupId, uint2 GroupThreadId, uint GroupThreadIndex, float2 ViewportUV, float FrameExposureScale)
  2. {
  3.     // 设置TAA输入参数.
  4.     FTAAInputParameters InputParams;
  6.     // 预曝光.
  7.     #if USE_PREEXPOSURE
  8.         InputParams.FrameExposureScale = ToScalarMemory(FrameExposureScale * View.OneOverPreExposure);
  9.     #else
  10.         InputParams.FrameExposureScale = ToScalarMemory(FrameExposureScale);
  11.     #endif
  13.     // 逐像素设置.
  14.     {
  15.         InputParams.GroupId = GroupId;
  16.         InputParams.GroupThreadId = GroupThreadId;
  17.         InputParams.GroupThreadIndex = GroupThreadIndex;
  18.         InputParams.ViewportUV = ViewportUV;
  19.         InputParams.ScreenPos = ViewportUVToScreenPos(ViewportUV);
  20.         InputParams.NearestBufferUV = ViewportUV * ViewportUVToInputBufferUV.xy + ViewportUVToInputBufferUV.zw;
  22.         // 处理单个或多通道的响应AA(responsive AA).
  23.         #if AA_SINGLE_PASS_RESPONSIVE
  24.         {
  25.             const uint kResponsiveStencilMask = 1 << 3;
  26.             
  27.             int2 SceneStencilUV = (int2)trunc(InputParams.NearestBufferUV * InputSceneColorSize.xy);
  28.             uint SceneStencilRef = StencilTexture.Load(int3(SceneStencilUV, 0)) STENCIL_COMPONENT_SWIZZLE;
  30.             InputParams.bIsResponsiveAAPixel = (SceneStencilRef & kResponsiveStencilMask) ? 1.f : 0.f;
  31.         }
  32.         #elif TAA_RESPONSIVE
  33.             InputParams.bIsResponsiveAAPixel = 1.f;
  34.         #else
  35.             InputParams.bIsResponsiveAAPixel = 0.f;
  36.         #endif
  37.     
  38.         // 处理上采样.
  39.         #if AA_UPSAMPLE
  40.         {
  41.             // 像素原点坐标.
  42.             float2 PPCo = ViewportUV * InputViewSize.xy + TemporalJitterPixels;
  43.             // 像素中心坐标.
  44.             float2 PPCk = floor(PPCo) + 0.5;
  45.             // 像素左上角的中心坐标.
  46.             float2 PPCt = floor(PPCo - 0.5) + 0.5;
  47.         
  48.             InputParams.NearestBufferUV = InputSceneColorSize.zw * (InputViewMin + PPCk);
  49.             InputParams.NearestTopLeftBufferUV = InputSceneColorSize.zw * (InputViewMin + PPCt);
  50.         }
  51.         #endif
  52.     }
  54.     // 设置中间结果.
  55.     FTAAIntermediaryResult IntermediaryResult = CreateIntermediaryResult();
  57.     // 查找像素和最近相邻像素的运动向量.
  58.     // ------------------------------------------------
  59.     float3 PosN; // 本像素的位置, 但随后可能是最近的相邻像素.
  60.     PosN.xy = InputParams.ScreenPos;
  62.     PrecacheInputSceneDepth(InputParams);
  63.     PosN.z = SampleCachedSceneDepthTexture(InputParams, int2(0, 0));
  65.     // 最小深度的屏幕位置.
  66.     float2 VelocityOffset = float2(0.0, 0.0);
  67.     #if AA_CROSS // 在深度搜索X模式中使用的像素交叉距离。
  68.     {
  69.         float4 Depths;
  70.         // AA_CROSS默认是2.
  71.         // 左下
  72.         Depths.x = SampleCachedSceneDepthTexture(InputParams, int2(-AA_CROSS, -AA_CROSS));
  73.         // 右上
  74.         Depths.y = SampleCachedSceneDepthTexture(InputParams, int2( AA_CROSS, -AA_CROSS));
  75.         // 左下
  76.         Depths.z = SampleCachedSceneDepthTexture(InputParams, int2(-AA_CROSS,  AA_CROSS));
  77.         // 右下
  78.         Depths.w = SampleCachedSceneDepthTexture(InputParams, int2( AA_CROSS,  AA_CROSS));
  80.         float2 DepthOffset = float2(AA_CROSS, AA_CROSS);
  81.         float DepthOffsetXx = float(AA_CROSS);
  82.         #if HAS_INVERTED_Z_BUFFER
  83.             // Nearest depth is the largest depth (depth surface 0=far, 1=near).
  84.             if(Depths.x > Depths.y) 
  85.             {
  86.                 DepthOffsetXx = -AA_CROSS;
  87.             }
  88.             if(Depths.z > Depths.w) 
  89.             {
  90.                 DepthOffset.x = -AA_CROSS;
  91.             }
  92.             float DepthsXY = max(Depths.x, Depths.y);
  93.             float DepthsZW = max(Depths.z, Depths.w);
  94.             if(DepthsXY > DepthsZW) 
  95.             {
  96.                 DepthOffset.y = -AA_CROSS;
  97.                 DepthOffset.x = DepthOffsetXx; 
  98.             }
  99.             float DepthsXYZW = max(DepthsXY, DepthsZW);
  100.             if(DepthsXYZW > PosN.z) 
  101.             {
  102.                 VelocityOffset = DepthOffset * InputSceneColorSize.zw;
  104.                 PosN.z = DepthsXYZW;
  105.             }
  106.         #else // !HAS_INVERTED_Z_BUFFER
  107.             #error Fix me!
  108.         #endif // !HAS_INVERTED_Z_BUFFER
  109.     }
  110.     #endif    // AA_CROSS
  112.     // 像素或最近像素的摄像机运动(在ScreenPos空间中).
  113.     bool OffScreen = false;
  114.     float Velocity = 0;
  115.     float HistoryBlur = 0;
  116.     float2 HistoryScreenPosition = InputParams.ScreenPos;
  118.     #if 1
  119.     {
  120.         // 当前和上一帧裁剪数据.
  121.         float4 ThisClip = float4( PosN.xy, PosN.z, 1 );
  122.         float4 PrevClip = mul( ThisClip, View.ClipToPrevClip );
  123.         float2 PrevScreen = PrevClip.xy / PrevClip.w;
  124.         float2 BackN = PosN.xy - PrevScreen;
  126.         float2 BackTemp = BackN * OutputViewportSize.xy;
  128.         #if AA_DYNAMIC // 动态模糊.
  129.         {
  130.             float4 EncodedVelocity = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV + VelocityOffset, 0);
  131.             bool DynamicN = EncodedVelocity.x > 0.0;
  132.             if(DynamicN)
  133.             {
  134.                 BackN = DecodeVelocityFromTexture(EncodedVelocity).xy;
  135.             }
  136.             BackTemp = BackN * OutputViewportSize.xy;
  137.         }
  138.         #endif
  140.         Velocity = sqrt(dot(BackTemp, BackTemp));
  141.         #if !AA_BICUBIC
  142.             // Save the amount of pixel offset of just camera motion, used later as the amount of blur introduced by history.
  143.             float HistoryBlurAmp = 2.0;
  144.             HistoryBlur = saturate(abs(BackTemp.x) * HistoryBlurAmp + abs(BackTemp.y) * HistoryBlurAmp);
  145.         #endif
  146.         // 当前像素对应的历史帧位置.
  147.         HistoryScreenPosition = InputParams.ScreenPos - BackN;
  149.         // 检测HistoryBufferUV是否在视口之外.
  150.         OffScreen = max(abs(HistoryScreenPosition.x), abs(HistoryScreenPosition.y)) >= 1.0;
  151.     }
  152.     #endif
  154.     // 缓存输入的颜色数据, 将它们加载到LDS中.
  155.     PrecacheInputSceneColor(/* inout = */ InputParams);
  157.     #if AA_UPSAMPLE_ADAPTIVE_FILTERING == 0
  158.         // 过滤输入数据.
  159.         FilterCurrentFrameInputSamples(
  160.             InputParams,
  161.             /* inout = */ IntermediaryResult);
  162.     #endif
  163.     
  164.     // 计算邻域的包围盒.
  165.     FTAAHistoryPayload NeighborMin;
  166.     FTAAHistoryPayload NeighborMax;
  168.     ComputeNeighborhoodBoundingbox(
  169.         InputParams,
  170.         /* inout = */ IntermediaryResult,
  171.         NeighborMin, NeighborMax);
  173.     // 采样历史数据.
  174.     FTAAHistoryPayload History = SampleHistory(HistoryScreenPosition);
  176.     // 是否需要忽略历史数据(历史数据在视口之外或突然出现).
  177.     bool IgnoreHistory = OffScreen || bCameraCut;
  179.     // 动态抗鬼影.
  180.     // ---------------------
  181.     #if AA_DYNAMIC_ANTIGHOST && AA_DYNAMIC && HISTORY_PAYLOAD_COMPONENTS == 3
  182.     bool Dynamic4; // 判断这个点是不是运动的
  183.     {
  184.         #if !AA_DYNAMIC
  185.             #error AA_DYNAMIC_ANTIGHOST requires AA_DYNAMIC
  186.         #endif
  187.         // 分别采样速度缓冲的下边(Dynamic1), 左边(Dynamic3), 自身(Dynamic4), 右边(Dynamic5), 上面(Dynamic7).
  188.         bool Dynamic1 = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV, 0, int2( 0, -1)).x > 0;
  189.         bool Dynamic3 = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV, 0, int2(-1,  0)).x > 0;
  190.         Dynamic4 = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV, 0).x > 0;
  191.         bool Dynamic5 = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV, 0, int2( 1,  0)).x > 0;
  192.         bool Dynamic7 = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, InputParams.NearestBufferUV, 0, int2( 0,  1)).x > 0;
  194.         // 判断以上任意一点是否运动的
  195.         bool Dynamic = Dynamic1 || Dynamic3 || Dynamic4 || Dynamic5 || Dynamic7;
  196.         // 继续判断是否需要忽略历史数据(不运动且历史的alpha>0).
  197.         IgnoreHistory = IgnoreHistory || (!Dynamic && History.Color.a > 0);
  198.     }
  199.     #endif
  200.     
  201.     // Clamp历史亮度之前先保存之.
  202.     float LumaMin     = GetSceneColorLuma4(NeighborMin.Color);
  203.     float LumaMax     = GetSceneColorLuma4(NeighborMax.Color);
  204.     float LumaHistory = GetSceneColorLuma4(History.Color);
  205.     
  206.     FTAAHistoryPayload PreClampingHistoryColor = History;
  207.     // Clamp历史数据.
  208.     History = ClampHistory(IntermediaryResult, History, NeighborMin, NeighborMax);
  209.     
  210.     // 颜色Clamp之后过滤输入.
  211.     #if AA_UPSAMPLE_ADAPTIVE_FILTERING == 1
  212.     {
  213.         #if AA_VARIANCE
  214.             #error AA_VARIANCE and AA_UPSAMPLE_ADAPTIVE_FILTERING are not compatible because of circular code dependency.
  215.         #endif
  217.         // 忽略历史帧数据.
  218.         if (IgnoreHistory)
  219.         {
  220.             IntermediaryResult.InvFilterScaleFactor = 0;
  221.         }
  223.         IntermediaryResult.InvFilterScaleFactor -= (Velocity * UpscaleFactor) * 0.1;
  224.         IntermediaryResult.InvFilterScaleFactor = max(IntermediaryResult.InvFilterScaleFactor, ScreenPercentage);
  226.         FilterCurrentFrameInputSamples(
  227.             InputParams,
  228.             /* inout = */ IntermediaryResult);
  229.     }
  230.     #endif
  232.     // 重新添加锯齿以锐化
  233.     // -------------------------------
  234.     #if AA_FILTERED && !AA_BICUBIC
  235.     {
  236.         #if AA_UPSAMPLE
  237.             #error Temporal upsample does not support sharpen.
  238.         #endif
  239.         
  240.         // Blend in non-filtered based on the amount of sub-pixel motion.
  241.         float AddAliasing = saturate(HistoryBlur) * 0.5;
  242.         float LumaContrastFactor = 32.0;
  243.         #if AA_YCOCG // TODO: Probably a bug arround here because using Luma4() even with YCOCG=0.
  244.             // 1/4 as bright.
  245.             LumaContrastFactor *= 4.0;
  246.         #endif
  247.         float LumaContrast = LumaMax - LumaMin;
  248.         AddAliasing = saturate(AddAliasing + rcp(1.0 + LumaContrast * LumaContrastFactor));
  249.         IntermediaryResult.Filtered.Color = lerp(IntermediaryResult.Filtered.Color, SampleCachedSceneColorTexture(InputParams, int2(0, 0)).Color, AddAliasing);
  250.     }
  251.     #endif
  252.     
  253.     // 计算混合因子.
  254.     // --------------------
  255.     float BlendFinal;
  256.     {
  257.         float LumaFiltered = GetSceneColorLuma4(IntermediaryResult.Filtered.Color);
  259.         // CurrentFrameWeight是从c++传入的，默认为0.04f
  260.         BlendFinal = IntermediaryResult.FilteredTemporalWeight * CurrentFrameWeight;
  261.         // 根据速度进行插值，速度越大，则BlendFinal越大
  262.         // 速度越大，历史帧越不可信
  263.         BlendFinal = lerp(BlendFinal, 0.2, saturate(Velocity / 40));
  265.         // 确保至少有一些小的贡献.
  266.         BlendFinal = max( BlendFinal, saturate( 0.01 * LumaHistory / abs( LumaFiltered - LumaHistory ) ) );
  268.         #if AA_NAN && (COMPILER_GLSL || COMPILER_METAL)
  269.             // The current Metal & GLSL compilers don\'t handle saturate(NaN) -> 0, instead they return NaN/INF.
  270.             BlendFinal = -min(-BlendFinal, 0.0);
  271.         #endif
  273.         // ResponsiveAA强制成新帧的1/4.
  274.         BlendFinal = InputParams.bIsResponsiveAAPixel ? (1.0/4.0) : BlendFinal;
  276.         #if AA_LERP 
  277.             BlendFinal = 1.0/float(AA_LERP);
  278.         #endif
  279.     
  280.         // 处理DOF.
  281.         #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_COC || AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_OPACITY_COC
  282.         {
  283.             float BilateralWeight = ComputeBilateralWeight(IntermediaryResult.Filtered.CocRadius, History.CocRadius);
  285.             BlendFinal = lerp(1, BlendFinal, BilateralWeight);
  286.         }
  287.         #endif
  288.         
  289.         // 如果是镜头切换, 当前帧强制成1.
  290.         if (bCameraCut)
  291.         {
  292.             BlendFinal = 1.0;
  293.         }
  294.     }
  296.     // 忽略历史帧, 重置数据.
  297.     if (IgnoreHistory)
  298.     {
  299.         // 历史帧等于滤波后的结果.
  300.         History = IntermediaryResult.Filtered;
  301.         #if HISTORY_PAYLOAD_COMPONENTS == 3
  302.             History.Color.a = 0.0;
  303.         #endif
  304.     }
  305.     
  306.     // 最终在历史和过滤颜色之间混合
  307.     // -------------------------------------------------
  308.     // 亮度权重混合.
  309.     float FilterWeight = GetSceneColorHdrWeight(InputParams, IntermediaryResult.Filtered.Color.x);
  310.     float HistoryWeight = GetSceneColorHdrWeight(InputParams, History.Color.x);
  312.     FTAAHistoryPayload OutputPayload;
  313.     {
  314.         // 计算带权重的插值.
  315.         float2 Weights = WeightedLerpFactors(HistoryWeight, FilterWeight, BlendFinal);
  316.         // 增加输出的历史负载数据, 会进行加权, 历史帧的alpha会乘以Weights.x系数下降.
  317.         OutputPayload = AddPayload(MulPayload(History, Weights.x), MulPayload(IntermediaryResult.Filtered, Weights.y));
  318.     }
  320.     // 调整靠近1的Alpha, 0.995 < 0.996 = 254/255
  321.     if (OutputPayload.Color.a > 0.995)
  322.     {
  323.         OutputPayload.Color.a = 1;
  324.     }
  326.     // 转换颜色回到线性空间.
  327.     OutputPayload.Color = TransformBackToRawLinearSceneColor(OutputPayload.Color);
  328.     
  329.     #if AA_NAN // 非法数据.
  330.         OutputPayload.Color = -min(-OutputPayload.Color, 0.0);
  331.         OutputPayload.CocRadius = isnan(OutputPayload.CocRadius) ? 0.0 : OutputPayload.CocRadius;
  332.     #endif
  334.     #if HISTORY_PAYLOAD_COMPONENTS == 3
  335.         #if  AA_DYNAMIC_ANTIGHOST && AA_DYNAMIC 
  336.             // 如果这一帧是运动的话，那么alpha为1，写入历史帧.
  337.             OutputPayload.Color.a = Dynamic4 ? 1 : 0;
  338.         #else
  339.             // 不运动或非动态, Alpha为0.
  340.             OutputPayload.Color.a = 0;
  341.         #endif
  342.     #endif
  344.     return OutputPayload;
  345. }

上面TAA的主流程中涉及到了很多个重要的接口调用，下面继续解析之：

  1. // 过滤当前帧的输入采样数据.
  2. void FilterCurrentFrameInputSamples(
  3.     in FTAAInputParameters InputParams,
  4.     inout FTAAIntermediaryResult IntermediaryResult)
  5. {
  6.     (......)
  8.     FTAAHistoryPayload Filtered;
  10.     {
  11.         // 上采样.
  12.         #if AA_UPSAMPLE
  13.             // Pixel coordinate of the center of output pixel O in the input viewport.
  14.             float2 PPCo = InputParams.ViewportUV * InputViewSize.xy + TemporalJitterPixels;
  16.             // Pixel coordinate of the center of the nearest input pixel K.
  17.             float2 PPCk = floor(PPCo) + 0.5;
  18.         
  19.             // Vector in pixel between pixel K -> O.
  20.             float2 dKO = PPCo - PPCk;
  21.         #endif
  22.         
  23.         // 根据采样数量选择不同的卷积核.
  24.         #if AA_SAMPLES == 9
  25.             const uint SampleIndexes[9] = kSquareIndexes3x3;
  26.         #elif AA_SAMPLES == 5 || AA_SAMPLES == 6
  27.             const uint SampleIndexes[5] = kPlusIndexes3x3;
  28.         #endif
  30.         #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_COC || AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_OPACITY_COC
  31.             // Fetches center pixel\'s Coc for the bilateral filtering.
  32.             float CenterCocRadius = SampleCachedSceneColorTexture(InputParams, int2(0, 0)).CocRadius;
  33.         #endif
  35.         // 计算邻居的HDR, 最终权重和颜色.
  36.         float NeighborsHdrWeight = 0;
  37.         float NeighborsFinalWeight = 0;
  38.         float4 NeighborsColor = 0;
  40.         UNROLL
  41.         for (uint i = 0; i < AA_SAMPLES; i++)
  42.         {
  43.             // 从最近的输入像素获得样本偏移量.
  44.             int2 SampleOffset;
  45.             
  46.             #if AA_UPSAMPLE && AA_SAMPLES == 6
  47.                 if (i == 5)
  48.                 {
  49.                     SampleOffset = SignFastInt(dKO);
  50.                 }
  51.                 else
  52.             #endif
  53.             {
  54.                 const uint SampleIndex = SampleIndexes[i];
  55.                 SampleOffset = kOffsets3x3[SampleIndex];
  56.             }
  57.             float2 fSampleOffset = float2(SampleOffset);
  58.             
  59.             // When doing Coc bilateral, the center sample is accumulated last.
  60.             #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_COC && 0
  61.                 if (all(SampleOffset == 0) && (AA_SAMPLES != 6 || i != 5))
  62.                 {
  63.                     continue;
  64.                 }
  65.             #endif
  67.             // 找出这个输入样本的空间权值.
  68.             #if AA_UPSAMPLE
  69.                 // 计算输出像素和输入像素I之间的像素增量.
  70.                 // 注意: abs() 不必要, 因为后面会用dot(dPP, dPP).
  71.                 float2 dPP = fSampleOffset - dKO;
  73.                 float SampleSpatialWeight = ComputeSampleWeigth(IntermediaryResult, dPP);
  75.             #elif AA_SAMPLES == 9
  76.                 float SampleSpatialWeight = SampleWeights[i];
  78.             #elif AA_SAMPLES == 5
  79.                 float SampleSpatialWeight = PlusWeights[i];
  81.             #else
  82.                 #error Do not know how to compute filtering sample weight.
  83.             #endif
  85.             // 获取颜色采样.
  86.             FTAASceneColorSample Sample = SampleCachedSceneColorTexture(InputParams, SampleOffset);
  87.                 
  88.             // 查找采样点的HDR权重.
  89.             #if AA_TONE
  90.                 float SampleHdrWeight = Sample.HdrWeight;
  91.             #else
  92.                 float SampleHdrWeight = 1;
  93.             #endif
  95.             // 根据有效负载求出样本的双边权重.
  96.             #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_COC
  97.                 float BilateralWeight = ComputeNeightborSampleBilateralWeight(CenterCocRadius, Sample.CocRadius);
  99.             #else
  100.                 float BilateralWeight = 1;
  102.             #endif
  104.             // 计算最终采样权重.
  105.             float SampleFinalWeight = SampleSpatialWeight * SampleHdrWeight * BilateralWeight;
  107.             // 应用权重到采样颜色中.
  108.             NeighborsColor       += SampleFinalWeight * Sample.Color;
  109.             NeighborsFinalWeight += SampleFinalWeight;
  111.             NeighborsHdrWeight   += SampleSpatialWeight * SampleHdrWeight;
  112.         }
  113.         
  114.         (......)
  115.     }
  117.     IntermediaryResult.Filtered = Filtered;
  118. }
  120. // 计算用于拒绝历史记录的邻域包围盒.
  121. void ComputeNeighborhoodBoundingbox(
  122.     in FTAAInputParameters InputParams,
  123.     in FTAAIntermediaryResult IntermediaryResult,
  124.     out FTAAHistoryPayload OutNeighborMin,
  125.     out FTAAHistoryPayload OutNeighborMax)
  126. {
  127.     // 相邻像素的数据.
  128.     FTAAHistoryPayload Neighbors[kNeighborsCount];
  129.     UNROLL
  130.     for (uint i = 0; i < kNeighborsCount; i++)
  131.     {
  132.         Neighbors[i].Color = SampleCachedSceneColorTexture(InputParams, kOffsets3x3[i]).Color;
  133.         Neighbors[i].CocRadius = SampleCachedSceneColorTexture(InputParams, kOffsets3x3[i]).CocRadius;
  134.     }
  136.     FTAAHistoryPayload NeighborMin;
  137.     FTAAHistoryPayload NeighborMax;
  139.     #if AA_HISTORY_CLAMPING_BOX == HISTORY_CLAMPING_BOX_VARIANCE 
  140.     // 这个就是NVIDIA版本的Variance Clipping.
  141.     {
  142.         #if AA_SAMPLES == 9
  143.             const uint SampleIndexes[9] = kSquareIndexes3x3;
  144.         #elif AA_SAMPLES == 5
  145.             const uint SampleIndexes[5] = kPlusIndexes3x3;
  146.         #else
  147.             #error Unknown number of samples.
  148.         #endif
  150.         // 计算当前像素的矩(moment).
  151.         float4 m1 = 0;
  152.         float4 m2 = 0;
  153.         for( uint i = 0; i < AA_SAMPLES; i++ )
  154.         {
  155.             float4 SampleColor = Neighbors[ SampleIndexes[i] ];
  157.             m1 += SampleColor;
  158.             m2 += Pow2( SampleColor );
  159.         }
  161.         m1 *= (1.0 / AA_SAMPLES);
  162.         m2 *= (1.0 / AA_SAMPLES);
  164.         // 标准方差.
  165.         float4 StdDev = sqrt( abs(m2 - m1 * m1) );
  166.         // 邻居的最大最小值.
  167.         NeighborMin = m1 - 1.25 * StdDev;
  168.         NeighborMax = m1 + 1.25 * StdDev;
  170.         // 跟输入的过滤数据做比较, 找出最大最小值.
  171.         NeighborMin = min( NeighborMin, IntermediaryResult.Filtered );
  172.         NeighborMax = max( NeighborMax, IntermediaryResult.Filtered );
  173.     }
  174.     #elif AA_HISTORY_CLAMPING_BOX == HISTORY_CLAMPING_BOX_SAMPLE_DISTANCE
  175.     // 只在某个半径内执行颜色裁剪.
  176.     {
  177.         float2 PPCo = InputParams.ViewportUV * InputViewSize.xy + TemporalJitterPixels;
  178.         float2 PPCk = floor(PPCo) + 0.5;
  179.         float2 dKO = PPCo - PPCk;
  180.         
  181.         // 总是考虑4个样本.
  182.         NeighborMin = Neighbors[4];
  183.         NeighborMax = Neighbors[4];
  184.         
  185.         // 减少距离阈值作为upsacale因素增加, 以减少鬼影.
  186.         float DistthresholdLerp = UpscaleFactor - 1;
  187.         float DistThreshold = lerp(1.51, 1.3, DistthresholdLerp);
  189.         #if AA_SAMPLES == 9
  190.             const uint Indexes[9] = kSquareIndexes3x3;
  191.         #else
  192.             const uint Indexes[5] = kPlusIndexes3x3;
  193.         #endif
  195.         // 计算所有样本的最大最小值.
  196.         UNROLL
  197.         for( uint i = 0; i < AA_SAMPLES; i++ )
  198.         {
  199.             uint NeightborId = Indexes[i];
  200.             if (NeightborId != 4)
  201.             {
  202.                 float2 dPP = float2(kOffsets3x3[NeightborId]) - dKO;
  204.                 FLATTEN
  205.                 if (dot(dPP, dPP) < (DistThreshold * DistThreshold))
  206.                 {
  207.                     NeighborMin = MinPayload(NeighborMin, Neighbors[NeightborId]);
  208.                     NeighborMax = MaxPayload(NeighborMax, Neighbors[NeightborId]);
  209.                 }
  210.             }
  211.         }
  212.     }
  213.     #elif AA_HISTORY_CLAMPING_BOX == HISTORY_CLAMPING_BOX_MIN_MAX
  214.     // 用最大最小包围盒来裁剪, 是默认的方式.
  215.     {
  216.         NeighborMin = MinPayload3( Neighbors[1], Neighbors[3], Neighbors[4] );
  217.         NeighborMin = MinPayload3( NeighborMin,  Neighbors[5], Neighbors[7] );
  219.         NeighborMax = MaxPayload3( Neighbors[1], Neighbors[3], Neighbors[4] );
  220.         NeighborMax = MaxPayload3( NeighborMax,  Neighbors[5], Neighbors[7] );
  221.         
  222.         #if AA_SAMPLES == 6
  223.         {
  224.             float2 PPCo = InputParams.ViewportUV * InputViewSize.xy + TemporalJitterPixels;
  225.             float2 PPCk = floor(PPCo) + 0.5;
  226.             float2 dKO = PPCo - PPCk;
  227.             
  228.             int2 FifthNeighborOffset = SignFastInt(dKO);
  230.             FTAAHistoryPayload FifthNeighbor;
  231.             FifthNeighbor.Color = SampleCachedSceneColorTexture(InputParams, FifthNeighborOffset).Color;
  232.             FifthNeighbor.CocRadius = SampleCachedSceneColorTexture(InputParams, FifthNeighborOffset).CocRadius;
  233.             
  234.             NeighborMin = MinPayload(NeighborMin, FifthNeighbor);
  235.             NeighborMax = MaxPayload(NeighborMax, FifthNeighbor);
  236.         }
  237.         #elif AA_SAMPLES == 9
  238.         {
  239.             FTAAHistoryPayload NeighborMinPlus = NeighborMin;
  240.             FTAAHistoryPayload NeighborMaxPlus = NeighborMax;
  242.             NeighborMin = MinPayload3( NeighborMin, Neighbors[0], Neighbors[2] );
  243.             NeighborMin = MinPayload3( NeighborMin, Neighbors[6], Neighbors[8] );
  245.             NeighborMax = MaxPayload3( NeighborMax, Neighbors[0], Neighbors[2] );
  246.             NeighborMax = MaxPayload3( NeighborMax, Neighbors[6], Neighbors[8] );
  248.             if( AA_ROUND )
  249.             {
  250.                 NeighborMin = AddPayload(MulPayload(NeighborMin, 0.5), MulPayload(NeighborMinPlus, 0.5));
  251.                 NeighborMax = AddPayload(MulPayload(NeighborMax, 0.5), MulPayload(NeighborMaxPlus, 0.5));
  252.             }
  253.         }
  254.         #endif
  255.     }
  256.     #else
  257.         #error Unknown history clamping box.
  258.     #endif
  260.     OutNeighborMin = NeighborMin;
  261.     OutNeighborMax = NeighborMax;
  262. }
  264. // 采样历史数据.
  265. FTAAHistoryPayload SampleHistory(in float2 HistoryScreenPosition)
  266. {
  267.     float4 RawHistory0 = 0;
  268.     float4 RawHistory1 = 0;
  270.     #if AA_BICUBIC // 用Catmull-Rom曲线采样历史数据, 以减少运动模糊.(默认使用)
  271.     {
  272.         float2 HistoryBufferUV = HistoryScreenPosition * ScreenPosToHistoryBufferUV.xy + ScreenPosToHistoryBufferUV.zw;
  274.         // 裁剪HistoryBufferUV，避免对额外样本的计算.
  275.         #if AA_MANUALLY_CLAMP_HISTORY_UV
  276.             HistoryBufferUV = clamp(HistoryBufferUV, HistoryBufferUVMinMax.xy, HistoryBufferUVMinMax.zw);
  277.         #endif
  279.         FCatmullRomSamples Samples = GetBicubic2DCatmullRomSamples(HistoryBufferUV, HistoryBufferSize.xy, HistoryBufferSize.zw);
  280.         for (uint i = 0; i < Samples.Count; i++)
  281.         {
  282.             float2 SampleUV = Samples.UV[i];
  284.             // 裁剪SampleUV在HistoryBufferUVMinMax内, 避免取样潜在NaN跑到视图区域之外.
  285.             // 可能消耗很大，但Samples.UVDir实际上是编译期常数。
  286.             if (AA_MANUALLY_CLAMP_HISTORY_UV)
  287.             {
  288.                 if (Samples.UVDir[i].x < 0)
  289.                 {
  290.                     SampleUV.x = max(SampleUV.x, HistoryBufferUVMinMax.x);
  291.                 }
  292.                 else if (Samples.UVDir[i].x > 0)
  293.                 {
  294.                     SampleUV.x = min(SampleUV.x, HistoryBufferUVMinMax.z);
  295.                 }
  297.                 if (Samples.UVDir[i].y < 0)
  298.                 {
  299.                     SampleUV.y = max(SampleUV.y, HistoryBufferUVMinMax.y);
  300.                 }
  301.                 else if (Samples.UVDir[i].y > 0)
  302.                 {
  303.                     SampleUV.y = min(SampleUV.y, HistoryBufferUVMinMax.w);
  304.                 }
  305.             }
  307.             RawHistory0 += HistoryBuffer_0.SampleLevel(HistoryBufferSampler_0, SampleUV, 0) * Samples.Weight[i];
  308.         }
  309.         RawHistory0 *= Samples.FinalMultiplier;
  310.     }
  311.     // 双线性采样历史数据.
  312.     #else
  313.     {
  314.         // Clamp HistoryScreenPosition to be within viewport.
  315.         if (AA_MANUALLY_CLAMP_HISTORY_UV)
  316.         {
  317.             HistoryScreenPosition = clamp(HistoryScreenPosition, -ScreenPosAbsMax, ScreenPosAbsMax);
  318.         }
  320.         float2 HistoryBufferUV = HistoryScreenPosition * ScreenPosToHistoryBufferUV.xy + ScreenPosToHistoryBufferUV.zw;
  322.         RawHistory0 = HistoryBuffer_0.SampleLevel(HistoryBufferSampler_0, HistoryBufferUV, 0);
  323.     }
  324.     #endif
  326.     #if HISTORY_RENDER_TARGETS == 2
  327.     {
  328.         if (AA_MANUALLY_CLAMP_HISTORY_UV)
  329.         {
  330.             HistoryScreenPosition = clamp(HistoryScreenPosition, -ScreenPosAbsMax, ScreenPosAbsMax);
  331.         }
  333.         float2 HistoryBufferUV = HistoryScreenPosition * ScreenPosToHistoryBufferUV.xy + ScreenPosToHistoryBufferUV.zw;
  335.         RawHistory1 = HistoryBuffer_1.SampleLevel(HistoryBufferSampler_1, HistoryBufferUV, 0);
  336.     }
  337.     #endif
  338.     
  339.     // 处理和保存历史数据的结果.
  340.     FTAAHistoryPayload HistoryPayload;
  341.     HistoryPayload.Color = RawHistory0;
  343.     #if AA_HISTORY_PAYLOAD == HISTORY_PAYLOAD_RGB_OPACITY_COC
  344.         HistoryPayload.CocRadius = RawHistory1.r;
  345.     #else
  346.         HistoryPayload.CocRadius = RawHistory0.a;
  347.     #endif
  349.     #if USE_PREEXPOSURE
  350.         HistoryPayload.Color.rgb *= HistoryPreExposureCorrection;
  351.     #endif
  353.     HistoryPayload.Color = TransformSceneColor(HistoryPayload.Color);
  355.     return HistoryPayload;
  356. }
  358. // 裁剪历史数据.
  359. FTAAHistoryPayload ClampHistory(inout FTAAIntermediaryResult IntermediaryResult, FTAAHistoryPayload History, FTAAHistoryPayload NeighborMin, FTAAHistoryPayload NeighborMax)
  360. {
  361.     #if !AA_CLAMP
  362.         return History;
  363.     
  364.     #elif AA_CLIP // 使用更紧的AABB裁剪历史数据.
  365.         // 裁剪历史，这使用颜色AABB相交更紧.
  366.         float4 TargetColor = Filtered;
  368.         // 历史裁剪.
  369.         float ClipBlend = HistoryClip( HistoryColor.rgb, TargetColor.rgb, NeighborMin.rgb, NeighborMax.rgb );
  370.         // 裁剪到0~1.
  371.         ClipBlend = saturate( ClipBlend );
  373.         // 根据混合权重插值历史和目标颜色.
  374.         HistoryColor = lerp( HistoryColor, TargetColor, ClipBlend );
  376.         #if AA_FORCE_ALPHA_CLAMP
  377.             HistoryColor.a = clamp( HistoryColor.a, NeighborMin.a, NeighborMax.a );
  378.         #endif
  380.         return HistoryColor;
  382.     #else //!AA_CLIP, 使用Neighborhood clamping(邻域裁剪).
  383.         History.Color = clamp(History.Color, NeighborMin.Color, NeighborMax.Color);
  384.         History.CocRadius = clamp(History.CocRadius, NeighborMin.CocRadius, NeighborMax.CocRadius);
  385.         return History;
  386.     #endif
  387. }

此外，重点说下当前帧和历史帧的权重插值WeightedLerpFactors：

  1. // Engine\Shaders\Private\TemporalAA\TAACommon.ush
  3. taa_half2 WeightedLerpFactors(taa_half WeightA, taa_half WeightB, taa_half Blend)
  4. {
  5.     // 先插值获得带权重的A和B.
  6.     taa_half BlendA = (taa_half(1.0) - Blend) * WeightA;
  7.     taa_half BlendB = Blend * WeightB;
  8.     // 计算它们和的倒数.
  9.     taa_half RcpBlend = SafeRcp(BlendA + BlendB);
  10.     // 用它们和的倒数归一化.
  11.     BlendA *= RcpBlend;
  12.     BlendB *= RcpBlend;
  13.     // 输出结果.
  14.     return taa_half2(BlendA, BlendB);
  15. }

上面的权重插值和线性插值不一样，关键是会将A和B的权重考虑进去，并除以它们的和来达到归一化的目的。

若用公式表达，则WeightA的插值结果WeightA‘的计算公式为：

\[{WeightA}\’ = \cfrac{(1.0-\text{Blend}) \cdot \text{WeightA} }{(1.0-\text{Blend}) \cdot \text{WeightA}+\text{Blend} \cdot \text{WeightB}}
\]

WeightB的插值结果WeightB‘的计算公式为：

\[{WeightB}\’ = \cfrac{\text{Blend} \cdot \text{WeightB} }{(1.0-\text{Blend}) \cdot \text{WeightA}+\text{Blend} \cdot \text{WeightB}}
\]

下面展示一下无AA、FXX、TAA的对比效果图：

不过，不要被上面的静态对比图给蒙蔽了，实际上，在运动的画面中，TAA还是存在不少问题，比如细小的物体的颗粒感、画面变模糊、突然消失或出现的像素有瑕疵、存在少许的延时等等。

但目前的硬件性能，在延迟管线下，TAA还是首选的抗锯齿技术。可以用一些Hack方法来缓解上述的瑕疵。

SSR全称Screen Space Reflections（屏幕空间的反射），是在屏幕空间计算光滑表面的反射效果的技术。

UE的SSR效果一览。

SSR和Cubemap、平面反射不一样，效果和效率都鉴于它们之间：

反射类型 效果 消耗 描述
Planar Reflections 高，动态 高 需要用镜像的摄像机渲染多一次
Screen Space Reflections 中，动态 中 基于屏幕空间，存在隐藏几何体和边缘裁剪的问题
Cubemap Reflections 低，静态 低 预生成，只适用于静态物体的反射

SSR的核心思想在于重用屏幕空间的数据：

SSR的核心算法和步骤是对每个像素执行以下步骤：

  • 计算反射射线。
  • 沿着反射射线方向追踪（可用深度缓冲）。
  • 用交点的颜色作为反射颜色。

.jpg)

SSR的步骤和依赖的屏幕空间数据，包含场景颜色、法线、深度和蒙版。

沿着反射射线方向追踪交点时，可用的方法有：

  • 固定步长的Raymarch：实现最简单，但效率差，追踪次数多。
  • 距离场：需预生成，可有效减少追踪次数。
  • Mesh/BVH：要用到分支，实现和数据结构复杂，非缓存一致性的内存访问。
  • Voxels：需预生成，内存消耗大，只能针对高端设备。
  • Hi-Z Buffer（Depth Mip-Map）：GPU友好，不能完美覆盖空间。（下图）

在使用Hi-Z Buffer追踪之前，需要用最小最大值生成深度的MipMap：

对于粗糙（模糊）表面的反射方向，可以使用重要性采样（Halton序列和BRDF）：

在实现过程中，可以使用符合权重条件的邻域射线来复用交点：

如何判定邻域射线可用呢？下图就是其中的一个权重算法：

另外，还有半分辨率来计算SSR，用类似TAA的Jitter方法达到多采样效果：

在追踪方式上，可用稀疏（Sparse）光线追踪优化，将光线追踪从颜色解析中解耦出来，只在半分辨率上执行，提升颜色解析到全分辨率，依然使用4邻域作为解析：

在生成重要性采样的射线时，需要过滤之，将射线模拟成椎体，获得更广范围的交点：

这就需要对场景颜色进行下采样获得Mipmap，模拟不同粗糙度的表面反射交点覆盖的范围。

SSR由于基于屏幕空间数据（相当于覆盖视锥体最前方的一层纸片），因此，会产生隐藏几何体的问题：

SSR的瑕疵，注意食指的倒影，明显被截掉了。

另外，还存在边缘裁剪（Edge Cutoff）的问题：

以上问题可以使用边缘过渡来缓解：

SSR只能用于延迟渲染管线，因为要依赖GBuffer数据、场景颜色和深度的Mipmap，它在渲染管线的流程示意图如下：

SSR内部的渲染过程图示如下：

下面转向分析UE的实现。首先来看SSR渲染的入口和逻辑：

  1. void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
  2. {
  3.     (......)
  4.     
  5.     // 渲染光源.
  6.     RenderLights(GraphBuilder, ...);
  7.     
  8.     (......)
  9.     
  10.     // 渲染反射(包含SSR)和天空光.
  11.     RenderDeferredReflectionsAndSkyLighting(GraphBuilder, ...);
  12.     
  13.     (......)
  14. }
  16. void FDeferredShadingSceneRenderer::RenderDeferredReflectionsAndSkyLighting(
  17.     FRDGBuilder& GraphBuilder,
  18.     TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformBuffer,
  19.     FRDGTextureMSAA SceneColorTexture,
  20.     FRDGTextureRef DynamicBentNormalAOTexture,
  21.     FRDGTextureRef VelocityTexture,
  22.     FHairStrandsRenderingData* HairDatas)
  23. {
  24.     (......)
  26.     for (FViewInfo& View : Views)
  27.     {  
  28.         (......)
  30.         // 处理SSR.
  31.         else if (bScreenSpaceReflections)
  32.         {
  33.             bDenoise = DenoiserMode != 0 && CVarDenoiseSSR.GetValueOnRenderThread();
  34.             bTemporalFilter = !bDenoise && View.ViewState && IsSSRTemporalPassRequired(View);
  36.             ESSRQuality SSRQuality;
  37.             GetSSRQualityForView(View, &SSRQuality, &DenoiserConfig);
  39.             RDG_EVENT_SCOPE(GraphBuilder, "ScreenSpaceReflections(Quality=%d)", int32(SSRQuality));
  41.             // 渲染SSR.
  42.             RenderScreenSpaceReflections(GraphBuilder, SceneTextures, SceneColorTexture.Resolve, View, SSRQuality, bDenoise, &DenoiserInputs);
  43.         }
  44.             
  45.     (......)
  46. }
  48. // Engine\Source\Runtime\Renderer\Private\ScreenSpaceRayTracing.cpp
  49.     
  50. void RenderScreenSpaceReflections(
  51.     FRDGBuilder& GraphBuilder,
  52.     const FSceneTextureParameters& SceneTextures,
  53.     const FRDGTextureRef CurrentSceneColor,
  54.     const FViewInfo& View,
  55.     ESSRQuality SSRQuality,
  56.     bool bDenoiser,
  57.     IScreenSpaceDenoiser::FReflectionsInputs* DenoiserInputs,
  58.     FTiledScreenSpaceReflection* TiledScreenSpaceReflection)
  59. {
  60.     // 处理输入纹理.
  61.     FRDGTextureRef InputColor = CurrentSceneColor;
  62.     if (SSRQuality != ESSRQuality::VisualizeSSR)
  63.     {
  64.         if (View.PrevViewInfo.CustomSSRInput.IsValid())
  65.         {
  66.             InputColor = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.CustomSSRInput);
  67.         }
  68.         else if (GSSRHalfResSceneColor && View.PrevViewInfo.HalfResTemporalAAHistory.IsValid())
  69.         {
  70.             InputColor = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.HalfResTemporalAAHistory);
  71.         }
  72.         else if (View.PrevViewInfo.TemporalAAHistory.IsValid())
  73.         {
  74.             InputColor = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.TemporalAAHistory.RT[0]);
  75.         }
  76.     }
  78.     const bool SSRStencilPrePass = CVarSSRStencil.GetValueOnRenderThread() != 0 && SSRQuality != ESSRQuality::VisualizeSSR && TiledScreenSpaceReflection == nullptr;
  79.     
  80.     // 为降噪分配输入.
  81.     {
  82.         FRDGTextureDesc Desc = FRDGTextureDesc::Create2D(
  83.             FSceneRenderTargets::Get_FrameConstantsOnly().GetBufferSizeXY(),
  84.             PF_FloatRGBA, FClearValueBinding(FLinearColor(0, 0, 0, 0)),
  85.             TexCreate_RenderTargetable | TexCreate_ShaderResource | TexCreate_UAV);
  87.         Desc.Flags |= GFastVRamConfig.SSR;
  89.         DenoiserInputs->Color = GraphBuilder.CreateTexture(Desc, TEXT("ScreenSpaceReflections"));
  91.         if (bDenoiser)
  92.         {
  93.             Desc.Format = PF_R16F;
  94.             DenoiserInputs->RayHitDistance = GraphBuilder.CreateTexture(Desc, TEXT("ScreenSpaceReflectionsHitDistance"));
  95.         }
  96.     }
  98.     IScreenSpaceDenoiser::FReflectionsRayTracingConfig RayTracingConfigs;
  99.     GetSSRShaderOptionsForQuality(SSRQuality, &RayTracingConfigs);
  100.         
  101.     // SSR通用shader参数.
  102.     FSSRCommonParameters CommonParameters;
  103.     CommonParameters.SSRParams = ComputeSSRParams(View, SSRQuality, false);
  104.     CommonParameters.ViewUniformBuffer = View.ViewUniformBuffer;
  105.     CommonParameters.SceneTextures = SceneTextures;
  107.     if (InputColor == CurrentSceneColor || !CommonParameters.SceneTextures.GBufferVelocityTexture)
  108.     {
  109.         CommonParameters.SceneTextures.GBufferVelocityTexture = GraphBuilder.RegisterExternalTexture(GSystemTextures.MidGreyDummy);
  110.     }
  111.     
  112.     FRenderTargetBindingSlots RenderTargets;
  113.     RenderTargets[0] = FRenderTargetBinding(DenoiserInputs->Color, ERenderTargetLoadAction::ENoAction);
  115.     if (bDenoiser)
  116.     {
  117.         RenderTargets[1] = FRenderTargetBinding(DenoiserInputs->RayHitDistance, ERenderTargetLoadAction::ENoAction);
  118.     }
  120.     // SSR的模板缓冲Pass.
  121.     if (SSRStencilPrePass)
  122.     {
  123.         // 绑定深度缓冲.
  124.         RenderTargets.DepthStencil = FDepthStencilBinding(
  125.             SceneTextures.SceneDepthTexture,
  126.             ERenderTargetLoadAction::ENoAction,
  127.             ERenderTargetLoadAction::ELoad,
  128.             FExclusiveDepthStencil::DepthNop_StencilWrite);
  130.         FScreenSpaceReflectionsStencilPS::FPermutationDomain PermutationVector;
  131.         PermutationVector.Set<FSSROutputForDenoiser>(bDenoiser);
  133.         FScreenSpaceReflectionsStencilPS::FParameters* PassParameters = GraphBuilder.AllocParameters<FScreenSpaceReflectionsStencilPS::FParameters>();
  134.         PassParameters->CommonParameters = CommonParameters;
  135.         PassParameters->RenderTargets = RenderTargets;
  136.         
  137.         TShaderMapRef<FScreenSpaceReflectionsStencilPS> PixelShader(View.ShaderMap, PermutationVector);
  138.         ClearUnusedGraphResources(PixelShader, PassParameters);
  139.         
  140.         // SSR模板Pass.
  141.         GraphBuilder.AddPass(
  142.             RDG_EVENT_NAME("SSR StencilSetup %dx%d", View.ViewRect.Width(), View.ViewRect.Height()),
  143.             PassParameters,
  144.             ERDGPassFlags::Raster,
  145.             [PassParameters, &View, PixelShader](FRHICommandList& RHICmdList)
  146.         {
  147.             SCOPED_GPU_STAT(RHICmdList, ScreenSpaceReflections);
  148.             RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
  149.         
  150.             FGraphicsPipelineStateInitializer GraphicsPSOInit;
  151.             FPixelShaderUtils::InitFullscreenPipelineState(RHICmdList, View.ShaderMap, PixelShader, /* out */ GraphicsPSOInit);
  152.             // Clobers the stencil to pixel that should not compute SSR
  153.             GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always, true, CF_Always, SO_Replace, SO_Replace, SO_Replace>::GetRHI();
  155.             SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  156.             SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
  158.             RHICmdList.SetStencilRef(0x80);
  160.             FPixelShaderUtils::DrawFullscreenTriangle(RHICmdList);
  161.         });
  162.     }
  164.     // 增加SSR pass.
  165.     auto SetSSRParameters = [&](auto* PassParameters)
  166.     {
  167.         {
  168.             const FVector2D HZBUvFactor(
  169.                 float(View.ViewRect.Width()) / float(2 * View.HZBMipmap0Size.X),
  170.                 float(View.ViewRect.Height()) / float(2 * View.HZBMipmap0Size.Y));
  171.             PassParameters->HZBUvFactorAndInvFactor = FVector4(
  172.                 HZBUvFactor.X,
  173.                 HZBUvFactor.Y,
  174.                 1.0f / HZBUvFactor.X,
  175.                 1.0f / HZBUvFactor.Y);
  176.         }
  177.         {
  178.             FIntPoint ViewportOffset = View.ViewRect.Min;
  179.             FIntPoint ViewportExtent = View.ViewRect.Size();
  180.             FIntPoint BufferSize = SceneTextures.SceneDepthTexture->Desc.Extent;
  182.             if (View.PrevViewInfo.TemporalAAHistory.IsValid())
  183.             {
  184.                 ViewportOffset = View.PrevViewInfo.TemporalAAHistory.ViewportRect.Min;
  185.                 ViewportExtent = View.PrevViewInfo.TemporalAAHistory.ViewportRect.Size();
  186.                 BufferSize = View.PrevViewInfo.TemporalAAHistory.ReferenceBufferSize;
  187.                 ensure(ViewportExtent.X > 0 && ViewportExtent.Y > 0);
  188.                 ensure(BufferSize.X > 0 && BufferSize.Y > 0);
  189.             }
  191.             FVector2D InvBufferSize(1.0f / float(BufferSize.X), 1.0f / float(BufferSize.Y));
  193.             PassParameters->PrevScreenPositionScaleBias = FVector4(
  194.                 ViewportExtent.X * 0.5f * InvBufferSize.X,
  195.                 -ViewportExtent.Y * 0.5f * InvBufferSize.Y,
  196.                 (ViewportExtent.X * 0.5f + ViewportOffset.X) * InvBufferSize.X,
  197.                 (ViewportExtent.Y * 0.5f + ViewportOffset.Y) * InvBufferSize.Y);
  199.             PassParameters->ScreenSpaceRayTracingDebugOutput = CreateScreenSpaceRayTracingDebugUAV(GraphBuilder, DenoiserInputs->Color->Desc, TEXT("DebugSSR"), true);
  200.         }
  201.         PassParameters->PrevSceneColorPreExposureCorrection = InputColor != CurrentSceneColor ? View.PreExposure / View.PrevViewInfo.SceneColorPreExposure : 1.0f;
  202.         
  203.         PassParameters->SceneColor = InputColor;
  204.         PassParameters->SceneColorSampler = GSSRHalfResSceneColor ? TStaticSamplerState<SF_Bilinear>::GetRHI() : TStaticSamplerState<SF_Point>::GetRHI();
  205.         
  206.         PassParameters->HZB = GraphBuilder.RegisterExternalTexture(View.HZB);
  207.         PassParameters->HZBSampler = TStaticSamplerState<SF_Point>::GetRHI();
  208.     };
  210.     // SSR的PS参数.
  211.     FScreenSpaceReflectionsPS::FPermutationDomain PermutationVector;
  212.     PermutationVector.Set<FSSRQualityDim>(SSRQuality);
  213.     PermutationVector.Set<FSSROutputForDenoiser>(bDenoiser);
  214.         
  215.     FScreenSpaceReflectionsPS::FParameters* PassParameters = GraphBuilder.AllocParameters<FScreenSpaceReflectionsPS::FParameters>();
  216.     PassParameters->CommonParameters = CommonParameters;
  217.     SetSSRParameters(&PassParameters->SSRPassCommonParameter);
  218.     PassParameters->RenderTargets = RenderTargets;
  220.     TShaderMapRef<FScreenSpaceReflectionsPS> PixelShader(View.ShaderMap, PermutationVector);
  222.     if (TiledScreenSpaceReflection == nullptr) // 非分块SSR(PC默认方式).
  223.     {
  224.         ClearUnusedGraphResources(PixelShader, PassParameters);
  225.         
  226.         // 增加SSR RayMarch通道.
  227.         GraphBuilder.AddPass(
  228.             RDG_EVENT_NAME("SSR RayMarch(Quality=%d RayPerPixel=%d%s) %dx%d",
  229.                 SSRQuality, RayTracingConfigs.RayCountPerPixel, bDenoiser ? TEXT(" DenoiserOutput") : TEXT(""),
  230.                 View.ViewRect.Width(), View.ViewRect.Height()),
  231.             PassParameters,
  232.             ERDGPassFlags::Raster,
  233.             [PassParameters, &View, PixelShader, SSRStencilPrePass](FRHICommandList& RHICmdList)
  234.         {
  235.             SCOPED_GPU_STAT(RHICmdList, ScreenSpaceReflections);
  236.             RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
  237.         
  238.             FGraphicsPipelineStateInitializer GraphicsPSOInit;
  239.             FPixelShaderUtils::InitFullscreenPipelineState(RHICmdList, View.ShaderMap, PixelShader, /* out */ GraphicsPSOInit);
  240.             if (SSRStencilPrePass)
  241.             {
  242.                 // Clobers the stencil to pixel that should not compute SSR
  243.                 GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always, true, CF_Equal, SO_Keep, SO_Keep, SO_Keep>::GetRHI();
  244.             }
  246.             SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  247.             SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
  249.             RHICmdList.SetStencilRef(0x80);
  251.             // 绘制全屏幕.
  252.             FPixelShaderUtils::DrawFullscreenTriangle(RHICmdList);
  253.         });
  254.     }
  255.     else // 分块SSR.
  256.     {
  257.         check(TiledScreenSpaceReflection->TileSize == 8); // WORK_TILE_SIZE
  259.         FScreenSpaceReflectionsTileVS::FPermutationDomain VsPermutationVector;
  260.         TShaderMapRef<FScreenSpaceReflectionsTileVS> VertexShader(View.ShaderMap, VsPermutationVector);
  262.         PassParameters->TileListData = TiledScreenSpaceReflection->TileListStructureBufferSRV;
  263.         PassParameters->IndirectDrawParameter = TiledScreenSpaceReflection->DispatchIndirectParametersBuffer;
  265.         ValidateShaderParameters(VertexShader, *PassParameters);
  266.         ValidateShaderParameters(PixelShader, *PassParameters);
  268.         // 增加SSR RayMarch通道.
  269.         GraphBuilder.AddPass(
  270.             RDG_EVENT_NAME("SSR RayMarch(Quality=%d RayPerPixel=%d%s) %dx%d",
  271.                 SSRQuality, RayTracingConfigs.RayCountPerPixel, bDenoiser ? TEXT(" DenoiserOutput") : TEXT(""),
  272.                 View.ViewRect.Width(), View.ViewRect.Height()),
  273.             PassParameters,
  274.             ERDGPassFlags::Raster,
  275.             [PassParameters, &View, VertexShader, PixelShader, SSRStencilPrePass](FRHICommandList& RHICmdList)
  276.         {
  277.             SCOPED_GPU_STAT(RHICmdList, ScreenSpaceReflections);
  278.             RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
  280.             FGraphicsPipelineStateInitializer GraphicsPSOInit;
  281.             FPixelShaderUtils::InitFullscreenPipelineState(RHICmdList, View.ShaderMap, PixelShader, /* out */ GraphicsPSOInit);
  282.             if (SSRStencilPrePass)
  283.             {
  284.                 // Clobers the stencil to pixel that should not compute SSR
  285.                 GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<false, CF_Always, true, CF_Equal, SO_Keep, SO_Keep, SO_Keep>::GetRHI();
  286.             }
  287.             GraphicsPSOInit.PrimitiveType = GRHISupportsRectTopology ? PT_RectList : PT_TriangleList;
  288.             GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GEmptyVertexDeclaration.VertexDeclarationRHI;
  289.             GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  290.             GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  292.             SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  293.             SetShaderParameters(RHICmdList, VertexShader, VertexShader.GetVertexShader(), *PassParameters);
  294.             SetShaderParameters(RHICmdList, PixelShader, PixelShader.GetPixelShader(), *PassParameters);
  296.             RHICmdList.SetStencilRef(0x80);
  298.             PassParameters->IndirectDrawParameter->MarkResourceAsUsed();
  300.             RHICmdList.DrawPrimitiveIndirect(PassParameters->IndirectDrawParameter->GetIndirectRHICallBuffer(), 0);
  301.         });
  302.     }
  303. } // RenderScreenSpaceReflections()

以上代码可知，SSR是RenderLights之后渲染的。在笔者的PC设备中，SSR采用Quality为2、每像素射线数量为1、非分块的参数：

下面继续分析SSR RayMarch使用的Shader代码：

  1. // Engine\Shaders\Private\SSRT\SSRTReflections.usf
  3. void ScreenSpaceReflections(
  4.     float4 SvPosition
  5.     , out float4 OutColor
  6. #if SSR_OUTPUT_FOR_DENOISER
  7.     , out float4 OutClosestHitDistance
  8. #endif
  9. )
  10. {
  11.     // 获取坐标.
  12.     float2 UV = SvPosition.xy * View.BufferSizeAndInvSize.zw;
  13.     float2 ScreenPos = ViewportUVToScreenPos((SvPosition.xy - View.ViewRectMin.xy) * View.ViewSizeAndInvSize.zw);
  14.     uint2 PixelPos = (uint2)SvPosition.xy;
  15.     
  16.     bool bDebugPrint = all(PixelPos == uint2(View.ViewSizeAndInvSize.xy) / 2);
  18.     OutColor = 0;
  19.     
  20.     #if SSR_OUTPUT_FOR_DENOISER
  21.         OutClosestHitDistance = -2.0;
  22.     #endif
  24.     // 获取GBuffer.
  25.     FGBufferData GBuffer = GetGBufferDataFromSceneTextures(UV);
  27.     float3 N = GBuffer.WorldNormal;
  28.     const float SceneDepth = GBuffer.Depth;
  29.     const float3 PositionTranslatedWorld = mul( float4( ScreenPos * SceneDepth, SceneDepth, 1 ), View.ScreenToTranslatedWorld ).xyz;
  30.     const float3 V = normalize(View.TranslatedWorldCameraOrigin - PositionTranslatedWorld);
  32.     // 修改GGX各向异性法线粗糙度.
  33.     ModifyGGXAnisotropicNormalRoughness(GBuffer.WorldTangent, GBuffer.Anisotropy, GBuffer.Roughness, N, V);
  34.     
  35.     float Roughness = GetRoughness(GBuffer);
  36.     float RoughnessFade = GetRoughnessFade(Roughness);
  38.     // 提前退出. 如果用了模板prepass, 则无用.
  39.     BRANCH if( RoughnessFade <= 0.0 || GBuffer.ShadingModelID == 0 )
  40.     {
  41.         return;
  42.     }
  44.     // 初始化粗糙度, Vis, 最近交点等数据.
  45.     float a = Roughness * Roughness;
  46.     float a2 = a * a;
  47.     
  48.     float NoV = saturate( dot( N, V ) );
  49.     float G_SmithV = 2 * NoV / (NoV + sqrt(NoV * (NoV - NoV * a2) + a2));
  51.     float ClosestHitDistanceSqr = INFINITE_FLOAT;
  53.     // 根据质量等级设置步数, 每像素光线数量, 是否光滑.
  54. #if SSR_QUALITY == 1
  55.     uint NumSteps = 8;
  56.     uint NumRays = 1;
  57.     bool bGlossy = false;
  58. #elif SSR_QUALITY == 2
  59.     uint NumSteps = 16;
  60.     uint NumRays = 1;
  61.     #if SSR_OUTPUT_FOR_DENOISER
  62.         bool bGlossy = true;
  63.     #else
  64.         bool bGlossy = false;
  65.     #endif
  66. #elif SSR_QUALITY == 3
  67.     uint NumSteps = 8;
  68.     uint NumRays = 4;
  69.     bool bGlossy = true;
  70. #else // SSR_QUALITY == 4
  71.     uint NumSteps = 12;
  72.     uint NumRays = 12;
  73.     bool bGlossy = true;
  74. #endif
  75.     
  76.     if( NumRays > 1 ) // 每像素射线大于1
  77.     {
  78.         // 计算噪点和随机数.
  79.         float2 Noise;
  80.         Noise.x = InterleavedGradientNoise( SvPosition.xy, View.StateFrameIndexMod8 );
  81.         Noise.y = InterleavedGradientNoise( SvPosition.xy, View.StateFrameIndexMod8 * 117 );
  82.     
  83.         uint2 Random = Rand3DPCG16( int3( PixelPos, View.StateFrameIndexMod8 ) ).xy;
  84.         
  85.         // 获取当前法线在切线空间的3个正交的基向量.
  86.         float3x3 TangentBasis = GetTangentBasis( N );
  87.         // 切线空间的V向量.
  88.         float3 TangentV = mul( TangentBasis, V );
  90.         float Count = 0;
  92.         // 如果粗糙度很小, 说明是光滑的表面, 修改步数和射线数量.
  93.         if( Roughness < 0.1 )
  94.         {
  95.             NumSteps = min( NumSteps * NumRays, 24u );
  96.             NumRays = 1;
  97.         }
  99.         // 发射NumRays条射线.
  100.         LOOP for( uint i = 0; i < NumRays; i++ )
  101.         {
  102.             float StepOffset = Noise.x;
  103.             StepOffset -= 0.5;
  104.             
  105.             // Hammersley低差异序列.
  106.             float2 E = Hammersley16( i, NumRays, Random );
  107.             // 先对E在圆盘上采样, 再结合粗糙度和切线空间的V向量做GGX重要性采样, 最后将结果变换到切线空间, 获得了切线空间的半向量H.
  108.             float3 H = mul( ImportanceSampleVisibleGGX(UniformSampleDisk(E), a2, TangentV ).xyz, TangentBasis );
  109.             // 计算光源方向.
  110.             float3 L = 2 * dot( V, H ) * H - V;
  112.             float3 HitUVz;
  113.             float Level = 0;
  114.             
  115.             // 如果是光滑表面, 将光源方向转化成其反射向量.
  116.             if( Roughness < 0.1 )
  117.             {
  118.                 L = reflect(-V, N);
  119.             }
  120.             
  121.             // 执行HZB射线检测.
  122.             bool bHit = RayCast(
  123.                 HZB, HZBSampler,
  124.                 PositionTranslatedWorld, L, Roughness, SceneDepth, 
  125.                 NumSteps, StepOffset,
  126.                 HZBUvFactorAndInvFactor,
  127.                 bDebugPrint,
  128.                 HitUVz,
  129.                 Level
  130.             );
  132.             // 如果命中, 采样场景颜色.
  133.             BRANCH if( bHit )
  134.             {
  135.                 ClosestHitDistanceSqr = min(ClosestHitDistanceSqr, ComputeRayHitSqrDistance(PositionTranslatedWorld, HitUVz));
  137.                 float2 SampleUV;
  138.                 float Vignette;
  139.                 // 重投影交点.
  140.                 ReprojectHit(PrevScreenPositionScaleBias, GBufferVelocityTexture, GBufferVelocityTextureSampler, HitUVz, SampleUV, Vignette);
  142.                 // 采样场景颜色.
  143.                 float4 SampleColor = SampleScreenColor( SceneColor, SceneColorSampler, SampleUV ) * Vignette;
  145.                 SampleColor.rgb *= rcp( 1 + Luminance(SampleColor.rgb) );
  146.                 OutColor += SampleColor;
  147.             }
  148.         }
  150.         OutColor /= max( NumRays, 0.0001 );
  151.         OutColor.rgb *= rcp( 1 - Luminance(OutColor.rgb) );
  152.     }
  153.     else // 每像素射线==1
  154.     {
  155.         float StepOffset = InterleavedGradientNoise(SvPosition.xy, View.StateFrameIndexMod8);
  156.         StepOffset -= 0.5;
  157.         
  158.         float3 L;
  159.         if (bGlossy)
  160.         {
  161.             float2 E = Rand1SPPDenoiserInput(PixelPos);
  162.             
  163.             #if SSR_OUTPUT_FOR_DENOISER
  164.             {
  165.                 E.y *= 1 - GGX_IMPORTANT_SAMPLE_BIAS;
  166.             }
  167.             #endif
  168.             
  169.             float3x3 TangentBasis = GetTangentBasis( N );
  170.             float3 TangentV = mul( TangentBasis, V );
  172.             float3 H = mul( ImportanceSampleVisibleGGX(UniformSampleDisk(E), a2, TangentV ).xyz, TangentBasis );
  173.             L = 2 * dot( V, H ) * H - V;
  174.         }
  175.         else
  176.         {
  177.             L = reflect( -V, N );
  178.         }
  179.         
  180.         float3 HitUVz;
  181.         float Level = 0;
  182.         
  183.         // HZB射线检测.
  184.         bool bHit = RayCast(
  185.             HZB, HZBSampler,
  186.             PositionTranslatedWorld, L, Roughness, SceneDepth,
  187.             NumSteps, StepOffset,
  188.             HZBUvFactorAndInvFactor,
  189.             bDebugPrint,
  190.             HitUVz,
  191.             Level
  192.         );
  194.         // 处理交点后的采样数据.
  195.         BRANCH if( bHit )
  196.         {
  197.             ClosestHitDistanceSqr = ComputeRayHitSqrDistance(PositionTranslatedWorld, HitUVz);
  199.             float2 SampleUV;
  200.             float Vignette;
  201.             ReprojectHit(PrevScreenPositionScaleBias, GBufferVelocityTexture, GBufferVelocityTextureSampler, HitUVz, SampleUV, Vignette);
  203.             OutColor = SampleScreenColor(SceneColor, SceneColorSampler, SampleUV) * Vignette;
  204.         }
  205.     }
  206.     
  207.     // 颜色过渡.
  208.     OutColor *= RoughnessFade;
  209.     OutColor *= SSRParams.r;
  211. #if USE_PREEXPOSURE
  212.     OutColor.rgb *= PrevSceneColorPreExposureCorrection;
  213. #endif
  214.     
  215.     // 为降噪输出最近交点的距离.
  216.     #if SSR_OUTPUT_FOR_DENOISER
  217.     {
  218.         OutClosestHitDistance = ComputeDenoiserConfusionFactor(
  219.             ClosestHitDistanceSqr > 0,
  220.             length(View.TranslatedWorldCameraOrigin - PositionTranslatedWorld),
  221.             sqrt(ClosestHitDistanceSqr));
  222.     }
  223.     #endif
  224. }
  226. // PS主入口.
  227. void ScreenSpaceReflectionsPS(
  228.     float4 SvPosition : SV_POSITION
  229.     , out float4 OutColor : SV_Target0
  230. #if SSR_OUTPUT_FOR_DENOISER
  231.     , out float4 OutClosestHitDistance : SV_Target1
  232. #endif
  233. )
  234. {
  235.     ScreenSpaceReflections(SvPosition, OutColor
  236. #if SSR_OUTPUT_FOR_DENOISER
  237.         ,OutClosestHitDistance
  238. #endif
  239.     );
  240. }

下面分析射线检测RayCast的逻辑主堆栈：

  1. // 射线检测.
  2. bool RayCast(
  3.     Texture2D Texture, SamplerState Sampler,
  4.     float3 RayOriginTranslatedWorld, float3 RayDirection,
  5.     float Roughness, float SceneDepth,
  6.     uint NumSteps, float StepOffset,
  7.     float4 HZBUvFactorAndInvFactor, 
  8.     bool bDebugPrint,
  9.     out float3 OutHitUVz,
  10.     out float Level)
  11. {
  12.     FSSRTRay Ray = InitScreenSpaceRayFromWorldSpace(RayOriginTranslatedWorld, RayDirection, SceneDepth);
  14.     // 检测单个屏幕空间的射线.
  15.     return CastScreenSpaceRay(
  16.         Texture, Sampler,
  17.         Ray,
  18.         Roughness, NumSteps, StepOffset,
  19.         HZBUvFactorAndInvFactor, bDebugPrint,
  20.         /* out */ OutHitUVz,
  21.         /* out */ Level);
  22. } // RayCast()
  25. // 检测单个屏幕空间的射线.
  26. bool CastScreenSpaceRay(
  27.     Texture2D Texture, SamplerState Sampler,
  28.     FSSRTRay Ray,
  29.     float Roughness,
  30.     uint NumSteps, float StepOffset,
  31.     float4 HZBUvFactorAndInvFactor, 
  32.     bool bDebugPrint,
  33.     out float3 OutHitUVz,
  34.     out float Level)
  35. {
  36.     // 初始化射线的起点, 步长等.
  37.     const float3 RayStartScreen = Ray.RayStartScreen;
  38.     float3 RayStepScreen = Ray.RayStepScreen;
  40.     float3 RayStartUVz = float3( (RayStartScreen.xy * float2( 0.5, -0.5 ) + 0.5) * HZBUvFactorAndInvFactor.xy, RayStartScreen.z );
  41.     float3 RayStepUVz  = float3(  RayStepScreen.xy  * float2( 0.5, -0.5 )         * HZBUvFactorAndInvFactor.xy, RayStepScreen.z );
  42.     
  43.     const float Step = 1.0 / NumSteps;
  44.     float CompareTolerance = Ray.CompareTolerance * Step;
  45.     
  46.     float LastDiff = 0;
  47.     Level = 1;
  49.     RayStepUVz *= Step;
  50.     float3 RayUVz = RayStartUVz + RayStepUVz * StepOffset;
  51.     #if IS_SSGI_SHADER && SSGI_TRACE_CONE
  52.         RayUVz = RayStartUVz;
  53.     #endif
  54.     
  55.     float4 MultipleSampleDepthDiff;
  56.     bool4 bMultipleSampleHit; // TODO: Might consumes VGPRS if bug in compiler.
  57.     bool bFoundAnyHit = false;
  58.     
  59.     #if IS_SSGI_SHADER && SSGI_TRACE_CONE
  60.         const float ConeAngle = PI / 4;
  61.         const float d = 1;
  62.         const float r = d * sin(0.5 * ConeAngle);
  63.         const float Exp = 1.6; //(d + r) / (d - r);
  64.         const float ExpLog2 = log2(Exp);
  65.         const float MaxPower = exp2(log2(Exp) * (NumSteps + 1.0)) - 0.9;
  67.         {
  68.             //Level = 2;
  69.         }
  70.     #endif
  72.     uint i;
  74.     // 最多检测NumSteps次, 找到交点就退出循环. 每次检测SSRT_SAMPLE_BATCH_SIZE(4)个采样点.
  75.     LOOP
  76.     for (i = 0; i < NumSteps; i += SSRT_SAMPLE_BATCH_SIZE)
  77.     {
  78.         float2 SamplesUV[SSRT_SAMPLE_BATCH_SIZE];
  79.         float4 SamplesZ;
  80.         float4 SamplesMip;
  82.         // 计算采样坐标, 深度和深度纹理Mip层级.
  83.         #if IS_SSGI_SHADER && SSGI_TRACE_CONE // SSGI或锥体追踪
  84.         {
  85.             UNROLL_N(SSRT_SAMPLE_BATCH_SIZE)
  86.             for (uint j = 0; j < SSRT_SAMPLE_BATCH_SIZE; j++)
  87.             {
  88.                 float S = float(i + j) + StepOffset;
  90.                 float NormalizedPower = (exp2(ExpLog2 * S) - 0.9) / MaxPower;
  92.                 float Offset = NormalizedPower * NumSteps;
  94.                 SamplesUV[j] = RayUVz.xy + Offset * RayStepUVz.xy;
  95.                 SamplesZ[j] = RayUVz.z + Offset * RayStepUVz.z;
  96.             }
  97.         
  98.             SamplesMip.xy = Level;
  99.             Level += (8.0 / NumSteps) * Roughness;
  100.         
  101.             SamplesMip.zw = Level;
  102.             Level += (8.0 / NumSteps) * Roughness;
  103.         }
  104.         #else // SSR执行此分支.
  105.         {
  106.             UNROLL_N(SSRT_SAMPLE_BATCH_SIZE)
  107.             for (uint j = 0; j < SSRT_SAMPLE_BATCH_SIZE; j++)
  108.             {
  109.                 SamplesUV[j] = RayUVz.xy + (float(i) + float(j + 1)) * RayStepUVz.xy;
  110.                 SamplesZ[j] = RayUVz.z + (float(i) + float(j + 1)) * RayStepUVz.z;
  111.             }
  112.         
  113.             // 采样深度的Mip层级.
  114.             SamplesMip.xy = Level;
  115.             // 调整层级, 注意受粗糙度影响, 粗糙度越小, Level也越小.
  116.             Level += (8.0 / NumSteps) * Roughness;
  117.         
  118.             SamplesMip.zw = Level;
  119.             Level += (8.0 / NumSteps) * Roughness;
  120.         }
  121.         #endif
  123.         // 采样场景深度.
  124.         float4 SampleDepth;
  125.         {
  126.             UNROLL_N(SSRT_SAMPLE_BATCH_SIZE)
  127.             for (uint j = 0; j < SSRT_SAMPLE_BATCH_SIZE; j++)
  128.             {
  129.                 SampleDepth[j] = Texture.SampleLevel(Sampler, SamplesUV[j], SamplesMip[j]).r;
  130.             }
  131.         }
  133.         // 计算是否相交.
  134.         // 计算射线采样点深度和深度纹理的差异.
  135.         MultipleSampleDepthDiff = SamplesZ - SampleDepth;
  136.         // 检测是否小于深度对比容忍值.
  137.         bMultipleSampleHit = abs(MultipleSampleDepthDiff + CompareTolerance) < CompareTolerance;
  138.         // 4个采样点只要有1个满足就算相交.
  139.         bFoundAnyHit = any(bMultipleSampleHit);
  141.         // 找到交点, 退出循环.
  142.         BRANCH
  143.         if (bFoundAnyHit)
  144.         {
  145.             break;
  146.         }
  148.         LastDiff = MultipleSampleDepthDiff.w;
  149.     } // for( uint i = 0; i < NumSteps; i += 4 )
  150.     
  151.     // 计算输出坐标.
  152.     BRANCH
  153.     if (bFoundAnyHit)
  154.     {
  155.         (......)
  156.         #else // SSR
  157.         {
  158.             float DepthDiff0 = MultipleSampleDepthDiff[2];
  159.             float DepthDiff1 = MultipleSampleDepthDiff[3];
  160.             float Time0 = 3;
  162.             FLATTEN
  163.             if (bMultipleSampleHit[2])
  164.             {
  165.                 DepthDiff0 = MultipleSampleDepthDiff[1];
  166.                 DepthDiff1 = MultipleSampleDepthDiff[2];
  167.                 Time0 = 2;
  168.             }
  169.             FLATTEN
  170.             if (bMultipleSampleHit[1])
  171.             {
  172.                 DepthDiff0 = MultipleSampleDepthDiff[0];
  173.                 DepthDiff1 = MultipleSampleDepthDiff[1];
  174.                 Time0 = 1;
  175.             }
  176.             FLATTEN
  177.             if (bMultipleSampleHit[0])
  178.             {
  179.                 DepthDiff0 = LastDiff;
  180.                 DepthDiff1 = MultipleSampleDepthDiff[0];
  181.                 Time0 = 0;
  182.             }
  184.             Time0 += float(i);
  185.             float Time1 = Time0 + 1;
  187.             // 利用线段交点找到更准确的交点.
  188.             float TimeLerp = saturate(DepthDiff0 / (DepthDiff0 - DepthDiff1));
  189.             float IntersectTime = Time0 + TimeLerp;
  190.                 
  191.             OutHitUVz = RayUVz + RayStepUVz * IntersectTime;
  192.         }
  193.         #endif
  195.         // 输出交点的数据.
  196.         OutHitUVz.xy *= HZBUvFactorAndInvFactor.zw;
  197.         OutHitUVz.xy = OutHitUVz.xy * float2( 2, -2 ) + float2( -1, 1 );
  198.         OutHitUVz.xy = OutHitUVz.xy * View.ScreenPositionScaleBias.xy + View.ScreenPositionScaleBias.wz;
  199.     }
  200.     else
  201.     {
  202.         OutHitUVz = float3(0, 0, 0);
  203.     }
  204.     
  205.     return bFoundAnyHit;
  206. } // CastScreenSpaceRay()

SSR的RayMarch每次循环执行4个采样点，以减少循环次数，深度的Level随着采样点而增加，且受粗糙度影响，这也符合物理原理：越光滑的表面，反射的颜色越清晰，对应的Mip层级越小。在测试交点时允许一定范围的深度误差，以加快检测。

根据RenderDoc截帧，可以发现其使用的场景颜色不是本帧的，而是上一帧的TAA数据：

这主要是因为TAA在后处理阶段执行，在SSR阶段，本帧的场景颜色还未执行后处理，还处于未抗锯齿的原始状态，直接使用势必降低SSR效果。由于SSR的RayMarch的SPP默认才1，意味着此阶段的颜色带有明显的噪点：

这就需要后续步骤进行降噪，UE是在TAA阶段处理的：

上：SSR带噪点纹理；中：TAA的历史帧纹理；下：TAA处理后的纹理。

AO（Ambient Occlusion）的本质是遮蔽来自环境光（非直接光），它可以通过发射很多射线来计算被遮挡的系数：

在实时渲染，计算遮挡系数存在两种方式：物体空间和屏幕空间。物体空间的AO使用真实的几何体进行射线检测，根据场景复杂度呈指数级的消耗，通常比较慢，需要复杂的物体简化和空间的数据结构技术。而屏幕空间的AO在后处理阶段完成，不需要预处理数据，不依赖场景复杂度，实现简单，消耗较低，但不是物理正确的，只能得到近似的遮挡结果。

限制表面法线形成的半球半径来近似AO，可以在封闭区域（enclosed area，如室内）比较好且有效地获得遮挡效果：

SSAO（Screen Space Ambient Occlusion）使用深度缓冲来近似场景物体，给每个像素在球体范围内采样若干次，并测试深度缓冲：

如果超过一半的采样点不被遮挡（通过了深度测试），AO将被应用。如果法线不可以，则需要用球体代替半球体：

这种基于屏幕空间的深度测试是存在瑕疵的，比如下图中的箭头所指的点，虽然不可以通过深度测试，但其实是没有被遮挡的点：

如果拥有法线信息，则可以将SSAO升级成HBAO（Horizon Based Ambient Occlusion），它会在法线形成的半球内采样，在深度缓冲中近似光线追踪：

HBAO采用更加精准的计算公式：

SSAO还可以采用半分辨率来加速计算，但也会在细小的高频物体（如草）产生闪烁的瑕疵。

除了SSAO和HBAO之外，还存在SSDO（Screen Space Directional Occlusion，屏幕空间方向遮挡）的技术，它和SSAO不同之处在于：SSAO会给每个像素生成多个采样点来累积遮挡系数，而SSDO会给每个像素生成多个方向来累积它们的辐射率：

SSDO在可见性测试也有所不同，过程更加复杂，结合下图加以描述。

对每个像素执行以下操作：

  • 在像素P点以半径\(r_{max}\)​结合法线形成的半球内计算N个采样点（A-D），每个采样点执行以下操作：
    • 将采样点投影到屏幕空间。
    • 根据深度缓冲计算表面位置。
    • 如果采样点向上，将视作被遮挡（如图中的A、B、D点）。
    • 如果采样点向下，则P点被来自这个方向（C）的光照照亮（采用模糊的环境图，滤波约等于\(2\pi/N\)​​）。

对于非直接光照的计算，SSDO采用这样的方式：将每个采样点当成很小的区域光，朝向像素法线，然后给每个采样点计算到P点的形状因子（form factor），并累积贡献量，获得一次间接光反弹的近似结果：

相比SSAO，SDAO有方向性，且有颜色，从而获得了类似Color Bleeding的GI效果：

除了上述的AO技术，还有HBAO+、HDAO（High Definition Ambient Occlusion）、Hybrid Ambient Occlusion、MSSAO（Multi-Resolution Screen-Space Ambient Occlusion）、VXAO（Voxel Accelerated Ambient Occlusion）和GTAO（Ground-Truth Ambient Occlusion）等等AO技术。

阐述完SSAO及相关技术的理论，接下来直接进入UE的代码实现。UE的SSAO入口位于RenderBasePass和RenderLights之间：

  1. void FDeferredShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
  2. {
  3.     (......)
  4.     
  5.     RenderBasePass(...);
  6.     
  7.     (......)
  8.     
  9.     // 准备光照之前的组合光照阶段，如延迟贴花、SSO等。
  10.     GCompositionLighting.Reset();
  11.     if (FeatureLevel >= ERHIFeatureLevel::SM5)
  12.     {
  13.         (......)
  15.         for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
  16.         {
  17.             const FViewInfo& View = Views[ViewIndex];
  18.             // SSAO在此接口渲染.
  19.             GCompositionLighting.ProcessAfterBasePass(GraphBuilder, Scene->UniformBuffers, View, SceneTextures);
  20.         }
  21.         
  22.         (......)
  23.     }
  24.     
  25.     (......)
  26.     
  27.     RenderLights(...);
  28. }

下面分析GCompositionLighting::ProcessAfterBasePass：

  1. // Engine\Source\Runtime\Renderer\Private\CompositionLighting\CompositionLighting.cpp
  3. void FCompositionLighting::ProcessAfterBasePass(
  4.     FRDGBuilder& GraphBuilder,
  5.     FPersistentUniformBuffers& UniformBuffers,
  6.     const FViewInfo& View,
  7.     TRDGUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformBuffer)
  8. {
  9.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(GraphBuilder.RHICmdList);
  11.     if (CanOverlayRayTracingOutput(View))
  12.     {
  13.         const FSceneViewFamily& ViewFamily = *View.Family;
  14.         RDG_EVENT_SCOPE(GraphBuilder, "LightCompositionTasks_PreLighting");
  16.         AddPass(GraphBuilder, [&UniformBuffers, &View](FRHICommandList&)
  17.         {
  18.             UniformBuffers.UpdateViewUniformBuffer(View);
  19.         });
  21.         (......)
  23.         // Forward shading SSAO is applied before the base pass using only the depth buffer.
  24.         // SSAO只需要深度缓冲, 不需要GBuffer, 可以在
  25.         if (!IsForwardShadingEnabled(View.GetShaderPlatform()))
  26.         {
  27.             FScreenPassRenderTarget FinalTarget = FScreenPassRenderTarget(GraphBuilder.RegisterExternalTexture(SceneContext.ScreenSpaceAO, TEXT("AmbientOcclusionDirect")), View.ViewRect, ERenderTargetLoadAction::ENoAction);
  29.             FScreenPassTexture AmbientOcclusion;
  31.             // 根据SSAO级别和类型选择不同的渲染方式.
  32.             const uint32 SSAOLevels = FSSAOHelper::ComputeAmbientOcclusionPassCount(View);
  33.             if (SSAOLevels)
  34.             {
  35.                 const EGTAOType GTAOType = FSSAOHelper::GetGTAOPassType(View, SSAOLevels);
  37.                 TUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformBufferRHI = CreateSceneTextureUniformBuffer(GraphBuilder.RHICmdList, View.FeatureLevel);
  39.                 // 分离的GTAO.
  40.                 if (GTAOType == EGTAOType::EAsyncHorizonSearch || GTAOType == EGTAOType::EAsyncCombinedSpatial)
  41.                 {
  42.                     (......)
  43.                     
  44.                     AmbientOcclusion = AddPostProcessingGTAOPostAsync(GraphBuilder, View, Parameters, GTAOHorizons, FinalTarget);
  45.                 }
  46.                 else // 非分离的GTAO
  47.                 {
  48.                     if (GTAOType == EGTAOType::ENonAsync)
  49.                     {
  50.                         FGTAOCommonParameters Parameters = GetGTAOCommonParameters(GraphBuilder, View, SceneTexturesUniformBuffer, SceneTexturesUniformBufferRHI, GTAOType);
  51.                         AmbientOcclusion = AddPostProcessingGTAOAllPasses(GraphBuilder, View, Parameters, FinalTarget);
  52.                     }
  53.                     else // 默认情况下, UE执行此分支.
  54.                     {
  55.                         FSSAOCommonParameters Parameters = GetSSAOCommonParameters(GraphBuilder, View, SceneTexturesUniformBuffer, SceneTexturesUniformBufferRHI, SSAOLevels, true);
  56.                         AmbientOcclusion = AddPostProcessingAmbientOcclusion(GraphBuilder, View, Parameters, FinalTarget);
  57.                     }
  58.                     
  59.                     (......)
  60.                 }
  62.                 SceneContext.bScreenSpaceAOIsValid = true;
  63.             }
  64.         }
  65.     }
  66. }

在默认情况下，UE会执行AddPostProcessingAmbientOcclusion，进入此接口分析：

  1. // @param Levels 0..3, how many different resolution levels we want to render
  2. static FScreenPassTexture AddPostProcessingAmbientOcclusion(
  3.     FRDGBuilder& GraphBuilder,
  4.     const FViewInfo& View,
  5.     const FSSAOCommonParameters& CommonParameters,
  6.     FScreenPassRenderTarget FinalTarget)
  7. {
  8.     check(CommonParameters.Levels >= 0 && CommonParameters.Levels <= 3);
  10.     FScreenPassTexture AmbientOcclusionInMip1;
  11.     FScreenPassTexture AmbientOcclusionPassMip1;
  12.     // 如果Level>=2, 则执行1~2次SetupPass, 1~2次StepPass, 1次FinalPass
  13.     if (CommonParameters.Levels >= 2)
  14.     {
  15.         AmbientOcclusionInMip1 =
  16.             AddAmbientOcclusionSetupPass(
  17.                 GraphBuilder,
  18.                 View,
  19.                 CommonParameters,
  20.                 CommonParameters.SceneDepth);
  22.         FScreenPassTexture AmbientOcclusionPassMip2;
  23.         if (CommonParameters.Levels >= 3)
  24.         {
  25.             FScreenPassTexture AmbientOcclusionInMip2 =
  26.                 AddAmbientOcclusionSetupPass(
  27.                     GraphBuilder,
  28.                     View,
  29.                     CommonParameters,
  30.                     AmbientOcclusionInMip1);
  32.             AmbientOcclusionPassMip2 =
  33.                 AddAmbientOcclusionStepPass(
  34.                     GraphBuilder,
  35.                     View,
  36.                     CommonParameters,
  37.                     AmbientOcclusionInMip2,
  38.                     AmbientOcclusionInMip2,
  39.                     FScreenPassTexture(),
  40.                     CommonParameters.HZBInput);
  41.         }
  43.         AmbientOcclusionPassMip1 =
  44.             AddAmbientOcclusionStepPass(
  45.                 GraphBuilder,
  46.                 View,
  47.                 CommonParameters,
  48.                 AmbientOcclusionInMip1,
  49.                 AmbientOcclusionInMip1,
  50.                 AmbientOcclusionPassMip2,
  51.                 CommonParameters.HZBInput);
  52.     }
  54.     FScreenPassTexture FinalOutput =
  55.         AddAmbientOcclusionFinalPass(
  56.             GraphBuilder,
  57.             View,
  58.             CommonParameters,
  59.             CommonParameters.GBufferA,
  60.             AmbientOcclusionInMip1,
  61.             AmbientOcclusionPassMip1,
  62.             CommonParameters.HZBInput,
  63.             FinalTarget);
  65.     return FinalOutput;
  66. }

上面会根据不同的Levels执行不同次数的Setup、Step、Final通道，以笔者的截帧为例，执行了一次Setup两次PS：

Setup阶段只要是对法线执行下采样，以获得半分辨率的法线。下采样的PS代码如下：

  1. // Engine\Shaders\Private\PostProcessAmbientOcclusion.usf
  3. void MainSetupPS(in noperspective float4 UVAndScreenPos : TEXCOORD0, float4 SvPosition : SV_POSITION, out float4 OutColor0 : SV_Target0)
  4. {
  5.     float2 ViewPortSize = AOViewport_ViewportSize;
  6.     float2 InUV = UVAndScreenPos.xy;
  8.     // 4个采样点.
  9.     float2 UV[4];
  10.     UV[0] = InUV + float2(-0.5f, -0.5f) * InputExtentInverse;
  11.     UV[1] = min(InUV + float2( 0.5f, -0.5f) * InputExtentInverse, View.BufferBilinearUVMinMax.zw);
  12.     UV[2] = min(InUV + float2(-0.5f,  0.5f) * InputExtentInverse, View.BufferBilinearUVMinMax.zw);
  13.     UV[3] = min(InUV + float2( 0.5f,  0.5f) * InputExtentInverse, View.BufferBilinearUVMinMax.zw);
  15.     float4 Samples[4];
  16.     
  17.     // 获取输入纹理的4个采样点数据.
  18.     UNROLL for(uint i = 0; i < 4; ++i)
  19.     {
  20. #if COMPUTE_SHADER || FORWARD_SHADING
  21.         // Async compute and forward shading don\'t have access to the gbuffer.
  22.         Samples[i].rgb = normalize(ReconstructNormalFromDepthBuffer(float4(UV[i] * ViewPortSize, SvPosition.zw))) * 0.5f + 0.5f;
  23. #else
  24.         Samples[i].rgb = GetGBufferData(UV[i], true).WorldNormal * 0.5f + 0.5f;
  25. #endif
  26.         Samples[i].a = CalcSceneDepth(UV[i]);
  27.     }
  28.     
  29.     float MaxZ = max( max(Samples[0].a, Samples[1].a), max(Samples[2].a, Samples[3].a));
  31.     // 平均颜色值, 此处采样了深度相似度来作为缩放权重.
  32.     float4 AvgColor = 0.0f;
  33.     if (USE_NORMALS)
  34.     {
  35.         AvgColor = 0.0001f;
  37.         {
  38.             UNROLL for(uint i = 0; i < 4; ++i)
  39.             {
  40.                 AvgColor += float4(Samples[i].rgb, 1) * ComputeDepthSimilarity(Samples[i].a, MaxZ, ThresholdInverse);
  41.             }
  42.             AvgColor.rgb /= AvgColor.w;
  43.         }
  44.     }
  46.     OutColor0 = float4(AvgColor.rgb, MaxZ / Constant_Float16F_Scale);
  47. }

上面在平均颜色值时使用了深度相似度ComputeDepthSimilarity作为颜色的缩放权重：

  1. // 0表示非常不相似, 1表示非常相似.
  2. float ComputeDepthSimilarity(float DepthA, float DepthB, float TweakScale)
  3. {
  4.     return saturate(1 - abs(DepthA - DepthB) * TweakScale);
  5. }

在StepPass，执行半分辨率的AO计算，而在FinalPass，执行了上采样的AO计算，它们使用了一样的PS Shader代码（但参数和宏不一样）：

  1. void MainPS(in noperspective float4 UVAndScreenPos : TEXCOORD0, float4 SvPosition : SV_POSITION, out float4 OutColor : SV_Target0)
  2. {
  3.     MainPSandCS(UVAndScreenPos, SvPosition, OutColor);    
  4. }
  6. // AO计算的主逻辑
  7. void MainPSandCS(in float4 UVAndScreenPos, float4 SvPosition, out float4 OutColor)
  8. {
  9.     OutColor = 0;
  11.     // 下列常量在C++层设置而来.
  12.     float AmbientOcclusionPower = ScreenSpaceAOParams[0].x;
  13.     float Ratio = ScreenSpaceAOParams[1].w;
  14.     float AORadiusInShader = ScreenSpaceAOParams[1].z;
  15.     float InvAmbientOcclusionDistance = ScreenSpaceAOParams[0].z;
  16.     float AmbientOcclusionIntensity = ScreenSpaceAOParams[0].w;
  17.     float2 ViewportUVToRandomUV = ScreenSpaceAOParams[1].xy;
  18.     float AmbientOcclusionBias = ScreenSpaceAOParams[0].y;
  19.     float ScaleFactor = ScreenSpaceAOParams[2].x;
  20.     float ScaleRadiusInWorldSpace = ScreenSpaceAOParams[2].z;
  22.     float2 UV = UVAndScreenPos.xy;
  23.     float2 ScreenPos = UVAndScreenPos.zw;
  25.     float InvTanHalfFov = ScreenSpaceAOParams[3].w;
  26.     float3 FovFix = float3(InvTanHalfFov, Ratio * InvTanHalfFov, 1);
  27.     float3 InvFovFix = 1.0f / FovFix;
  29.     float SceneDepth = GetDepthFromAOInput(UV);
  30.     float3 WorldNormal = GetWorldSpaceNormalFromAOInput(UV, SvPosition);
  32.     // 如果不使用法线(!USE_NORMALS), ViewSpaceNormal可能是NaN.
  33.     float3 ViewSpaceNormal = normalize(mul(WorldNormal, (float3x3)View.TranslatedWorldToView));
  34.     float3 ViewSpacePosition = ReconstructCSPos(SceneDepth, ScreenPos);
  36.     // 计算AO的半球体实际半径.
  37.     float ActualAORadius = AORadiusInShader * lerp(SceneDepth, 1, ScaleRadiusInWorldSpace);
  39.     // 修复之后增加偏移.
  40.     if (USE_NORMALS)
  41.     {
  42.         ViewSpacePosition += AmbientOcclusionBias * SceneDepth * ScaleFactor * (ViewSpaceNormal * FovFix);
  43.     }
  45.     float2 WeightAccumulator = 0.0001f;
  46.     
  47.     // 根据采样质量选择不同的随机向量.
  48. #if AO_SAMPLE_QUALITY != 0
  49.     // no SSAO in this pass, only upsampling
  51. #if AO_SAMPLE_QUALITY == 1
  52.     // no 4x4 randomization
  53.     float2 RandomVec = float2(0, 1) * ActualAORadius;
  54.     {
  55. #elif AO_SAMPLE_QUALITY == 2
  56.     // 从一个4x4重复的纹理中提取16个基向量(旋转和缩放)中的一个.
  57.     float2 RandomVec = (Texture2DSample(RandomNormalTexture, RandomNormalTextureSampler, UV * ViewportUVToRandomUV).rg * 2 - 1) * ActualAORadius;
  58.     {
  59. #else // AO_SAMPLE_QUALITY == 3
  60.     // 从一个4x4重复的纹理中提取16个基向量(旋转和缩放)中的一个，如果启用TemporalAA，则随时间变化.
  62.     // 通过多帧, 仅当TAA启用时, 每帧增加一点抖动可获得更高的质量, 但可能引发鬼影效果.
  63.     const float2 TemporalOffset = ScreenSpaceAOParams[3].xy;
  65.     // 调试模式.
  66.     const bool bDebugLookups = DEBUG_LOOKUPS && ViewSpacePosition.x > 0;
  68.     float2 RandomVec = (Texture2DSample(RandomNormalTexture, RandomNormalTextureSampler, TemporalOffset + UV * ViewportUVToRandomUV).rg * 2 - 1) * ActualAORadius;
  69.     {
  70. #endif // AO_SAMPLE_QUALITY == 
  72.         if(bDebugLookups && ViewSpacePosition.y > 0)
  73.         {
  74.             // top sample are not per pixel rotated
  75.             RandomVec = float2(0, 1) * ActualAORadius;
  76.         }
  78.         float2 FovFixXY = FovFix.xy * (1.0f / ViewSpacePosition.z);
  79.         float4 RandomBase = float4(RandomVec, -RandomVec.y, RandomVec.x) * float4(FovFixXY, FovFixXY);
  80.         float2 ScreenSpacePos = ViewSpacePosition.xy / ViewSpacePosition.z;
  82.         // .x意味着对于非常各向异性的视图用x来缩放.
  83.         float InvHaloSize = 1.0f / (ActualAORadius * FovFixXY.x * 2);
  85.         float3 ScaledViewSpaceNormal = ViewSpaceNormal;
  87. #if OPTIMIZATION_O1
  88.         ScaledViewSpaceNormal *= 0.08f * lerp(SceneDepth, 1000, ScaleRadiusInWorldSpace);
  89. #endif
  91.         UNROLL for(int i = 0; i < SAMPLESET_ARRAY_SIZE; ++i)
  92.         {
  93.             // -1..1
  94.             float2 UnrotatedRandom = OcclusionSamplesOffsets[i].xy;
  96.             float2 LocalRandom = (UnrotatedRandom.x * RandomBase.xy + UnrotatedRandom.y * RandomBase.zw);
  98.             if (bDebugLookups)
  99.             {
  100.                 (......)
  101.             }
  102.             else if (USE_NORMALS) // 有法线
  103.             {
  104.                 float3 LocalAccumulator = 0;
  106.                 UNROLL for(uint step = 0; step < SAMPLE_STEPS; ++step)
  107.                 {
  108.                     // 运行时是常量.
  109.                     float Scale = (step + 1) / (float)SAMPLE_STEPS;
  110.                     // 运行时是常量(越高对纹理的缓存和性能越好, 越低对质量越好).
  111.                     float MipLevel = ComputeMipLevel(i, step);
  113.                     // 单步的采样点.
  114.                     float3 StepSample = WedgeWithNormal(ScreenSpacePos, Scale * LocalRandom, InvFovFix, ViewSpacePosition, ScaledViewSpaceNormal, InvHaloSize, MipLevel);
  116.                     // 组合水平方向的样本.
  117.                     LocalAccumulator = lerp(LocalAccumulator, float3(max(LocalAccumulator.xy, StepSample.xy), 1), StepSample.z);
  118.                 }
  120.                 // Square(): 用角度的二次曲线缩放面积, 获得更暗一点的效果.
  121.                 WeightAccumulator += float2(Square(1 - LocalAccumulator.x) * LocalAccumulator.z, LocalAccumulator.z);
  122.                 WeightAccumulator += float2(Square(1 - LocalAccumulator.y) * LocalAccumulator.z, LocalAccumulator.z);
  123.             }
  124.             else // 没有法线
  125.             {
  126.                 (......)
  127.             }
  128.         }
  129.     }
  131. #endif // #if AO_SAMPLE_QUALITY == 0
  133.     OutColor.r = WeightAccumulator.x / WeightAccumulator.y;
  134.     OutColor.gb = float2(0, 0);
  136.     if(!bDebugLookups)
  137.     {
  138. #if COMPUTE_SHADER || FORWARD_SHADING
  139.         // In compute, Input1 and Input2 are not necessarily valid.
  140.         float4 Filtered = 1;
  141. #else
  142.         // 上采样.
  143.         float4 Filtered = ComputeUpsampleContribution(SceneDepth, UV, WorldNormal);
  144. #endif
  145.         // recombined result from multiple resolutions
  146.         OutColor.r = lerp(OutColor.r, Filtered.r, ComputeLerpFactor());
  147.     }
  149. #if !USE_AO_SETUP_AS_INPUT // FinalPass会执行此逻辑.
  150.     if(!bDebugLookups)
  151.     {
  152.         // 全分辨率
  154.         // 在距离上软过渡AO
  155.         {
  156.             float Mul = ScreenSpaceAOParams[4].x;
  157.             float Add = ScreenSpaceAOParams[4].y;
  158.             OutColor.r = lerp(OutColor.r, 1, saturate(SceneDepth * Mul + Add));
  159.         }
  161.         // 用户修改的AO
  162.         OutColor.r = 1 - (1 - pow(abs(OutColor.r), AmbientOcclusionPower)) * AmbientOcclusionIntensity;
  164.         // 只输出单通道
  165.         OutColor = OutColor.r;
  166.     }
  167.     else
  168.     {
  169.         OutColor.r = pow(1 - OutColor.r, 16);    // constnt is tweaked with radius and sample count
  170.     }
  171. #endif
  173.     // SM4不支持ddx_fine()
  174. #if !COMPUTE_SHADER && QUAD_MESSAGE_PASSING_BLUR > 0 && FEATURE_LEVEL >= FEATURE_LEVEL_SM5
  175.     {
  176.         // .x: AO output, .y:SceneDepth .zw:view space normal
  177.         float4 CenterPixel = float4(OutColor.r, SceneDepth, normalize(ViewSpaceNormal).xy); 
  179.         float4 dX = ddx_fine(CenterPixel);
  180.         float4 dY = ddy_fine(CenterPixel);
  182.         int2 Mod = (uint2)(SvPosition.xy) % 2;
  184.         float4 PixA = CenterPixel;
  185.         float4 PixB = CenterPixel - dX * (Mod.x * 2 - 1);
  186.         float4 PixC = CenterPixel - dY * (Mod.y * 2 - 1);
  188.         float WeightA = 1.0f;
  189.         float WeightB = 1.0f;
  190.         float WeightC = 1.0f;
  192.         // 用法线计算权重.
  193. #if QUAD_MESSAGE_PASSING_NORMAL
  194.         const float NormalTweak = 4.0f;
  195.         float3 NormalA = ReconstructNormal(PixA.zw);
  196.         float3 NormalB = ReconstructNormal(PixB.zw);
  197.         float3 NormalC = ReconstructNormal(PixC.zw);
  198.         WeightB *= saturate(pow(saturate(dot(NormalA, NormalB)), NormalTweak));
  199.         WeightC *= saturate(pow(saturate(dot(NormalA, NormalC)), NormalTweak));
  200. #endif
  202.         // 用深度计算权重.
  203. #if QUAD_MESSAGE_PASSING_DEPTH
  204.         const float DepthTweak = 1;
  205.         float InvDepth = 1.0f / PixA.y;
  206.         WeightB *= 1 - saturate(abs(1 - PixB.y * InvDepth) * DepthTweak);
  207.         WeightC *= 1 - saturate(abs(1 - PixC.y * InvDepth) * DepthTweak);
  208. #endif
  210.         // + 1.0f to avoid div by 0
  211.         float InvWeightABC = 1.0f / (WeightA + WeightB + WeightC);
  213.         // 缩放权重.
  214.         WeightA *= InvWeightABC;
  215.         WeightB *= InvWeightABC;
  216.         WeightC *= InvWeightABC;
  218.         // 用权重计算最终的输出颜色.
  219.         OutColor = WeightA * PixA.x + WeightB * PixB.x + WeightC * PixC.x;
  220.     }
  221. #endif
  222. }

上述提供了法线和深度作为权重的算法，它们的计算公式如下（摘自MSSAO）：

UE在PC端的SSAO使用了法线，所以其在计算采样点时考虑了法线，由WedgeWithNormal担当：

  1. float3 WedgeWithNormal(float2 ScreenSpacePosCenter, float2 InLocalRandom, float3 InvFovFix, float3 ViewSpacePosition, float3 ScaledViewSpaceNormal, float InvHaloSize, float MipLevel)
  2. {
  3.     float2 ScreenSpacePosL = ScreenSpacePosCenter + InLocalRandom;
  4.     float2 ScreenSpacePosR = ScreenSpacePosCenter - InLocalRandom;
  6.     float AbsL = GetHZBDepth(ScreenSpacePosL, MipLevel);
  7.     float AbsR = GetHZBDepth(ScreenSpacePosR, MipLevel);
  9.     float3 SamplePositionL = ReconstructCSPos(AbsL, ScreenSpacePosL);
  10.     float3 SamplePositionR = ReconstructCSPos(AbsR, ScreenSpacePosR);
  12.     float3 DeltaL = (SamplePositionL - ViewSpacePosition) * InvFovFix;
  13.     float3 DeltaR = (SamplePositionR - ViewSpacePosition) * InvFovFix;
  14.         
  15. #if OPTIMIZATION_O1
  16.     float InvNormAngleL = saturate(dot(DeltaL, ScaledViewSpaceNormal) / dot(DeltaL, DeltaL));
  17.     float InvNormAngleR = saturate(dot(DeltaR, ScaledViewSpaceNormal) / dot(DeltaR, DeltaR));
  18.     float Weight = 1;
  19. #else
  20.     float InvNormAngleL = saturate(dot(DeltaL, ScaledViewSpaceNormal) * rsqrt(dot(DeltaL, DeltaL)));
  21.     float InvNormAngleR = saturate(dot(DeltaR, ScaledViewSpaceNormal) * rsqrt(dot(DeltaR, DeltaR)));
  23.     float Weight = 
  24.           saturate(1.0f - length(DeltaL) * InvHaloSize)
  25.         * saturate(1.0f - length(DeltaR) * InvHaloSize);
  26. #endif
  28.     return float3(InvNormAngleL, InvNormAngleR, Weight);
  29. }

利用法线构造了一个楔形（下图），在此楔形内生成采样数据和权重。主要过程是在法线周围生成屏幕空间的左右偏移量，结合HZB深度值重建出左右两个采样位置，最后输出左右角度的倒数和权重。

从上面的代码分析可知，UE的SSAO在渲染流程、下采样、权重计算、AO混合等等和MSSAO版本高度相似：

经过上述的步骤渲染之后，会得到如下所示的全分辨率单通道ScreenSpaceAO纹理数据：

那么ScreenSpaceAO又是在哪里怎么被应用到光照中呢？下面继续追踪和分析之。

利用RenderDoc截帧分析可以发现有几个渲染阶段都会用到ScreenSpaceAO纹理：

上图显示组合非直接光和AO、渲染延迟标准光源、反射环境和天空光的渲染阶段都会引用到ScreenSpaceAO。

其中组合非直接光和AO涉及到SSAO的代码逻辑如下：

  1. // Engine\Shaders\Private\DiffuseIndirectComposite.usf
  3. Texture2D AmbientOcclusionTexture;
  4. SamplerState AmbientOcclusionSampler;
  6. void MainPS(float4 SvPosition : SV_POSITION, out float4 OutColor : SV_Target0)
  7. {
  8.     (......)
  10.     // 采样SSAO数据.
  11.     float DynamicAmbientOcclusion = 1.0f;
  12. #if DIM_APPLY_AMBIENT_OCCLUSION
  13.     DynamicAmbientOcclusion = AmbientOcclusionTexture.SampleLevel(AmbientOcclusionSampler, BufferUV, 0).r;
  14. #endif
  16.     // 计算最终AO: 材质AO * SSAO.
  17.     float FinalAmbientOcclusion = GBuffer.GBufferAO * DynamicAmbientOcclusion;
  19.     (......)
  21.     {
  22.         float AOMask = (GBuffer.ShadingModelID != SHADINGMODELID_UNLIT);
  23.         // 利用AOMask和AmbientOcclusionStaticFraction作为权重插值最终AO, 然后将AO值保存到Alpha通道, 而不是直接应用到rgb颜色中.
  24.         OutColor.a = lerp(1.0f, FinalAmbientOcclusion, AOMask * AmbientOcclusionStaticFraction);
  25.     }
  26. }

渲染延迟标准光源涉及的SSAO计算代码如下：

  1. // Engine\Shaders\Private\DeferredShadingCommon.ush
  3. FScreenSpaceData GetScreenSpaceData(float2 UV, bool bGetNormalizedNormal = true)
  4. {
  5.     FScreenSpaceData Out;
  7.     Out.GBuffer = GetGBufferData(UV, bGetNormalizedNormal);
  8.     // 采样SSAO
  9.     float4 ScreenSpaceAO = Texture2DSampleLevel(SceneTexturesStruct.ScreenSpaceAOTexture, SceneTexturesStruct_ScreenSpaceAOTextureSampler, UV, 0);
  11.     // 直接将SSAO作为最终AO.
  12.     Out.AmbientOcclusion = ScreenSpaceAO.r;
  14.     return Out;
  15. }
  17. FDeferredLightingSplit GetDynamicLightingSplit(..., float AmbientOcclusion, ...)
  18. {
  19.     (......)
  21.     FShadowTerms Shadow;
  22.     // 直接将SSAO作为阴影的初始值, 后面还会叠加阴影的系数.
  23.     Shadow.SurfaceShadow = AmbientOcclusion;
  24.         
  25.     (......)
  26.     
  27.     LightAccumulator_AddSplit( LightAccumulator, Lighting.Diffuse, Lighting.Specular, Lighting.Diffuse,
  28.                               // 注意, 此处利用Shadow.SurfaceShadow缩放了光源颜色.
  29.                               LightColor * LightMask * Shadow.SurfaceShadow,
  30.                               bNeedsSeparateSubsurfaceLightAccumulation );
  31.     (......)
  32. }

延迟灯光渲染阶段将叠加了AO和阴影的系数缩放了光源颜色，从而对漫反射和高光都起了影响。

反射环境和天空光也类似，此处就不再冗余分析了。本节的最后放出UE的SSAO开启和关闭的效果对比图（上无下有）：

此外，UE也支持GTAO的版本，本文就不解析了。

SSGI（Screen Space Global IIlumination）译为屏幕空间的全局光照，是基于屏幕空间的GBuffer数据进行光线追踪的GI技术。

默认情况下，UE是关闭SSGI的，需要在工程配置里显式开启：

开启SSGI后，可以增加角落、凹槽等表面的间接光照，减少它们的漏光，提升画面可信度。

上：关闭SSGI；下：开启SSGI，桌子和椅子下方的漏光明显减少。

UE的SSGI是在DiffuseIndirectAndAO内完成的，意味着它也是位于BasePass和Lighting之间。SSGI主要分为以下几个阶段：

  • SSGI渲染阶段：
    • 第一次下采样上一帧数据（4个Mip层级）。
    • 第二次下采样上一帧数据（1个Mip层级，最低级）。
    • 计算屏幕空间非直接漫反射。
  • 屏幕空间降噪：
    • 压缩元数据。
    • 重建数据。
    • 时间累积降噪。
  • 组合SSGI和SSAO等非直接光。

下面就按照上述步骤阐述SSGI的具体实现过程。首先看SSGI渲染阶段：

  1. // Engine\Source\Runtime\Renderer\Private\ScreenSpaceRayTracing.cpp
  3. void RenderScreenSpaceDiffuseIndirect(
  4.     FRDGBuilder& GraphBuilder, 
  5.     const FSceneTextureParameters& SceneTextures,
  6.     const FRDGTextureRef CurrentSceneColor,
  7.     const FViewInfo& View,
  8.     IScreenSpaceDenoiser::FAmbientOcclusionRayTracingConfig* OutRayTracingConfig,
  9.     IScreenSpaceDenoiser::FDiffuseIndirectInputs* OutDenoiserInputs)
  10. {
  11.     // 初始化质量, 标记, 尺寸等数据.
  12.     const int32 Quality = FMath::Clamp( CVarSSGIQuality.GetValueOnRenderThread(), 1, 4 );
  13.     bool bHalfResolution = IsSSGIHalfRes();
  15.     FIntPoint GroupSize;
  16.     int32 RayCountPerPixel;
  17.     GetSSRTGIShaderOptionsForQuality(Quality, &GroupSize, &RayCountPerPixel);
  19.     FIntRect Viewport = View.ViewRect;
  20.     if (bHalfResolution)
  21.     {
  22.         Viewport = FIntRect::DivideAndRoundUp(Viewport, 2);
  23.     }
  25.     RDG_EVENT_SCOPE(GraphBuilder, "SSGI %dx%d", Viewport.Width(), Viewport.Height());
  27.     const FVector2D ViewportUVToHZBBufferUV(
  28.         float(View.ViewRect.Width()) / float(2 * View.HZBMipmap0Size.X),
  29.         float(View.ViewRect.Height()) / float(2 * View.HZBMipmap0Size.Y)
  30.     );
  32.     FRDGTexture* FurthestHZBTexture = GraphBuilder.RegisterExternalTexture(View.HZB);
  33.     FRDGTexture* ClosestHZBTexture = GraphBuilder.RegisterExternalTexture(View.ClosestHZB);
  35.     // 重投影和下采样上一帧的颜色.
  36.     FRDGTexture* ReducedSceneColor;
  37.     FRDGTexture* ReducedSceneAlpha = nullptr;
  38.     {
  39.         // 忽略最前面mip的数量.
  40.         const int32 DownSamplingMip = 1;
  41.         // mip数量.
  42.         const int32 kNumMips = 5;
  44.         bool bUseLeakFree = View.PrevViewInfo.ScreenSpaceRayTracingInput != nullptr;
  46.         // 分配ReducedSceneColor.
  47.         {
  48.             FIntPoint RequiredSize = SceneTextures.SceneDepthTexture->Desc.Extent / (1 << DownSamplingMip);
  50.             int32 QuantizeMultiple = 1 << (kNumMips - 1);
  51.             FIntPoint QuantizedSize = FIntPoint::DivideAndRoundUp(RequiredSize, QuantizeMultiple);
  53.             FRDGTextureDesc Desc = FRDGTextureDesc::Create2D(
  54.                 FIntPoint(QuantizeMultiple * QuantizedSize.X, QuantizeMultiple * QuantizedSize.Y),
  55.                 PF_FloatR11G11B10,
  56.                 FClearValueBinding::None,
  57.                 TexCreate_ShaderResource | TexCreate_UAV);
  58.             Desc.NumMips = kNumMips;
  60.             ReducedSceneColor = GraphBuilder.CreateTexture(Desc, TEXT("SSRTReducedSceneColor"));
  62.             if (bUseLeakFree)
  63.             {
  64.                 Desc.Format = PF_A8;
  65.                 ReducedSceneAlpha = GraphBuilder.CreateTexture(Desc, TEXT("SSRTReducedSceneAlpha"));
  66.             }
  67.         }
  69.         // 处理第易次下采样Pass.(有4个mip纹理)
  70.         
  71.         // FSSRTPrevFrameReductionCS参数处理.
  72.         FSSRTPrevFrameReductionCS::FParameters DefaultPassParameters;
  73.         {
  74.             DefaultPassParameters.SceneTextures = SceneTextures;
  75.             DefaultPassParameters.View = View.ViewUniformBuffer;
  77.             DefaultPassParameters.ReducedSceneColorSize = FVector2D(
  78.                 ReducedSceneColor->Desc.Extent.X, ReducedSceneColor->Desc.Extent.Y);
  79.             DefaultPassParameters.ReducedSceneColorTexelSize = FVector2D(
  80.                 1.0f / float(ReducedSceneColor->Desc.Extent.X), 1.0f / float(ReducedSceneColor->Desc.Extent.Y));
  81.         }
  83.         {
  84.             FSSRTPrevFrameReductionCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FSSRTPrevFrameReductionCS::FParameters>();
  85.             *PassParameters = DefaultPassParameters;
  87.             FIntPoint ViewportOffset;
  88.             FIntPoint ViewportExtent;
  89.             FIntPoint BufferSize;
  91.             // 是否不漏光的处理.
  92.             if (bUseLeakFree)
  93.             {
  94.                 BufferSize = View.PrevViewInfo.ScreenSpaceRayTracingInput->GetDesc().Extent;
  95.                 ViewportOffset = View.ViewRect.Min; // TODO
  96.                 ViewportExtent = View.ViewRect.Size();
  98.                 PassParameters->PrevSceneColor = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.ScreenSpaceRayTracingInput);
  99.                 PassParameters->PrevSceneColorSampler = TStaticSamplerState<SF_Point>::GetRHI();
  101.                 PassParameters->PrevSceneDepth = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.DepthBuffer);
  102.                 PassParameters->PrevSceneDepthSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
  103.             }
  104.             else
  105.             {
  106.                 BufferSize = View.PrevViewInfo.TemporalAAHistory.ReferenceBufferSize;
  107.                 ViewportOffset = View.PrevViewInfo.TemporalAAHistory.ViewportRect.Min;
  108.                 ViewportExtent = View.PrevViewInfo.TemporalAAHistory.ViewportRect.Size();
  110.                 PassParameters->PrevSceneColor = GraphBuilder.RegisterExternalTexture(View.PrevViewInfo.TemporalAAHistory.RT[0]);
  111.                 PassParameters->PrevSceneColorSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
  112.             }
  114.             PassParameters->PrevSceneColorPreExposureCorrection = View.PreExposure / View.PrevViewInfo.SceneColorPreExposure;
  116.             PassParameters->PrevScreenPositionScaleBias = FVector4(
  117.                 ViewportExtent.X * 0.5f / BufferSize.X,
  118.                 -ViewportExtent.Y * 0.5f / BufferSize.Y,
  119.                 (ViewportExtent.X * 0.5f + ViewportOffset.X) / BufferSize.X,
  120.                 (ViewportExtent.Y * 0.5f + ViewportOffset.Y) / BufferSize.Y);
  122.             // 给每个mip创建输出的UAV.
  123.             for (int32 MipLevel = 0; MipLevel < (PassParameters->ReducedSceneColorOutput.Num() - DownSamplingMip); MipLevel++)
  124.             {
  125.                 PassParameters->ReducedSceneColorOutput[DownSamplingMip + MipLevel] = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(ReducedSceneColor, MipLevel));
  126.                 if (ReducedSceneAlpha)
  127.                     PassParameters->ReducedSceneAlphaOutput[DownSamplingMip + MipLevel] = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(ReducedSceneAlpha, MipLevel));
  128.             }
  130.             FSSRTPrevFrameReductionCS::FPermutationDomain PermutationVector;
  131.             PermutationVector.Set<FSSRTPrevFrameReductionCS::FLowerMips>(false); 
  132.             PermutationVector.Set<FSSRTPrevFrameReductionCS::FLeakFree>(bUseLeakFree);
  134.             // 增加CS Pass以下采样颜色和alpha.
  135.             TShaderMapRef<FSSRTPrevFrameReductionCS> ComputeShader(View.ShaderMap, PermutationVector);
  136.             FComputeShaderUtils::AddPass(
  137.                 GraphBuilder,
  138.                 RDG_EVENT_NAME("PrevFrameReduction(LeakFree=%i) %dx%d",
  139.                     bUseLeakFree ? 1 : 0,
  140.                     View.ViewRect.Width(), View.ViewRect.Height()),
  141.                 ComputeShader,
  142.                 PassParameters,
  143.                 FComputeShaderUtils::GetGroupCount(View.ViewRect.Size(), 8));
  144.         }
  145.         
  146.         // 处理第二次下采样Pass.(只有1个mip纹理)
  148.         for (int32 i = 0; i < 1; i++)
  149.         {
  150.             int32 SrcMip = i * 3 + 2 - DownSamplingMip;
  151.             int32 StartDestMip = SrcMip + 1;
  152.             int32 Divisor = 1 << (StartDestMip + DownSamplingMip);
  154.             FSSRTPrevFrameReductionCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FSSRTPrevFrameReductionCS::FParameters>();
  155.             *PassParameters = DefaultPassParameters;
  157.             PassParameters->HigherMipTexture = GraphBuilder.CreateSRV(FRDGTextureSRVDesc::CreateForMipLevel(ReducedSceneColor, SrcMip));
  158.             if (bUseLeakFree)
  159.             {
  160.                 check(ReducedSceneAlpha);
  161.                 PassParameters->HigherMipTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  162.                 PassParameters->HigherAlphaMipTexture = GraphBuilder.CreateSRV(FRDGTextureSRVDesc::CreateForMipLevel(ReducedSceneAlpha, SrcMip));
  163.                 PassParameters->HigherAlphaMipTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  164.             }
  165.             else
  166.             {
  167.                 PassParameters->HigherMipTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
  168.             }
  170.             PassParameters->HigherMipDownScaleFactor = 1 << (DownSamplingMip + SrcMip);
  172.             PassParameters->HigherMipBufferBilinearMax = FVector2D(
  173.                 (0.5f * View.ViewRect.Width() - 0.5f) / float(ReducedSceneColor->Desc.Extent.X),
  174.                 (0.5f * View.ViewRect.Height() - 0.5f) / float(ReducedSceneColor->Desc.Extent.Y));
  176.             PassParameters->ViewportUVToHZBBufferUV = ViewportUVToHZBBufferUV;
  177.             PassParameters->FurthestHZBTexture = FurthestHZBTexture;
  178.             PassParameters->FurthestHZBTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  180.             for (int32 MipLevel = 0; MipLevel < PassParameters->ReducedSceneColorOutput.Num(); MipLevel++)
  181.             {
  182.                 PassParameters->ReducedSceneColorOutput[MipLevel] = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(ReducedSceneColor, StartDestMip + MipLevel));
  183.                 if (ReducedSceneAlpha)
  184.                     PassParameters->ReducedSceneAlphaOutput[MipLevel] = GraphBuilder.CreateUAV(FRDGTextureUAVDesc(ReducedSceneAlpha, StartDestMip + MipLevel));
  185.             }
  187.             FSSRTPrevFrameReductionCS::FPermutationDomain PermutationVector;
  188.             PermutationVector.Set<FSSRTPrevFrameReductionCS::FLowerMips>(true);
  189.             PermutationVector.Set<FSSRTPrevFrameReductionCS::FLeakFree>(bUseLeakFree);
  191.             // 第二次下采样Pass
  192.             TShaderMapRef<FSSRTPrevFrameReductionCS> ComputeShader(View.ShaderMap, PermutationVector);
  193.             FComputeShaderUtils::AddPass(
  194.                 GraphBuilder,
  195.                 RDG_EVENT_NAME("PrevFrameReduction(LeakFree=%i) %dx%d",
  196.                     bUseLeakFree ? 1 : 0,
  197.                     View.ViewRect.Width() / Divisor, View.ViewRect.Height() / Divisor),
  198.                 ComputeShader,
  199.                 PassParameters,
  200.                 FComputeShaderUtils::GetGroupCount(View.ViewRect.Size(), 8 * Divisor));
  201.         }
  202.     }
  204.     {
  205.         // 分配输出.
  206.         {
  207.             FRDGTextureDesc Desc = FRDGTextureDesc::Create2D(
  208.                 SceneTextures.SceneDepthTexture->Desc.Extent / (bHalfResolution ? 2 : 1),
  209.                 PF_FloatRGBA,
  210.                 FClearValueBinding::Transparent,
  211.                 TexCreate_ShaderResource | TexCreate_UAV);
  213.             OutDenoiserInputs->Color = GraphBuilder.CreateTexture(Desc, TEXT("SSRTDiffuseIndirect"));
  215.             Desc.Format = PF_R16F;
  216.             Desc.Flags |= TexCreate_RenderTargetable;
  217.             OutDenoiserInputs->AmbientOcclusionMask = GraphBuilder.CreateTexture(Desc, TEXT("SSRTAmbientOcclusion"));
  218.         }
  219.     
  220.         // 处理FScreenSpaceDiffuseIndirectCS参数.
  221.         
  222.         FScreenSpaceDiffuseIndirectCS::FParameters* PassParameters = GraphBuilder.AllocParameters<FScreenSpaceDiffuseIndirectCS::FParameters>();
  224.         if (bHalfResolution)
  225.         {
  226.             PassParameters->PixelPositionToFullResPixel = 2.0f;
  227.             PassParameters->FullResPixelOffset = FVector2D(0.5f, 0.5f); // TODO.
  228.         }
  229.         else
  230.         {
  231.             PassParameters->PixelPositionToFullResPixel = 1.0f;
  232.             PassParameters->FullResPixelOffset = FVector2D(0.5f, 0.5f);
  233.         }
  235.         {
  236.             PassParameters->ColorBufferScaleBias = FVector4(
  237.                 0.5f * SceneTextures.SceneDepthTexture->Desc.Extent.X / float(ReducedSceneColor->Desc.Extent.X),
  238.                 0.5f * SceneTextures.SceneDepthTexture->Desc.Extent.Y / float(ReducedSceneColor->Desc.Extent.Y),
  239.                 -0.5f * View.ViewRect.Min.X / float(ReducedSceneColor->Desc.Extent.X),
  240.                 -0.5f * View.ViewRect.Min.Y / float(ReducedSceneColor->Desc.Extent.Y));
  242.             PassParameters->ReducedColorUVMax = FVector2D(
  243.                 (0.5f * View.ViewRect.Width() - 0.5f) / float(ReducedSceneColor->Desc.Extent.X),
  244.                 (0.5f * View.ViewRect.Height() - 0.5f) / float(ReducedSceneColor->Desc.Extent.Y));
  245.         }
  247.         PassParameters->FurthestHZBTexture = FurthestHZBTexture;
  248.         PassParameters->FurthestHZBTextureSampler = TStaticSamplerState<SF_Point>::GetRHI();
  249.         PassParameters->ColorTexture = ReducedSceneColor;
  250.         PassParameters->ColorTextureSampler = TStaticSamplerState<SF_Bilinear>::GetRHI();
  252.         PassParameters->HZBUvFactorAndInvFactor = FVector4(
  253.             ViewportUVToHZBBufferUV.X,
  254.             ViewportUVToHZBBufferUV.Y,
  255.             1.0f / ViewportUVToHZBBufferUV.X,
  256.             1.0f / ViewportUVToHZBBufferUV.Y );
  258.         PassParameters->SceneTextures = SceneTextures;
  259.         PassParameters->View = View.ViewUniformBuffer;
  260.     
  261.         PassParameters->IndirectDiffuseOutput = GraphBuilder.CreateUAV(OutDenoiserInputs->Color);
  262.         PassParameters->AmbientOcclusionOutput = GraphBuilder.CreateUAV(OutDenoiserInputs->AmbientOcclusionMask);
  263.         PassParameters->DebugOutput = CreateScreenSpaceRayTracingDebugUAV(GraphBuilder, OutDenoiserInputs->Color->Desc, TEXT("DebugSSGI"));
  264.         PassParameters->ScreenSpaceRayTracingDebugOutput = CreateScreenSpaceRayTracingDebugUAV(GraphBuilder, OutDenoiserInputs->Color->Desc, TEXT("DebugSSGIMarshing"), true);
  266.         FScreenSpaceDiffuseIndirectCS::FPermutationDomain PermutationVector;
  267.         PermutationVector.Set<FScreenSpaceDiffuseIndirectCS::FQualityDim>(Quality);
  269.         // 增加SSGI计算Pass.
  270.         TShaderMapRef<FScreenSpaceDiffuseIndirectCS> ComputeShader(View.ShaderMap, PermutationVector);
  271.         FComputeShaderUtils::AddPass(
  272.             GraphBuilder,
  273.             RDG_EVENT_NAME("ScreenSpaceDiffuseIndirect(Quality=%d RayPerPixel=%d) %dx%d",
  274.                 Quality, RayCountPerPixel, Viewport.Width(), Viewport.Height()),
  275.             ComputeShader,
  276.             PassParameters,
  277.             FComputeShaderUtils::GetGroupCount(Viewport.Size(), GroupSize));
  278.     }
  280.     OutRayTracingConfig->ResolutionFraction = bHalfResolution ? 0.5f : 1.0f;
  281.     OutRayTracingConfig->RayCountPerPixel = RayCountPerPixel;
  282. } // RenderScreenSpaceDiffuseIndirect()

下面分析下采样Pass使用的CS Shader：

  1. // Engine\Shaders\Private\SSRT\SSRTPrevFrameReduction.usf
  3. [numthreads(GROUP_TILE_SIZE, GROUP_TILE_SIZE, 1)]
  4. void MainCS(
  5.     uint2 DispatchThreadId : SV_DispatchThreadID,
  6.     uint2 GroupId : SV_GroupID,
  7.     uint2 GroupThreadId : SV_GroupThreadID,
  8.     uint GroupThreadIndex : SV_GroupIndex)
  9. {
  10.     #if DIM_LOWER_MIPS
  11.         float2 SceneBufferUV = HigherMipDownScaleFactor * (2.0 * float2(DispatchThreadId) + 1.0) * View.BufferSizeAndInvSize.zw;
  12.     #else
  13.         float2 SceneBufferUV = (float2(DispatchThreadId) + 0.5) * View.BufferSizeAndInvSize.zw;
  14.     #endif
  16.     SceneBufferUV = clamp(SceneBufferUV, View.BufferBilinearUVMinMax.xy, View.BufferBilinearUVMinMax.zw);
  17.     float2 ViewportUV = BufferUVToViewportUV(SceneBufferUV);
  18.     float2 ScreenPosition = ViewportUVToScreenPos(ViewportUV);
  19.     
  20.     float4 PrevColor;
  21.     float WorldDepth;
  23.     #if DIM_LOWER_MIPS // 第二次下采样Pass进入此分支.
  24.         #if DIM_LEAK_FREE
  25.         {
  26.             {
  27.                 float HZBDeviceZ = FurthestHZBTexture.SampleLevel(FurthestHZBTextureSampler, ViewportUV * ViewportUVToHZBBufferUV, 2.0).r;
  28.                 WorldDepth = ConvertFromDeviceZ(HZBDeviceZ);
  29.             }
  31.             float WorldDepthToPixelWorldRadius = GetTanHalfFieldOfView().x * View.ViewSizeAndInvSize.z * 100;
  33.             float WorldBluringRadius = WorldDepthToPixelWorldRadius * WorldDepth;
  34.             float InvSquareWorldBluringRadius = rcp(WorldBluringRadius * WorldBluringRadius);
  36.             PrevColor = 0.0;
  38.             // 根据深度缓存还原当前像素及相邻4个像素的世界坐标，使用世界坐标之间的距离平方衰减作为权重缩小Color的值.
  39.             UNROLL_N(4)
  40.             for (uint i = 0; i < 4; i++)
  41.             {
  42.                 const float2 TexelOffset = float2(i % 2, i / 2) - 0.5;
  44.                 // 采样UV
  45.                 float2 HZBBufferUV = (ViewportUV + TexelOffset * HigherMipDownScaleFactor * View.ViewSizeAndInvSize.zw) * ViewportUVToHZBBufferUV;
  46.                 // 采样的深度
  47.                 float SampleDeviceZ = FurthestHZBTexture.SampleLevel(FurthestHZBTextureSampler, HZBBufferUV, 1.0).r;
  48.                 // 当前像素和采样深度的距离.
  49.                 float SampleDist = WorldDepth - ConvertFromDeviceZ(SampleDeviceZ);
  51.                 // 采样权重.
  52.                 float SampleWeight = 0.25 * saturate(1 - SampleDist * SampleDist * InvSquareWorldBluringRadius);
  54.                 float2 SampleUV = HigherMipDownScaleFactor * (2.0 * float2(DispatchThreadId) + 1.0 + TexelOffset) * 0.5 * ReducedSceneColorTexelSize;
  55.                 SampleUV = min(SampleUV, HigherMipBufferBilinearMax);
  57.                 float4 SampleColor = float4(
  58.                     HigherMipTexture.SampleLevel(HigherMipTextureSampler, SampleUV, 0).rgb,
  59.                     Texture2DSample_A8(HigherAlphaMipTexture,HigherAlphaMipTextureSampler, SampleUV));
  61.                 // 累加应用权重后的颜色.
  62.                 PrevColor += SampleColor * SampleWeight;
  63.             }
  64.         }
  65.         #else
  66.         {
  67.             float2 HigherMipUV = HigherMipDownScaleFactor * (float2(DispatchThreadId) * 1.0 + 0.5) * ReducedSceneColorTexelSize;
  68.             PrevColor = float4(HigherMipTexture.SampleLevel(HigherMipTextureSampler, HigherMipUV, 0).rgb, 1);
  69.         }
  70.         #endif
  71.     #else // 第一次下采样Pass进入此分支.
  72.     {
  73.         float DeviceZ = SampleDeviceZFromSceneTextures(SceneBufferUV);
  74.         WorldDepth = ConvertFromDeviceZ(DeviceZ);
  76.         // 当前像素的在屏幕空间的镜头运动向量.
  77.         float4 ThisClip = float4(ScreenPosition, DeviceZ, 1);
  78.         float4 PrevClip = mul(ThisClip, View.ClipToPrevClip);
  79.         float2 PrevScreen = PrevClip.xy / PrevClip.w;
  81.         bool bIsSky = WorldDepth > 100 * 1000;
  83.         // 获取速度.
  84.         float4 EncodedVelocity = GBufferVelocityTexture.SampleLevel(GBufferVelocityTextureSampler, SceneBufferUV, 0);
  85.         if (EncodedVelocity.x > 0.0)
  86.         {
  87.             PrevScreen = ThisClip.xy - DecodeVelocityFromTexture(EncodedVelocity).xy;
  88.         }
  90.         float2 PrevFrameUV = PrevScreen.xy * PrevScreenPositionScaleBias.xy + PrevScreenPositionScaleBias.zw;
  92.         // 获取颜色(与上面类似)
  93.         #if DIM_LEAK_FREE
  94.         {
  95.             float3 RefWorldPosition = ComputeTranslatedWorldPosition(ScreenPosition, WorldDepth, /* bIsPrevFrame = */ false);
  97.             float NoV = dot(View.TranslatedWorldCameraOrigin - normalize(RefWorldPosition), GetGBufferDataFromSceneTextures(SceneBufferUV).WorldNormal);
  98.                 
  99.             float WorldDepthToPixelWorldRadius = GetTanHalfFieldOfView().x * View.ViewSizeAndInvSize.z * 100;
  101.             float WorldBluringRadius = WorldDepthToPixelWorldRadius * WorldDepth;
  102.             float InvSquareWorldBluringRadius = rcp(WorldBluringRadius * WorldBluringRadius);
  104.             {
  105.                 float2 SampleUV = PrevFrameUV;
  106.                 
  107.                 SampleUV = clamp(SampleUV, View.BufferBilinearUVMinMax.xy, View.BufferBilinearUVMinMax.zw);
  109.                 float PrevDeviceZ = PrevSceneDepth.SampleLevel(PrevSceneDepthSampler, SampleUV, 0).r;
  111.                 float3 SampleWorldPosition = ComputeTranslatedWorldPosition(PrevScreen.xy, ConvertFromDeviceZ(PrevDeviceZ), /* bIsPrevFrame = */ true);
  113.                 float SampleDistSquare = length2(RefWorldPosition - SampleWorldPosition);
  115.                 float SampleWeight = saturate(1 - SampleDistSquare * InvSquareWorldBluringRadius);
  117.                 PrevColor = float4(PrevSceneColor.SampleLevel(PrevSceneColorSampler, SampleUV, 0).rgb * SampleWeight, SampleWeight);
  118.             }
  119.         }
  120.         #else
  121.         {
  122.             PrevColor = float4(PrevSceneColor.SampleLevel(PrevSceneColorSampler, PrevFrameUV, 0).rgb, 1.0);
  123.         }
  124.         #endif
  126.         PrevColor = -min(-PrevColor, 0.0);
  128.         #if CONFIG_COLOR_TILE_CLASSIFICATION
  129.         {
  130.             if (bIsSky)
  131.                 PrevColor = 0;
  132.         }
  133.         #endif
  135.         // 校正预曝光.
  136.         #if USE_PREEXPOSURE
  137.             PrevColor.rgb *= PrevSceneColorPreExposureCorrection;
  138.         #endif
  140.         // 应用暗角.
  141.         {
  142.             float Vignette = min(ComputeHitVignetteFromScreenPos(ScreenPosition), ComputeHitVignetteFromScreenPos(PrevScreen));
  143.             PrevColor *= Vignette;
  144.         }
  146.         (......)
  147.     }
  148.     #endif
  150.     // 输出mip 0
  151.     #if DIM_LOWER_MIPS
  152.     {
  153.         ReducedSceneColorOutput_0[DispatchThreadId] = float4(PrevColor.rgb, 0);
  155.         #if DIM_LEAK_FREE
  156.             ReducedSceneAlphaOutput_0[DispatchThreadId] = PrevColor.a;
  157.         #endif
  158.     }
  159.     #endif
  161.     // 下采样低mip级别.
  162.     {
  163.         // 存储颜色到LDS.
  164.         {
  165.             SharedMemory[GROUP_PIXEL_COUNT * 0 | GroupThreadIndex] = (f32tof16(PrevColor.r) << 0) | (f32tof16(PrevColor.g) << 16);
  166.             SharedMemory[GROUP_PIXEL_COUNT * 1 | GroupThreadIndex] = (f32tof16(PrevColor.b) << 0) | (f32tof16(PrevColor.a) << 16);
  168.             #if DIM_LEAK_FREE
  169.                 SharedFurthestDepth[GroupThreadIndex] = WorldDepth;
  170.             #endif
  171.         }
  172.     
  173.         GroupMemoryBarrierWithGroupSync();
  175.         // 下采样低mip级别.
  176.         UNROLL
  177.         for (uint MipLevel = 1; MipLevel < 3; MipLevel++)
  178.         {
  179.             const uint ReductionAmount = 1 << MipLevel;
  180.             const uint NumberPixelInMip = GROUP_PIXEL_COUNT / (ReductionAmount * ReductionAmount);
  181.             
  182.             if (GroupThreadIndex < NumberPixelInMip)
  183.             {
  184.                 uint2 OutputCoord = uint2(
  185.                     GroupThreadIndex % (GROUP_TILE_SIZE / ReductionAmount),
  186.                     GroupThreadIndex / (GROUP_TILE_SIZE / ReductionAmount));
  188.                 // 利用FurthestHZB执行Ray marchsing以避免自相交, 所以这里要保持保守策略。
  189.                 #if DIM_LEAK_FREE
  190.                 // 下采样深度, 计算自身和周边4个像素的最大深度(最靠近相机的深度).
  191.                 float FurthestDepth;
  192.                 {
  193.                     UNROLL_N(2)
  194.                     for (uint x = 0; x < 2; x++)
  195.                     {
  196.                         UNROLL_N(2)
  197.                         for (uint y = 0; y < 2; y++)
  198.                         {
  199.                             uint2 Coord = OutputCoord * 2 + uint2(x, y);
  200.                             uint LDSIndex = Coord.x + Coord.y * ((2 * GROUP_TILE_SIZE) / ReductionAmount);
  202.                             float NeighborDepth = SharedFurthestDepth[LDSIndex];
  204.                             if (x == 0 && y == 0)
  205.                                 FurthestDepth = NeighborDepth;
  206.                             else
  207.                                 FurthestDepth = max(FurthestDepth, NeighborDepth);
  208.                         }
  209.                     }
  210.                 }
  212.                 float WorldDepthToPixelWorldRadius = GetTanHalfFieldOfView().x * View.ViewSizeAndInvSize.z * 100;
  214.                 float WorldBluringRadius = WorldDepthToPixelWorldRadius * FurthestDepth;
  215.                 float InvSquareWorldBluringRadius = rcp(WorldBluringRadius * WorldBluringRadius);
  217.                 #endif
  219.                 // 下采样颜色, 也会考量采样深度到当前像素深度的距离作为权重以缩放颜色值.
  220.                 float4 ReducedColor = 0;
  222.                 UNROLL
  223.                 for (uint x = 0; x < 2; x++)
  224.                 {
  225.                     UNROLL
  226.                     for (uint y = 0; y < 2; y++)
  227.                     {
  228.                         uint2 Coord = OutputCoord * 2 + uint2(x, y);
  229.                         uint LDSIndex = Coord.x + Coord.y * ((2 * GROUP_TILE_SIZE) / ReductionAmount);
  231.                         uint Raw0 = SharedMemory[GROUP_PIXEL_COUNT * 0 | LDSIndex];
  232.                         uint Raw1 = SharedMemory[GROUP_PIXEL_COUNT * 1 | LDSIndex];
  234.                         float4 Color;
  235.                         Color.r = f16tof32(Raw0 >> 0);
  236.                         Color.g = f16tof32(Raw0 >> 16);
  237.                         Color.b = f16tof32(Raw1 >> 0);
  238.                         Color.a = f16tof32(Raw1 >> 16);
  240.                         float SampleWeight = 1.0;
  241.                         #if DIM_LEAK_FREE
  242.                         {
  243.                             float NeighborDepth = SharedFurthestDepth[LDSIndex];
  244.                             float SampleDist = (FurthestDepth - NeighborDepth);
  246.                             SampleWeight = saturate(1 - (SampleDist * SampleDist) * InvSquareWorldBluringRadius);
  247.                         }
  248.                         #endif
  250.                         ReducedColor += Color * SampleWeight;
  251.                     }
  252.                 }
  254.                 // 处理并输出结果.
  255.                 
  256.                 ReducedColor *= rcp(4.0);
  258.                 uint2 OutputPosition = GroupId * (GROUP_TILE_SIZE / ReductionAmount) + OutputCoord;
  260.                 if (MipLevel == 1)
  261.                 {
  262.                     ReducedSceneColorOutput_1[OutputPosition] = float4(ReducedColor.rgb, 0);
  263.                     #if DIM_LEAK_FREE
  264.                         ReducedSceneAlphaOutput_1[OutputPosition] = ReducedColor.a;
  265.                     #endif
  266.                 }
  267.                 else if (MipLevel == 2)
  268.                 {
  269.                     ReducedSceneColorOutput_2[OutputPosition] = float4(ReducedColor.rgb, 0);
  270.                     #if DIM_LEAK_FREE
  271.                         ReducedSceneAlphaOutput_2[OutputPosition] = ReducedColor.a;
  272.                     #endif
  273.                 }
  274.                 
  275.                 SharedMemory[GROUP_PIXEL_COUNT * 0 | GroupThreadIndex] = (f32tof16(ReducedColor.r) << 0) | (f32tof16(ReducedColor.g) << 16);
  276.                 SharedMemory[GROUP_PIXEL_COUNT * 1 | GroupThreadIndex] = (f32tof16(ReducedColor.b) << 0) | (f32tof16(ReducedColor.a) << 16);
  278.                 #if DIM_LEAK_FREE
  279.                 {
  280.                     SharedFurthestDepth[GroupThreadIndex] = FurthestDepth;
  281.                 }
  282.                 #endif
  283.             } // if (GroupThreadIndex < NumberPixelInMip)
  284.         } // for (uint MipLevel = 1; MipLevel < 3; MipLevel++)
  285.     }
  286. } // MainCS()

经过上述处理之后，输出了下采样的拥有5个Mip级别的颜色和深度纹理：

接下来继续分析SSGI的渲染部分，此Pass的输入有场景深度、HZB、GBuffer和上一阶段生成的下采样纹理，下面直接分析其使用的CS Shader：

  1. // Engine\Shaders\Private\SSRT\SSRTDiffuseIndirect.usf
  3. [numthreads(TILE_PIXEL_SIZE_X, TILE_PIXEL_SIZE_Y, CONFIG_RAY_COUNT)]
  4. void MainCS(
  5.     uint2 GroupId : SV_GroupID,
  6.     uint GroupThreadIndex : SV_GroupIndex)
  7. {
  8.     // 线程组的波形(wave)ID.
  9.     uint GroupWaveIndex = GroupThreadIndex / 64;
  10.     
  11.     FSSRTTileInfos TileInfos;
  12.     {
  13.         const uint BinsAddress = TILE_PIXEL_COUNT * 2;
  15.         uint GroupPixelId = GroupThreadIndex % TILE_PIXEL_COUNT;
  16.         uint RaySequenceId = GroupThreadIndex / TILE_PIXEL_COUNT;
  18.         // 计算TileCoord, 保证编译器将它用标量来加载.
  19.         uint2 TileCoord = GroupId / uint2(TILE_RES_DIVISOR / TILE_PIXEL_SIZE_X, TILE_RES_DIVISOR / TILE_PIXEL_SIZE_Y);
  20.         TileInfos = LoadTileInfos(TileCoord);
  22.         // 存储GBuffer到LDS
  23.         {
  24.             BRANCH
  25.             if (RaySequenceId == 0)
  26.             {
  27.                 uint2 GroupPixelOffset = DecodeGroupPixelOffset(GroupPixelId);
  28.                 uint2 PixelPosition = ComputePixelPosition(GroupId, GroupPixelOffset);
  29.                 
  30.                 float2 BufferUV;
  31.                 float2 ScreenPos;
  32.                 UpdateLane2DCoordinateInformations(PixelPosition, /* out */ BufferUV, /* out */ ScreenPos);
  33.     
  34.                 FGBufferData GBuffer = GetGBufferDataFromSceneTextures(BufferUV);
  35.                 float3 N = mul(float4(GBuffer.WorldNormal, 0), View.TranslatedWorldToView).xyz;
  36.                 float DeviceZ = SampleDeviceZFromSceneTextures(BufferUV);
  38.                 bool bTraceRay = GBuffer.ShadingModelID != SHADINGMODELID_UNLIT;
  39.                 
  40.                 SharedMemory[TILE_PIXEL_COUNT * 0 | GroupPixelId] = CompressN(N);
  41.                 SharedMemory[TILE_PIXEL_COUNT * 1 | GroupPixelId] = asuint(bTraceRay ? DeviceZ : -1.0);
  42.             }
  43.             else if (GroupWaveIndex == 1) // TODO.
  44.             {
  45.                 // Clears the bins
  46.                 SharedMemory[BinsAddress | GroupPixelId] = 0;
  47.             }
  48.         }
  49.         
  50.         (......)
  51.     }
  52.     
  53.     GroupMemoryBarrierWithGroupSync();
  54.     
  55.     // 发射射线
  56.     {
  57.         uint GroupPixelId;
  58.         uint RaySequenceId;
  59.         uint CompressedN;
  60.         float DeviceZ;
  61.         bool bTraceRay;
  62.         #if CONFIG_SORT_RAYS
  63.         {
  64.             uint Raw0 = SharedMemory[LANE_PER_GROUPS * 0 | GroupThreadIndex];
  65.             uint Raw1 = SharedMemory[LANE_PER_GROUPS * 1 | GroupThreadIndex];
  67.             // 解压射线数据.
  68.             RaySequenceId = Raw0 >> (24 + TILE_PIXEL_SIZE_X_LOG + TILE_PIXEL_SIZE_Y_LOG);
  69.             GroupPixelId = (Raw0 >> 24) % TILE_PIXEL_COUNT;
  70.             CompressedN = Raw0;
  71.             DeviceZ = asfloat(Raw1);
  72.             bTraceRay = asfloat(Raw1) > 0;
  73.         }
  74.         #else // !CONFIG_SORT_RAYS
  75.         {
  76.             GroupPixelId = GroupThreadIndex % TILE_PIXEL_COUNT;
  77.             RaySequenceId = GroupThreadIndex / TILE_PIXEL_COUNT;
  79.             uint Raw0 = SharedMemory[TILE_PIXEL_COUNT * 0 | GroupPixelId];
  80.             uint Raw1 = SharedMemory[TILE_PIXEL_COUNT * 1 | GroupPixelId];
  82.             CompressedN = Raw0;
  83.             DeviceZ = asfloat(Raw1);
  84.             bTraceRay = asfloat(Raw1) > 0;
  85.         }
  86.         #endif // !CONFIG_SORT_RAYS
  88.         GroupMemoryBarrierWithGroupSync();
  90.         #if DEBUG_RAY_COUNT
  91.             float DebugRayCount = 0.0;
  92.         #endif
  93.         uint2 CompressedColor;
  95.         BRANCH
  96.         if (bTraceRay) // 确保需要时才发射射线
  97.         {
  98.             // 计算坐标, uv, 屏幕位置.
  99.             uint2 GroupPixelOffset = DecodeGroupPixelOffset(GroupPixelId);
  100.             uint2 PixelPosition = ComputePixelPosition(GroupId, GroupPixelOffset);
  101.     
  102.             float2 BufferUV;
  103.             float2 ScreenPos;
  104.             UpdateLane2DCoordinateInformations(PixelPosition, /* out */ BufferUV, /* out */ ScreenPos);
  105.     
  106.             // 随机采样光源方向.
  107.             uint2 RandomSeed = ComputeRandomSeed(PixelPosition);
  108.             float2 E = Hammersley16(RaySequenceId, CONFIG_RAY_COUNT, RandomSeed);        
  109.             float3 L = ComputeL(DecompressN(CompressedN), E);
  110.             
  111.             // 步进偏移
  112.             float StepOffset = InterleavedGradientNoise(PixelPosition + 0.5, View.StateFrameIndexMod8);
  113.     
  114.             #if !SSGI_TRACE_CONE
  115.                 StepOffset -= 0.9;
  116.             #endif
  118.             bool bDebugPrint = all(PixelPosition == uint2(View.ViewSizeAndInvSize.xy) / 2);
  120.             // 初始化射线.
  121.             FSSRTRay Ray = InitScreenSpaceRay(ScreenPos, DeviceZ, L);
  122.             
  123.             float Level;
  124.             float3 HitUVz;
  125.             bool bHit;
  127.             #if !CONFIG_SORT_RAYS
  128.             // 如果分块分类可以检测出射线不能有任何交点, 则可以提前退出.
  129.             bool bEarlyOut = TestRayEarlyReturn(TileInfos, Ray);
  130.             
  131.             BRANCH
  132.             if (bEarlyOut)
  133.             {
  134.                 bHit = false;
  135.                 Level = 0;
  136.                 HitUVz = 0;
  137.             }
  138.             else
  139.             #endif
  140.             {
  141.                 // HZB屏幕空间的光线追踪(SSAO已解析过)
  142.                 bHit = CastScreenSpaceRay(
  143.                     FurthestHZBTexture, FurthestHZBTextureSampler,
  144.                     Ray, 1, CONFIG_RAY_STEPS, StepOffset,
  145.                     HZBUvFactorAndInvFactor, bDebugPrint,
  146.                     /* out */ HitUVz,
  147.                     /* out */ Level);
  148.             }
  149.             
  150.             // 如果找到交点, 则计算权重, 采样颜色, 应用权重到颜色并累加.
  151.             BRANCH
  152.             if (bHit)
  153.             {
  154.                 float2 ReducedColorUV =  HitUVz.xy * ColorBufferScaleBias.xy + ColorBufferScaleBias.zw;
  155.                 ReducedColorUV = min(ReducedColorUV, ReducedColorUVMax);
  157.                 float4 SampleColor = ColorTexture.SampleLevel(ColorTextureSampler, ReducedColorUV, Level);
  158.                 
  159.                 float SampleColorWeight = 1.0;
  161.                 // 交点表面的背面调整
  162.                 #if CONFIG_BACKFACE_MODULATION
  163.                 {
  164.                     float3 SampleNormal = GetGBufferDataFromSceneTextures(HitUVz.xy).WorldNormal;
  165.                     
  166.                     uint2 GroupPixelOffset = DecodeGroupPixelOffset(GroupPixelId);
  167.                     uint2 PixelPosition = ComputePixelPosition(GroupId, GroupPixelOffset);
  169.                     uint2 RandomSeed = ComputeRandomSeed(PixelPosition);
  171.                     float2 E = Hammersley16(RaySequenceId, CONFIG_RAY_COUNT, RandomSeed);
  172.         
  173.                     float3 L = ComputeL(DecompressN(CompressedN), E);
  174.         
  175.                     SampleColorWeight *= saturate( 1 - dot( SampleNormal, L ) );
  176.                 }
  177.                 #endif
  178.                 
  179.                 #if CONFIG_RAY_COUNT > 1
  180.                     SampleColorWeight *= rcp( 1 + Luminance(SampleColor.rgb) );
  181.                 #endif
  182.                 
  183.                 // 应用权重到颜色.
  184.                 float3 DiffuseColor = SampleColor.rgb * SampleColorWeight;
  185.                 float AmbientOcclusion = 1.0;
  186.                 
  187.                 #if CONFIG_COLOR_TILE_CLASSIFICATION
  188.                 {
  189.                     float Lumi = Luminance(DiffuseColor.rgb);
  190.                     AmbientOcclusion *= saturate(Lumi / 0.25);
  191.                 }
  192.                 #endif
  194.                 // 压缩颜色RGB和AO到XY通道中.
  195.                 CompressedColor.x = asuint(f32tof16(DiffuseColor.r) << 16 | f32tof16(DiffuseColor.g));
  196.                 CompressedColor.y = asuint(f32tof16(DiffuseColor.b) << 16 | f32tof16(AmbientOcclusion));
  197.             }
  198.             else
  199.             {
  200.                 CompressedColor = uint2(0, 0);
  201.             }
  202.             
  203.         }
  204.         else if (!bTraceRay)
  205.         {
  206.             CompressedColor = uint2(0, 0);
  207.         }
  208.         
  209.         uint DestPos = GroupPixelId + RaySequenceId * TILE_PIXEL_COUNT;
  210.         
  211.         // 保存压缩的颜色和AO数据到LDS中.
  212.         SharedMemory[LANE_PER_GROUPS * 0 | DestPos] = CompressedColor.x;
  213.         SharedMemory[LANE_PER_GROUPS * 1 | DestPos] = CompressedColor.y;
  214.     }
  215.     
  216.     GroupMemoryBarrierWithGroupSync();
  217.     
  218.     // 将LDS数据解压并保存到UAV中.
  219.     BRANCH
  220.     if (GroupThreadIndex < TILE_PIXEL_COUNT)
  221.     {
  222.         const uint GroupPixelId = GroupThreadIndex;
  223.     
  224.         float3 DiffuseColor = 0;
  225.         float AmbientOcclusion = 0;
  227.         // LDS保存了当前像素的多条射线的数据, 此处将它们解压并累加起来.
  228.         UNROLL
  229.         for (uint RaySequenceId = 0; RaySequenceId < CONFIG_RAY_COUNT; RaySequenceId++)
  230.         {
  231.             uint SrcPos = GroupPixelId + RaySequenceId * TILE_PIXEL_COUNT;
  233.             uint Row0 = SharedMemory[LANE_PER_GROUPS * 0 | SrcPos];
  234.             uint Row1 = SharedMemory[LANE_PER_GROUPS * 1 | SrcPos];
  236.             DiffuseColor.r += f16tof32(Row0 >> 16);
  237.             DiffuseColor.g += f16tof32(Row0 >>  0);
  238.             DiffuseColor.b += f16tof32(Row1 >> 16);
  239.             AmbientOcclusion += f16tof32(Row1 >> 0);
  240.         }
  242.         // 归一化颜色和AO等数据.
  243.         #if CONFIG_RAY_COUNT > 1
  244.         {
  245.             DiffuseColor *= rcp(float(CONFIG_RAY_COUNT));
  246.             AmbientOcclusion *= rcp(float(CONFIG_RAY_COUNT));
  248.             DiffuseColor *= rcp( 1 - Luminance(DiffuseColor) );
  249.         }    
  250.         #endif
  252.         DiffuseColor *= View.IndirectLightingColorScale;
  253.         AmbientOcclusion = 1 - AmbientOcclusion;
  255.         // 保存结果到UAV中.
  256.         {
  257.             uint2 GroupPixelOffset = DecodeGroupPixelOffset(GroupPixelId);
  258.             uint2 OutputPixelCoordinate = ComputePixelPosition(GroupId, GroupPixelOffset);
  260.             IndirectDiffuseOutput[OutputPixelCoordinate] = float4(DiffuseColor, 1.0);
  261.             AmbientOcclusionOutput[OutputPixelCoordinate] = AmbientOcclusion;
  262.         }
  263.     } // if (GroupThreadIndex < TILE_PIXEL_COUNT)
  264. } // MainCS()

由此可知，SSGI的采样生成、光线追踪、权重计算和结果累加的过程跟SSAO比较相似。经过上面的计算，最终输出了带噪点的颜色和AO纹理：

噪点的产生是由于每像素采样数不足，估算的结果跟实际值的方差比较大。这就需要后面的降噪步骤。降噪阶段分为三个Pass：压缩元数据、重建数据、时间累积降噪。压缩元数据Pass的输入有深度、法线等GBuffer数据，下面分析其使用的CS：

  1. // Engine\Shaders\Private\ScreenSpaceDenoise\SSDCompressMetadata.usf
  3. [numthreads(TILE_PIXEL_SIZE, TILE_PIXEL_SIZE, 1)]
  4. void MainCS(uint2 DispatchThreadId : SV_DispatchThreadID)
  5. {
  6.     // 计算UV和屏幕位置.
  7.     float2 SceneBufferUV = DispatchThreadId * ThreadIdToBufferUV.xy + ThreadIdToBufferUV.zw;
  8.     float2 ViewportUV = BufferUVToViewportUV(SceneBufferUV);
  9.     float2 ScreenPosition = ViewportUVToScreenPos(ViewportUV);
  11.     // 获取场景元数据.
  12.     FSSDSampleSceneInfos SceneMetadata = FetchCurrentSceneInfosFromGBuffer(ScreenPosition, SceneBufferUV);
  14.     // 压缩元数据.
  15.     FSSDCompressedSceneInfos CompressedMetadata = CompressSampleSceneInfo(DIM_METADATA_LAYOUT, SceneMetadata);
  17.     // No need to keep DispatchThreadId, while SceneBufferUV is arround at highest VGPR peak.
  18.     uint2 OutputPixelPostion = uint2(SceneBufferUV * BufferUVToOutputPixelPosition);
  20.     // 保存压缩后的元数据.
  21.     BRANCH
  22.     if (all(OutputPixelPostion < ViewportMax))
  23.     {
  24.         CompressedMetadataOutput_0[OutputPixelPostion] = CompressedMetadata.VGPR[0];
  25.     }
  26. } // MainCS

什么是场景的元数据？答案可以在FetchCurrentSceneInfosFromGBuffer：

  1. FSSDSampleSceneInfos FetchCurrentSceneInfosFromGBuffer(float2 ScreenPosition, float2 BufferUV)
  2. {
  3.     float DeviceZ = SampleDeviceZFromSceneTextures(BufferUV);
  4.     FGBufferData GBufferData = GetGBufferDataFromSceneTextures(BufferUV);
  5.     
  6.     // 处理场景采样信息.
  7.     FSSDSampleSceneInfos Infos = CreateSampleSceneInfos();
  8.     Infos.ScreenPosition = ScreenPosition;
  9.     Infos.DeviceZ = DeviceZ;
  10.     Infos.WorldDepth = GBufferData.Depth;
  11.     Infos.WorldNormal = GBufferData.WorldNormal;
  12.     Infos.Roughness = GBufferData.Roughness;
  13.     
  14.     // 计算平移后的世界位置.
  15.     {
  16.         float2 ClipPosition = ScreenPosition * (View.ViewToClip[3][3] < 1.0f ? Infos.WorldDepth : 1.0f);
  17.         Infos.TranslatedWorldPosition = mul(float4(ClipPosition, Infos.WorldDepth, 1), View.ScreenToTranslatedWorld).xyz;
  18.     }
  19.     
  20.     // 计算视图空间的法线.
  21.     Infos.ViewNormal = mul(float4(Infos.WorldNormal, 0), View.TranslatedWorldToView).xyz;
  23.     return Infos;
  24. }

所谓的场景元数据，就是当前像素的屏幕坐标、设备深度、世界深度、世界法线、粗糙度、偏移世界坐标和视图空间的法线等信息。至于压缩它们的过程，则需要进入CompressSampleSceneInfo分析：

  1. // Engine\Shaders\Private\ScreenSpaceDenoise\SSDMetadata.ush
  3. FSSDCompressedSceneInfos CompressSampleSceneInfo(
  4.     const uint CompressedLayout,
  5.     FSSDSampleSceneInfos Infos)
  6. {
  7.     FSSDCompressedSceneInfos CompressedInfos = CreateCompressedSceneInfos();
  9.     (......)
  10.     
  11.     // 压缩深度和视图空间的法线.(默认执行此分支)
  12.     else if (CompressedLayout == METADATA_BUFFER_LAYOUT_DEPTH_VIEWNORMAL)
  13.     {
  14.         CompressedInfos.VGPR[0] = CompressDevizeZAndN(Infos.DeviceZ, Infos.ViewNormal);
  15.     }
  16.     
  17.     (......)
  19.     return CompressedInfos;
  20. }

在SSGI涉及的压缩元数据Pass中，压缩的是深度和视图空间的法线，由CompressDevizeZAndN完成：

  1. uint CompressDevizeZAndN(float DevizeZ, float3 N)
  2. {
  3.     uint FaceN;
  4.     // 压缩法线.(后面由解析)
  5.     EncodeNormal(/* inout */ N, /* out */ FaceN);
  7.     // 将法线的xy从float转成uint.
  8.     uint2 FaceCood = uint2(clamp(round(127.0 * N.xy), 0, 127.0));
  9.     // 压缩法线和深度到32位uint.
  10.     uint Compressed = f32tof16(DevizeZ) | (FaceN << 15) | (FaceCood.x << 18) | (FaceCood.y << 25);
  11.     return Compressed;
  12. }
  14. // Engine\Shaders\Private\DeferredShadingCommon.ush
  15.     
  16. void EncodeNormal( inout float3 N, out uint Face )
  17. {
  18.     // 默认的法线朝向z.
  19.     uint Axis = 2;
  20.     // 如果法线的x值最大, 则将轴调整成x.
  21.     if( abs(N.x) >= abs(N.y) && abs(N.x) >= abs(N.z) )
  22.     {
  23.         Axis = 0;
  24.     }
  25.     // 如果法线的y值最大, 则将轴调整成y.
  26.     else if( abs(N.y) > abs(N.z) )
  27.     {
  28.         Axis = 1;
  29.     }
  30.     Face = Axis * 2;
  32.     // 根据轴向调整法线的各个分量.
  33.     N = Axis == 0 ? N.yzx : N;
  34.     N = Axis == 1 ? N.xzy : N;
  35.     
  36.     // 将法线的值域调整到[0, 1]
  37.     float MaxAbs = 1.0 / sqrt(2.0);
  38.     Face += N.z > 0 ? 0 : 1;
  39.     N.xy *= N.z > 0 ? 1 : -1;
  40.     N.xy = N.xy * (0.5 / MaxAbs) + 0.5;
  41. }

由上可知，元数据压缩就是将场景的深度和视图空间的法线压缩到32位的无符号整型，其中深度占前15bit，法线的朝向、X、Y分别占随后的3bit、7bit、7bit。元数据压缩后的输出纹理如下所示（值做了调整）：

重建数据Pass的输入有压缩的元数据、带噪点的颜色和AO纹理，下面直接分析其使用的CS Shader（结合RenderDoc截帧做了简化）：

  1. // Engine\Shaders\Private\ScreenSpaceDenoise\SSDSpatialAccumulation.usf
  3. [numthreads(TILE_PIXEL_SIZE, TILE_PIXEL_SIZE, 1)]
  4. void MainCS(
  5.     uint2 DispatchThreadId : SV_DispatchThreadID,
  6.     uint2 GroupId : SV_GroupID,
  7.     uint2 GroupThreadId : SV_GroupThreadID,
  8.     uint GroupThreadIndex : SV_GroupIndex)
  9. {
  10. #if CONFIG_SIGNAL_INPUT_TEXTURE_TYPE == SIGNAL_TEXTURE_TYPE_FLOAT4
  11.     Texture2D Signal_Textures_0 = SignalInput_Textures_0;
  12.     Texture2D Signal_Textures_1 = SignalInput_Textures_1;
  13.     Texture2D Signal_Textures_2 = SignalInput_Textures_2;
  14.     Texture2D Signal_Textures_3 = SignalInput_Textures_3;
  15. #else
  16.     (......)
  17. #endif
  19.     // 计算UV.
  20.     float2 SceneBufferUV = DispatchThreadId * ThreadIdToBufferUV.xy + ThreadIdToBufferUV.zw;
  21.     if (true)
  22.     {
  23.         SceneBufferUV = clamp(SceneBufferUV, BufferBilinearUVMinMax.xy, BufferBilinearUVMinMax.zw);
  24.     }
  25.     
  26.     // 读取相关的元数据.
  27.     FSSDCompressedSceneInfos CompressedRefSceneMetadata;
  28.     FSSDSampleSceneInfos RefSceneMetadata;
  29.     {
  30.         CompressedRefSceneMetadata = SampleCompressedSceneMetadata(
  31.             /* bPrevFrame = */ false,
  32.             SceneBufferUV, BufferUVToBufferPixelCoord(SceneBufferUV));
  33.         
  34.         float2 ScreenPosition = DenoiserBufferUVToScreenPosition(SceneBufferUV);
  35.     
  36.         RefSceneMetadata = UncompressSampleSceneInfo(
  37.             CONFIG_METADATA_BUFFER_LAYOUT, /* bPrevFrame = */ false,
  38.             ScreenPosition, CompressedRefSceneMetadata);
  39.     }
  41.     // 采样相关的采样数据.
  42.     #if !CONFIG_UPSCALE || 1
  43.         FSSDSignalArray RefSamples;
  44.         FSSDSignalFrequencyArray RefFrequencies;
  45.         SampleMultiplexedSignals(
  46.             Signal_Textures_0,
  47.             Signal_Textures_1,
  48.             Signal_Textures_2,
  49.             Signal_Textures_3,
  50.             GlobalPointClampedSampler,
  51.             CONFIG_SIGNAL_INPUT_LAYOUT,
  52.             /* MultiplexedSampleId = */ 0,
  53.             /* bNormalizeSample = */ CONFIG_NORMALIZE_INPUT != 0,
  54.             SceneBufferUV,
  55.             /* out */ RefSamples,
  56.             /* out */ RefFrequencies);
  57.         
  58.         #if CONFIG_NORMALIZE_INPUT
  59.             FSSDSignalArray NormalizedRefSamples = RefSamples;
  60.         #else
  61.             // TODO(Denoiser): Decode twice instead.
  62.             FSSDSignalArray NormalizedRefSamples = NormalizeToOneSampleArray(RefSamples);
  63.         #endif
  64.     #endif
  66.     // 缩放卷积核系数.
  67.     #if CONFIG_UPSCALE
  68.         float KernelSpreadFactor = UpscaleFactor;
  69.     #elif !CONFIG_CUSTOM_SPREAD_FACTOR
  70.         const float KernelSpreadFactor = 1;
  71.     #endif
  73.     // 计算所需的采样数量.
  74.     float RequestedSampleCount = 1024;
  75.     
  76.     #if CONFIG_SAMPLE_SET == SAMPLE_SET_NONE
  77.         RequestedSampleCount = 1;
  78.     #elif CONFIG_SAMPLE_COUNT_POLICY == SAMPLE_COUNT_POLICY_DISABLED
  79.         // NOP
  80.     #elif CONFIG_SAMPLE_COUNT_POLICY == SAMPLE_COUNT_POLICY_SAMPLE_ACCUMULATION_BASED
  81.     {
  82.         #if CONFIG_SIGNAL_BATCH_SIZE != 1
  83.             #error Unable to support more than one signal.
  84.         #endif
  85.         RequestedSampleCount = clamp(TARGETED_SAMPLE_COUNT / RefSamples.Array[0].SampleCount, 1, MaxSampleCount);
  86.     }
  87.     #else
  88.         #error Unknown policy to control the number of samples.
  89.     #endif
  91.     // 卷积核成员的别名.
  92.     #if (CONFIG_SAMPLE_SET == SAMPLE_SET_STACKOWIAK_4_SETS) && CONFIG_VGPR_OPTIMIZATION
  93.         float2 KernelBufferUV;
  94.         uint SampleTrackId;
  95.     #endif
  97.     // 在空间上积累输入.
  98.     FSSDSignalAccumulatorArray SignalAccumulators;
  99.     {
  100.         FSSDKernelConfig KernelConfig = CreateKernelConfig();
  102.         #if DEBUG_OUTPUT
  103.         {
  104.             KernelConfig.DebugPixelPosition = DispatchThreadId;
  105.             KernelConfig.DebugEventCounter = 0;
  106.         }
  107.         #endif
  109.         // 填充卷积核配置.
  110.         KernelConfig.SampleSet = CONFIG_SAMPLE_SET;
  111.         KernelConfig.SampleSubSetId = CONFIG_SAMPLE_SUBSET;
  112.         KernelConfig.BufferLayout = CONFIG_SIGNAL_INPUT_LAYOUT;
  113.         KernelConfig.MultiplexedSignalsPerSignalDomain = CONFIG_MULTIPLEXED_SIGNALS_PER_SIGNAL_DOMAIN;
  114.         KernelConfig.NeighborToRefComputation = NEIGHBOR_TO_REF_LOWEST_VGPR_PRESSURE;
  115.         KernelConfig.bUnroll = CONFIG_SAMPLE_SET != SAMPLE_SET_STACKOWIAK_4_SETS;
  116.         KernelConfig.bDescOrder = CONFIG_OUTPUT_MODE == OUTPUT_MODE_DRB;
  117.         KernelConfig.BilateralDistanceComputation = CONFIG_BILATERAL_DISTANCE_COMPUTATION;
  118.         KernelConfig.WorldBluringDistanceMultiplier = CONFIG_BILATERAL_DISTANCE_MULTIPLIER;
  119.         KernelConfig.bNormalizeSample = CONFIG_NORMALIZE_INPUT != 0;
  120.         KernelConfig.bSampleKernelCenter = CONFIG_UPSCALE;
  121.         KernelConfig.bForceKernelCenterAccumulation = true;
  122.         KernelConfig.bClampUVPerMultiplexedSignal = CONFIG_CLAMP_UV_PER_SIGNAL != 0;
  124.         // 从1spp重构球谐函数.
  125.         KernelConfig.bComputeSampleColorSH = DIM_STAGE == STAGE_RECONSTRUCTION && DIM_MULTI_SPP == 0;
  126.         
  127.         // 填充颜色空间.
  128.         {
  129.             UNROLL_N(SIGNAL_ARRAY_SIZE)
  130.             for (uint MultiplexId = 0; MultiplexId < SIGNAL_ARRAY_SIZE; MultiplexId++)
  131.             {
  132.                 KernelConfig.BufferColorSpace[MultiplexId] = CONFIG_INPUT_COLOR_SPACE;
  133.                 KernelConfig.AccumulatorColorSpace[MultiplexId] = CONFIG_ACCUMULATION_COLOR_SPACE;
  134.             }
  135.         }
  137.         // 设置双边滤波预设.
  138.         SetBilateralPreset(CONFIG_BILATERAL_PRESET, /* inout */ KernelConfig);
  140.         // SGPRs
  141.         KernelConfig.BufferSizeAndInvSize = BufferSizeAndInvSize;
  142.         KernelConfig.BufferBilinearUVMinMax = BufferBilinearUVMinMax;
  143.         KernelConfig.KernelSpreadFactor = KernelSpreadFactor;
  144.         KernelConfig.HarmonicPeriode = HarmonicPeriode;
  146.         (......)
  148.         // VGPRs
  149.         KernelConfig.BufferUV = SceneBufferUV; 
  150.         {
  151.             #if CONFIG_REF_METADATA_COMPRESSION == CONFIG_METADATA_BUFFER_LAYOUT
  152.                 // Straight up plumb down the compress layout to save any VALU.
  153.                 KernelConfig.CompressedRefSceneMetadata = CompressedRefSceneMetadata;
  154.             #else
  155.                 // Recompress the reference scene metadata
  156.                 KernelConfig.CompressedRefSceneMetadata = CompressSampleSceneInfo(CONFIG_REF_METADATA_COMPRESSION, RefSceneMetadata);
  157.             #endif
  158.             KernelConfig.RefBufferUV = SceneBufferUV;
  159.             KernelConfig.RefSceneMetadataLayout = CONFIG_REF_METADATA_COMPRESSION;
  160.         }
  161.         KernelConfig.HammersleySeed = Rand3DPCG16(int3(SceneBufferUV * BufferUVToOutputPixelPosition, View.StateFrameIndexMod8)).xy;
  163.         (......)
  165.         // 创建未压缩的累积器.
  166.         FSSDSignalAccumulatorArray UncompressedAccumulators = CreateSignalAccumulatorArray();
  168.         // 当不进行缩放时，手动强制累积内核的样本.
  169.         if (!KernelConfig.bSampleKernelCenter && !KernelConfig.bDescOrder)
  170.         {
  171.             // SIGNAL_ARRAY_SIZE默认是1, 即1spp.
  172.             UNROLL_N(SIGNAL_ARRAY_SIZE)
  173.             for (uint SignalMultiplexId = 0; SignalMultiplexId < SIGNAL_ARRAY_SIZE; SignalMultiplexId++)
  174.             {
  175.                 const uint BatchedSignalId = ComputeSignalBatchIdFromSignalMultiplexId(KernelConfig, SignalMultiplexId);
  176.                 FSSDSignalDomainKnowledge DomainKnowledge = GetSignalDomainKnowledge(BatchedSignalId);
  178.                 uint2 RefPixelCoord = floor(KernelConfig.BufferUV * KernelConfig.BufferSizeAndInvSize.xy);
  179.                 // 采样数据.
  180.                 FSSDSignalSample CenterSample = TransformSignalSampleForAccumulation(
  181.                     KernelConfig,
  182.                     SignalMultiplexId,
  183.                     RefSceneMetadata,
  184.                     RefSamples.Array[SignalMultiplexId],
  185.                     RefPixelCoord);
  186.                 
  187.                 // 采样累积信息.
  188.                 FSSDSampleAccumulationInfos SampleInfos;
  189.                 SampleInfos.Sample = CenterSample;
  190.                 SampleInfos.Frequency = RefFrequencies.Array[SignalMultiplexId];
  191.                 SampleInfos.FinalWeight = 1.0;
  192.                 SampleInfos.InvFrequency = GetSignalWorldBluringRadius(SampleInfos.Frequency, RefSceneMetadata, DomainKnowledge);
  193.                 
  194.                 if (KernelConfig.BilateralDistanceComputation == SIGNAL_WORLD_FREQUENCY_PRECOMPUTED_BLURING_RADIUS)
  195.                 {
  196.                     SampleInfos.InvFrequency = SampleInfos.Frequency.WorldBluringRadius;
  197.                 }
  199.                 // 累积样本.
  200.                 AccumulateSample(
  201.                     /* inout */ UncompressedAccumulators.Array[SignalMultiplexId],
  202.                     SampleInfos);
  203.             }
  204.         }
  206.         #if CONFIG_SAMPLE_SET == SAMPLE_SET_STACKOWIAK_4_SETS
  207.         {
  208.             KernelConfig.SampleCount = clamp(uint(RequestedSampleCount) / kStackowiakSampleSetCount, 1, MaxSampleCount);
  210.             (......)
  211.             {
  212.                 // 将内核中心放在四边形的中心, 在样本偏移中进行了半像素偏移.
  213.                 KernelConfig.BufferUV = float2(DispatchThreadId | 1) * ThreadIdToBufferUV.xy + ThreadIdToBufferUV.zw;
  215.                 // Id of the pixel in the quad. This is to match hard coded first samples of the sample set.
  216.                 KernelConfig.SampleTrackId = ((DispatchThreadId.x & 1) | ((DispatchThreadId.y & 1) << 1));
  217.             }
  218.             (......)
  219.         }
  220.         #elif CONFIG_SAMPLE_SET == SAMPLE_SET_DIRECTIONAL_RECT || CONFIG_SAMPLE_SET == SAMPLE_SET_DIRECTIONAL_ELLIPSE
  221.         (......)
  222.         #endif // CONFIG_SAMPLE_SET == SAMPLE_SET_DIRECTIONAL_*
  223.         
  224.         FSSDCompressedSignalAccumulatorArray CompressedAccumulators = CompressAccumulatorArray(UncompressedAccumulators, CONFIG_ACCUMULATOR_VGPR_COMPRESSION);
  226.         if (1)
  227.         {
  228.             // 累积卷积核.
  229.             AccumulateKernel(
  230.                 KernelConfig,
  231.                 Signal_Textures_0,
  232.                 Signal_Textures_1,
  233.                 Signal_Textures_2,
  234.                 Signal_Textures_3,
  235.                 /* inout */ UncompressedAccumulators,
  236.                 /* inout */ CompressedAccumulators);
  237.         }
  239.         (......)
  240.         
  241.         // 当按降序进行累积时，在任何累积之后手动采样内核的中心.
  242.         if (!KernelConfig.bSampleKernelCenter && KernelConfig.bDescOrder)
  243.         {
  244.             KernelConfig.BufferUV = SceneBufferUV;
  246.             SampleAndAccumulateCenterSampleAsItsOwnCluster(
  247.                 KernelConfig,
  248.                 Signal_Textures_0,
  249.                 Signal_Textures_1,
  250.                 Signal_Textures_2,
  251.                 Signal_Textures_3,
  252.                 /* inout */ UncompressedAccumulators,
  253.                 /* inout */ CompressedAccumulators);
  254.         }
  255.         
  256.         #if CONFIG_ACCUMULATOR_VGPR_COMPRESSION == ACCUMULATOR_COMPRESSION_DISABLED
  257.             SignalAccumulators = UncompressedAccumulators;
  258.         #else
  259.             SignalAccumulators = UncompressAccumulatorArray(CompressedAccumulators, CONFIG_ACCUMULATOR_VGPR_COMPRESSION);
  260.         #endif
  261.     }
  263.     (......)
  265.     // 将空间积累信号按不同的模式转换成多路复用信号.
  266.     uint MultiplexCount = 1;
  267.     FSSDSignalArray OutputSamples = CreateSignalArrayFromScalarValue(0.0);
  268.     FSSDSignalFrequencyArray OutputFrequencies = CreateInvalidSignalFrequencyArray();
  269.     {
  270.         {
  271.             MultiplexCount = CONFIG_SIGNAL_BATCH_SIZE;
  272.             
  273.             UNROLL_N(CONFIG_SIGNAL_BATCH_SIZE)
  274.             for (uint MultiplexId = 0; MultiplexId < CONFIG_SIGNAL_BATCH_SIZE; MultiplexId++)
  275.             {
  276.                 UncompressSignalAccumulator(/* inout */ SignalAccumulators.Array[MultiplexId]);
  278.                 OutputSamples.Array[MultiplexId] = SignalAccumulators.Array[MultiplexId].Moment1;
  279.                 
  280.                 // 输出最小的逆反频率作为新世界模糊半径的subsequent pass.
  281.                 OutputFrequencies.Array[MultiplexId] = SignalAccumulators.Array[MultiplexId].MinFrequency;
  282.             }
  283.         }
  284.         (......)
  285.     }
  286.     
  287.     (......)
  289.     // 计算输出像素位置.
  290.     uint2 OutputPixelPostion;
  291.     #if CONFIG_VGPR_OPTIMIZATION && !CONFIG_UPSCALE // TODO(Denoiser)
  292.     {
  293.         OutputPixelPostion = (uint2(KernelBufferUV * BufferUVToOutputPixelPosition) & ~0x1) | (uint2(SampleTrackId, SampleTrackId >> 1) & 0x1);
  294.         (......)
  295.     }
  296.     #else
  297.         OutputPixelPostion = ViewportMin + DispatchThreadId;
  298.     #endif 
  300.     BRANCH
  301.     if (all(OutputPixelPostion < ViewportMax))
  302.     {
  303.         // 输出多路复合信号.
  304.         (......)
  305.         {
  306.             OutputMultiplexedSignal(
  307.                 SignalOutput_UAVs_0,
  308.                 SignalOutput_UAVs_1,
  309.                 SignalOutput_UAVs_2,
  310.                 SignalOutput_UAVs_3,
  311.                 CONFIG_SIGNAL_OUTPUT_LAYOUT,
  312.                 MultiplexCount,
  313.                 OutputPixelPostion,
  314.                 OutputSamples,
  315.                 OutputFrequencies);
  316.         }
  317.     }
  318. } // MainCS

经过数据重建之后，输出的颜色和AO噪点有所降低：

经过数据重建之后的颜色和AO对比图。左侧是重建前的数据，右侧是重建后的数据。

由于数据重建之后的图像依然存在明显的噪点，这就需要降噪的最后一个阶段：时间累积降噪。它的输入有当前帧和上一帧的压缩元数据、场景颜色、时间累积数据等。其使用的CS Shader如下：

  1. // Engine\Shaders\Private\ScreenSpaceDenoise\SSDTemporalAccumulation.usf
  3. void TemporallyAccumulate(
  4.     uint2 DispatchThreadId : SV_DispatchThreadID,
  5.     uint2 GroupId : SV_GroupID,
  6.     uint2 GroupThreadId : SV_GroupThreadID,
  7.     uint GroupThreadIndex : SV_GroupIndex)
  8. {
  9.     // 计算buffer UV.
  10.     float2 SceneBufferUV = DispatchThreadId * ThreadIdToBufferUV.xy + ThreadIdToBufferUV.zw;
  11.     if (true)
  12.     {
  13.         SceneBufferUV = clamp(SceneBufferUV, BufferBilinearUVMinMax.xy, BufferBilinearUVMinMax.zw);
  14.     }
  16.     // 采样当前帧数据.
  17.     FSSDCompressedSceneInfos CompressedRefSceneMetadata = SampleCompressedSceneMetadata(
  18.         /* bPrevFrame = */ false,
  19.         SceneBufferUV, BufferUVToBufferPixelCoord(SceneBufferUV));
  21.     float DeviceZ;
  22.     {
  23.         FSSDSampleSceneInfos RefInfo = UncompressSampleSceneInfo(
  24.             CONFIG_METADATA_BUFFER_LAYOUT, /* bIsPrevFrame = */ false,
  25.             DenoiserBufferUVToScreenPosition(SceneBufferUV),
  26.             CompressedRefSceneMetadata);
  28.         DeviceZ = RefInfo.DeviceZ;
  29.     }
  31.     // 重投影到上一帧.
  32.     float3 HistoryScreenPosition = float3(DenoiserBufferUVToScreenPosition(SceneBufferUV), DeviceZ);
  33.     bool bIsDynamicPixel = false;
  34.     if (1)
  35.     {
  36.         float4 ThisClip = float4(HistoryScreenPosition, 1);
  38.         float4 PrevClip = mul(ThisClip, View.ClipToPrevClip);
  39.         float3 PrevScreen = PrevClip.xyz * rcp(PrevClip.w);
  40.         float3 Velocity = HistoryScreenPosition - PrevScreen;
  42.         if (1)
  43.         {
  44.             float4 EncodedVelocity = GBufferVelocityTexture.SampleLevel(GlobalPointClampedSampler, SceneBufferUV, 0);
  45.             if (EncodedVelocity.x > 0.0)
  46.             {
  47.                 Velocity = DecodeVelocityFromTexture(EncodedVelocity);
  48.             }
  49.         }
  51.         HistoryScreenPosition -= Velocity;
  52.     }
  54.     // 采样多路复合信号.
  55.     FSSDSignalArray CurrentFrameSamples;
  56.     FSSDSignalFrequencyArray CurrentFrameFrequencies;
  57.     SampleMultiplexedSignals(
  58.         SignalInput_Textures_0,
  59.         SignalInput_Textures_1,
  60.         SignalInput_Textures_2,
  61.         SignalInput_Textures_3,
  62.         GlobalPointClampedSampler,
  63.         CONFIG_SIGNAL_INPUT_LAYOUT,
  64.         /* MultiplexedSampleId = */ 0,
  65.         /* bNormalizeSample = */ CONFIG_NORMALIZED_INPUT != 0,
  66.         SceneBufferUV,
  67.         /* out */ CurrentFrameSamples,
  68.         /* out */ CurrentFrameFrequencies);
  70.     // 采样历史帧数据.
  71.     FSSDSignalArray HistorySamples = CreateSignalArrayFromScalarValue(0.0);
  72.     {
  73.         float2 HistoryBufferUV = HistoryScreenPosition.xy* ScreenPosToHistoryBufferUV.xy + ScreenPosToHistoryBufferUV.zw;
  74.         float2 ClampedHistoryBufferUV = clamp(HistoryBufferUV, HistoryBufferUVMinMax.xy, HistoryBufferUVMinMax.zw);
  75.         bool bIsPreviousFrameOffscreen = any(HistoryBufferUV != ClampedHistoryBufferUV);
  77.         BRANCH
  78.         if (!bIsPreviousFrameOffscreen)
  79.         {
  80.             FSSDKernelConfig KernelConfig = CreateKernelConfig();
  82.             #if DEBUG_OUTPUT
  83.             {
  84.                 KernelConfig.DebugPixelPosition = DispatchThreadId;
  85.                 KernelConfig.DebugEventCounter = 0;
  86.             }
  87.             #endif
  88.             
  89.             // 填充卷积核配置.
  90.             KernelConfig.SampleSet = CONFIG_HISTORY_KERNEL;
  91.             KernelConfig.bSampleKernelCenter = true;
  92.             KernelConfig.BufferLayout = CONFIG_SIGNAL_HISTORY_LAYOUT;
  93.             KernelConfig.MultiplexedSignalsPerSignalDomain = CONFIG_MULTIPLEXED_SIGNALS_PER_SIGNAL_DOMAIN;
  94.             KernelConfig.bUnroll = true;
  95.             KernelConfig.bPreviousFrameMetadata = true;
  96.             KernelConfig.BilateralDistanceComputation = SIGNAL_WORLD_FREQUENCY_MIN_METADATA;
  97.             KernelConfig.bClampUVPerMultiplexedSignal = CONFIG_CLAMP_UV_PER_SIGNAL != 0;
  99.             // 允许做双边拒绝历史时的一点错误，以适配每帧TAA抖动.
  100.             KernelConfig.WorldBluringDistanceMultiplier = max(CONFIG_BILATERAL_DISTANCE_MULTIPLIER, 3.0);
  101.             
  102.             // 设置双边预设.
  103.             SetBilateralPreset(CONFIG_HISTORY_BILATERAL_PRESET, /* inout */ KernelConfig);
  104.             // 卷积核的SGPR配置.
  105.             KernelConfig.BufferSizeAndInvSize = HistoryBufferSizeAndInvSize;
  106.             KernelConfig.BufferBilinearUVMinMax = HistoryBufferUVMinMax;
  107.             
  108.             #if CONFIG_CLAMP_UV_PER_SIGNAL
  109.             {
  110.                 UNROLL_N(CONFIG_SIGNAL_BATCH_SIZE)
  111.                 for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  112.                 {
  113.                     uint MultiplexId = BatchedSignalId / CONFIG_MULTIPLEXED_SIGNALS_PER_SIGNAL_DOMAIN;
  114.                     KernelConfig.PerSignalUVMinMax[MultiplexId] = HistoryBufferScissorUVMinMax[MultiplexId];
  115.                 }
  116.             }
  117.             #endif
  118.             
  119.             // 卷积核的VGPR配置.
  120.             KernelConfig.BufferUV = HistoryBufferUV + BufferUVBilinearCorrection;
  121.             KernelConfig.bIsDynamicPixel = bIsDynamicPixel;
  123.             #if CONFIG_PATCH_PREV_SCENE_DEPTH
  124.             {
  125.                 KernelConfig.RefBufferUV = HistoryBufferUV;
  126.                 KernelConfig.RefSceneMetadataLayout = CONFIG_METADATA_BUFFER_LAYOUT;
  127.                 KernelConfig.bPreviousFrameRefMetadata = true;
  129.                 FSSDSampleSceneInfos PrevRefInfo = UncompressSampleSceneInfo(
  130.                     CONFIG_METADATA_BUFFER_LAYOUT, /* bIsPrevFrame = */ false,
  131.                     BufferUVToBufferPixelCoord(SceneBufferUV),
  132.                     CompressedRefSceneMetadata);
  134.                 PrevRefInfo.ScreenPosition = HistoryScreenPosition.xy;
  135.                 PrevRefInfo.DeviceZ = HistoryScreenPosition.z;
  136.                 PrevRefInfo.WorldDepth = ConvertFromDeviceZ(HistoryScreenPosition.z);
  137.                 
  138.                 float4 ClipPosition = float4(HistoryScreenPosition.xy * (View.ViewToClip[3][3] < 1.0f ? PrevRefInfo.WorldDepth : 1.0f), PrevRefInfo.WorldDepth, 1);
  139.                 
  140.                 PrevRefInfo.TranslatedWorldPosition = mul(ClipPosition, View.PrevScreenToTranslatedWorld).xyz + (View.PreViewTranslation.xyz - View.PrevPreViewTranslation.xyz);
  141.                 
  142.                 KernelConfig.CompressedRefSceneMetadata = CompressSampleSceneInfo(
  143.                     KernelConfig.RefSceneMetadataLayout,
  144.                     PrevRefInfo);
  145.             }
  146.             #else
  147.             {
  148.                 KernelConfig.CompressedRefSceneMetadata = CompressedRefSceneMetadata;
  149.                 KernelConfig.RefBufferUV = SceneBufferUV;
  150.                 KernelConfig.RefSceneMetadataLayout = CONFIG_METADATA_BUFFER_LAYOUT;
  151.             }
  152.             #endif
  154.             // 计算随机信号.
  155.             ISOLATE
  156.             {
  157.                 KernelConfig.Randoms[0] = InterleavedGradientNoise(SceneBufferUV * BufferUVToOutputPixelPosition, View.StateFrameIndexMod8);
  158.             }
  159.             
  160.             FSSDSignalAccumulatorArray SignalAccumulators = CreateSignalAccumulatorArray();
  161.             FSSDCompressedSignalAccumulatorArray UnusedCompressedAccumulators = CreateUninitialisedCompressedAccumulatorArray();
  163.             // 累计卷积核.
  164.             AccumulateKernel(
  165.                 KernelConfig,
  166.                 PrevHistory_Textures_0,
  167.                 PrevHistory_Textures_1,
  168.                 PrevHistory_Textures_2,
  169.                 PrevHistory_Textures_3,
  170.                 /* inout */ SignalAccumulators,
  171.                 /* inout */ UnusedCompressedAccumulators);
  172.         
  173.             // 从累加器导出历史帧采样.
  174.             UNROLL_N(CONFIG_SIGNAL_BATCH_SIZE)
  175.             for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  176.             {
  177.                 HistorySamples.Array[BatchedSignalId] = SignalAccumulators.Array[BatchedSignalId].Moment1;
  178.                 BRANCH
  179.                 if (bCameraCut[BatchedSignalId])
  180.                 {
  181.                     HistorySamples.Array[BatchedSignalId] = CreateSignalSampleFromScalarValue(0.0);
  182.                 }
  183.             }
  185.             UNROLL_N(CONFIG_SIGNAL_BATCH_SIZE)
  186.             for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  187.             {
  188.                 FSSDSignalSample CurrentFrameSample = CurrentFrameSamples.Array[BatchedSignalId];
  189.                 FSSDSignalSample HistorySample = HistorySamples.Array[BatchedSignalId];
  191.                 // 应用历史帧的预曝光.
  192.                 #if COMPILE_SIGNAL_COLOR
  193.                     HistorySamples.Array[BatchedSignalId].SceneColor.rgb *= HistoryPreExposureCorrection;
  194.                 #endif
  195.             } // for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  196.         } // if (!bIsPreviousFrameOffscreen)
  197.     }
  198.     
  199.     #if CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_DIFFUSE_INDIRECT_AND_AO && 0
  200.         DebugOutput[DispatchThreadId] = float4(
  201.             HistorySamples.Array[0].SampleCount / 4096,
  202.             0,
  203.             0,
  204.             0);
  205.     #endif
  206.     
  207.     const bool bPostRejectionBlending = true;
  209.     // 历史帧数据的摒弃.
  210.     #if (CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_MINMAX_BOUNDARIES || CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_VAR_BOUNDARIES)
  211.     {
  212.         FSSDKernelConfig KernelConfig = CreateKernelConfig();
  213.         
  214.         #if DEBUG_OUTPUT
  215.         {
  216.             KernelConfig.DebugPixelPosition = DispatchThreadId;
  217.             KernelConfig.DebugEventCounter = 0;
  218.         }
  219.         #endif
  221.         {
  222.             KernelConfig.bSampleKernelCenter = CONFIG_USE_REJECTION_BUFFER != 0;
  223.         
  224.             // 历史帧摒弃已经通过任何重投影模糊了系数. 为了优先考虑样本比精度更大的抑制稳定性，所以只取参考样本的模糊距离，这取决于当前帧的深度和像素大小。
  225.             KernelConfig.BilateralDistanceComputation = SIGNAL_WORLD_FREQUENCY_REF_METADATA_ONLY;
  226.             KernelConfig.NeighborToRefComputation = NEIGHBOR_TO_REF_LOWEST_VGPR_PRESSURE;
  228.             if (CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_SHADOW_VISIBILITY_MASK)
  229.                 KernelConfig.BilateralDistanceComputation = SIGNAL_WORLD_FREQUENCY_PRECOMPUTED_BLURING_RADIUS;
  230.             KernelConfig.WorldBluringDistanceMultiplier = CONFIG_BILATERAL_DISTANCE_MULTIPLIER;
  231.             
  232.             #if CONFIG_REJECTION_SAMPLE_SET == SAMPLE_SET_NXN
  233.             {
  234.                 KernelConfig.SampleSet = SAMPLE_SET_NXN;
  235.                 KernelConfig.BoxKernelRadius = 3;
  236.                 KernelConfig.bUnroll = false;
  237.             }
  238.             #else
  239.             {
  240.                 KernelConfig.SampleSet = CONFIG_REJECTION_SAMPLE_SET;
  241.                 KernelConfig.bUnroll = true;
  242.             }
  243.             #endif
  245.             if (CONFIG_USE_REJECTION_BUFFER)
  246.             {
  247.                 // 历史摒弃有被去噪信号的两个矩(moment).
  248.                 KernelConfig.MultiplexedSignalsPerSignalDomain = 2;
  249.                 
  250.                 KernelConfig.BufferLayout = CONFIG_SIGNAL_HISTORY_REJECTION_LAYOUT;
  251.                 KernelConfig.bNormalizeSample = false;
  252.             
  253.                 for (uint MultiplexId = 0; MultiplexId < SIGNAL_ARRAY_SIZE; MultiplexId++)
  254.                 {
  255.                     KernelConfig.BufferColorSpace[MultiplexId] = CONFIG_REJECTION_BUFFER_COLOR_SPACE;
  256.                     KernelConfig.AccumulatorColorSpace[MultiplexId] = CONFIG_HISTORY_REJECTION_COLOR_SPACE;
  257.                 }
  259.                 // 强制采样内核中心，因为它将包含两个用于匹配场景元数据的矩.
  260.                 KernelConfig.bForceKernelCenterAccumulation = true;
  261.             }
  262.             else
  263.             {
  264.                 KernelConfig.MultiplexedSignalsPerSignalDomain = CONFIG_MULTIPLEXED_SIGNALS_PER_SIGNAL_DOMAIN;
  265.                 KernelConfig.BufferLayout = CONFIG_SIGNAL_INPUT_LAYOUT;
  266.                 KernelConfig.bNormalizeSample = true;
  267.             
  268.                 for (uint MultiplexId = 0; MultiplexId < SIGNAL_ARRAY_SIZE; MultiplexId++)
  269.                 {
  270.                     KernelConfig.AccumulatorColorSpace[MultiplexId] = CONFIG_HISTORY_REJECTION_COLOR_SPACE;
  271.                 }
  272.             
  273.                 if (MAX_SIGNAL_BATCH_SIZE == 1)
  274.                 {
  275.                     KernelConfig.bForceAllAccumulation = CurrentFrameSamples.Array[0].SampleCount == 0;
  276.                 }
  277.             }
  278.             
  279.             SetBilateralPreset(CONFIG_BILATERAL_PRESET, /* inout */ KernelConfig);
  280.         }
  282.         // SGPR配置.
  283.         {
  284.             KernelConfig.BufferSizeAndInvSize = BufferSizeAndInvSize;
  285.             KernelConfig.BufferBilinearUVMinMax = BufferBilinearUVMinMax;
  286.         }
  288.         // VGPR配置.
  289.         {
  290.             KernelConfig.BufferUV = SceneBufferUV;
  291.             {
  292.                 KernelConfig.CompressedRefSceneMetadata = CompressedRefSceneMetadata;
  293.                 KernelConfig.RefBufferUV = SceneBufferUV;
  294.                 KernelConfig.RefSceneMetadataLayout = CONFIG_METADATA_BUFFER_LAYOUT;
  295.             }
  296.         }
  298.         // 累积当前帧以节省不必要的双边性能评估.
  299.         FSSDSignalAccumulatorArray SignalAccumulators = CreateSignalAccumulatorArray();
  300.         {
  301.             FSSDSampleSceneInfos RefSceneMetadata = UncompressRefSceneMetadata(KernelConfig);
  302.             
  303.             FSSDCompressedSignalAccumulatorArray UnusedCompressedAccumulators = CreateUninitialisedCompressedAccumulatorArray();
  305.             FSSDSignalArray CenterSample = CurrentFrameSamples;
  306.             if (KernelConfig.bNormalizeSample)
  307.             {
  308.                 CenterSample = NormalizeToOneSampleArray(CurrentFrameSamples);
  309.             }
  311.             AccumulateRefSampleAsKernelCenter(
  312.                 KernelConfig,
  313.                 /* inout */ SignalAccumulators,
  314.                 /* inout */ UnusedCompressedAccumulators,
  315.                 KernelConfig.RefBufferUV,
  316.                 RefSceneMetadata,
  317.                 CenterSample,
  318.                 CurrentFrameFrequencies);
  319.         }
  321.         {
  322.             FSSDCompressedSignalAccumulatorArray UnusedCompressedAccumulators = CreateUninitialisedCompressedAccumulatorArray();
  324.             #if CONFIG_USE_REJECTION_BUFFER
  325.                 AccumulateKernel(
  326.                     KernelConfig,
  327.                     HistoryRejectionSignal_Textures_0,
  328.                     HistoryRejectionSignal_Textures_1,
  329.                     HistoryRejectionSignal_Textures_2,
  330.                     HistoryRejectionSignal_Textures_3,
  331.                     /* inout */ SignalAccumulators,
  332.                     /* inout */ UnusedCompressedAccumulators);
  333.             #else
  334.                 AccumulateKernel(
  335.                     KernelConfig,
  336.                     SignalInput_Textures_0,
  337.                     SignalInput_Textures_1,
  338.                     SignalInput_Textures_2,
  339.                     SignalInput_Textures_3,
  340.                     /* inout */ SignalAccumulators,
  341.                     /* inout */ UnusedCompressedAccumulators);
  342.             #endif
  343.         }
  345.         // 裁剪历史数据.
  346.         UNROLL_N(CONFIG_SIGNAL_BATCH_SIZE)
  347.         for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  348.         {
  349.             FSSDSignalSample NeighborMoment1 = CreateSignalSampleFromScalarValue(0.0);
  350.             FSSDSignalSample NeighborMoment2 = CreateSignalSampleFromScalarValue(0.0);
  351.             #if CONFIG_REJECTION_INPUT_MODE == REJECTION_INPUT_MODE_1UNNORMALIZED
  352.             {
  353.                 float NormalizeFactor = SafeRcp(SignalAccumulators.Array[BatchedSignalId].Moment1.SampleCount);
  354.                 NeighborMoment1 = MulSignal(SignalAccumulators.Array[BatchedSignalId].Moment1, NormalizeFactor);
  355.                 
  356.                 #if COMPILE_MOMENT2_ACCUMULATOR
  357.                     NeighborMoment2 = MulSignal(SignalAccumulators.Array[BatchedSignalId].Moment2, NormalizeFactor);
  358.                 #endif
  359.             }
  360.             #elif CONFIG_REJECTION_INPUT_MODE == REJECTION_INPUT_MODE_2PRETRANSFORMED_MOMMENTS
  361.             {
  362.                 #if SIGNAL_ARRAY_SIZE != 2 * MAX_SIGNAL_BATCH_SIZE
  363.                     #error Invalid signal array size.
  364.                 #endif
  366.                 float NormalizeFactor = SafeRcp(SignalAccumulators.Array[BatchedSignalId * 2 + 0].Moment1.SampleCount);
  367.                 NeighborMoment1 = MulSignal(SignalAccumulators.Array[BatchedSignalId * 2 + 0].Moment1, NormalizeFactor);
  368.                 NeighborMoment2 = MulSignal(SignalAccumulators.Array[BatchedSignalId * 2 + 1].Moment1, NormalizeFactor);
  369.             }
  370.             #else
  371.                 #error NOrmalized samples. 
  372.             #endif
  373.         
  374.             #if CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_REFLECTIONS && 0
  375.                 FSSDSignalSample Temp = TransformSignalForPostRejection(NeighborMoment1);
  376.                 DebugOutput[DispatchThreadId] = float4(
  377.                     Temp.SceneColor.rgb,
  378.                     0);
  379.             #endif
  380.                 
  381.             FSSDSignalSample CurrentFrameSample = CurrentFrameSamples.Array[BatchedSignalId];
  382.             FSSDSignalSample HistorySample = HistorySamples.Array[BatchedSignalId];
  384.             // 裁剪历史数据.
  385.             #if CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_VAR_BOUNDARIES
  386.             {
  387.                 #if CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_AO
  388.                     const float StdDevMultiplier = 6.00;
  389.                 #else
  390.                     const float StdDevMultiplier = 1.25;
  391.                 #endif
  393.                 FSSDSignalSample StdDev = SqrtSignal(AbsSignal(SubtractSignal(NeighborMoment2, PowerSignal(NeighborMoment1, 2))));
  394.                 FSSDSignalSample NeighborMin = AddSignal(NeighborMoment1, MulSignal(StdDev, -StdDevMultiplier));
  395.                 FSSDSignalSample NeighborMax = AddSignal(NeighborMoment1, MulSignal(StdDev,  StdDevMultiplier));
  397.                 if (0)
  398.                 {
  399.                     FSSDSignalSample QuantizationErrorMin = MulSignal(NeighborMoment1, 1 - SafeRcp(HistorySample.SampleCount));
  400.                     FSSDSignalSample QuantizationErrorMax = MulSignal(NeighborMoment1, 1 + SafeRcp(HistorySample.SampleCount));
  402.                     NeighborMin = MinSignal(NeighborMin, QuantizationErrorMin);
  403.                     NeighborMax = MaxSignal(NeighborMax, QuantizationErrorMax);
  404.                 }
  406.                 // 变换历史数据，使其在正确的组件空间中，并规范化为裁剪盒.
  407.                 FSSDSignalSample NormalizedHistorySample = NormalizeToOneSample(HistorySample);
  408.                 FSSDSignalSample TransformedHistorySample = TransformInputBufferForPreRejection(NormalizedHistorySample);
  410.                 // 裁剪历史.
  411.                 FSSDSignalSample ClampedTransformedHistorySample = ClampSignal(TransformedHistorySample, NeighborMin, NeighborMax);
  413.                 // 变换历史回到线性组件空间.
  414.                 FSSDSignalSample ClampedHistorySample = TransformSignalForPostRejection(ClampedTransformedHistorySample);
  416.                 // 重估抗鬼影的历史数据.
  417.                 {
  418.                     FSSDSignalSample RejectedDiff = AbsSignal(SubtractSignal(ClampedTransformedHistorySample, TransformedHistorySample));
  420.                     // 计算历史数据被改变的程度.
  421.                     float RejectionFactor = 0.0;
  422.                     #if CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_REFLECTIONS && (CONFIG_HISTORY_REJECTION_COLOR_SPACE & COLOR_SPACE_LCOCG)
  423.                     {
  424.                         #if !COMPILE_SIGNAL_COLOR
  425.                             #error Need to compile signal color.
  426.                         #endif
  427.                         RejectionFactor = abs(
  428.                             Luma_To_LumaLog(ClampedTransformedHistorySample.SceneColor.x) -
  429.                             Luma_To_LumaLog(TransformedHistorySample.SceneColor.x));
  430.                 
  431.                         RejectionFactor = max(RejectionFactor, 1 * max(RejectedDiff.SceneColor.y, RejectedDiff.SceneColor.z));
  432.                         RejectionFactor = max(RejectionFactor, 1 * RejectedDiff.SceneColor.a);
  433.                     }
  434.                     #elif CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_SHADOW_VISIBILITY_MASK || CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_POLYCHROMATIC_PENUMBRA_HARMONIC || CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_AO || CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_DIFFUSE_INDIRECT_AND_AO
  435.                     {
  436.                         RejectionFactor = abs(ClampedTransformedHistorySample.MissCount - TransformedHistorySample.MissCount);
  437.                     }
  438.                     #elif CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_SSGI
  439.                     {
  440.                         RejectionFactor = abs(ClampedTransformedHistorySample.MissCount - TransformedHistorySample.MissCount);
  441.                     }
  442.                     #else
  443.                         #error Unsupported signal rejection.
  444.                     #endif
  445.             
  446.                     // 计算一个初始历史权重，就像已经删除了样本一样.
  447.                     float FinalHistoryWeight = HistorySample.SampleCount * saturate(1 - RejectionFactor);
  449.                     // 在进行摒弃前的积累时，需要确保输入权重通过.
  450.                     if (!bPostRejectionBlending)
  451.                     {
  452.                         FinalHistoryWeight = max(FinalHistoryWeight, CurrentFrameSample.SampleCount);
  453.                     }
  455.                     // 当执行上采样时, 可能拥有非法的输入样本.
  456.                     FinalHistoryWeight = max(FinalHistoryWeight, NeighborMoment1.SampleCount * 0.1);
  457.             
  458.                     // 应用历史权重.
  459.                     HistorySample = MulSignal(ClampedHistorySample, FinalHistoryWeight);
  460.                     HistorySample.SampleCount = FinalHistoryWeight;
  461.                 }
  462.             }
  463.             #elif CONFIG_HISTORY_REJECTION == HISTORY_REJECTION_MINMAX_BOUNDARIES
  464.             {
  465.                 FSSDSignalSample NeighborMin = SignalAccumulators.Array[BatchedSignalId].Min;
  466.                 FSSDSignalSample NeighborMax = SignalAccumulators.Array[BatchedSignalId].Max;
  468.                 // 如果没有邻居有样本, 最大样本数将为0.
  469.                 bool bIsValid = NeighborMax.SampleCount > 0.0;
  471.                 float RejectedSampleCount = 0;
  472.                 HistorySample = MulSignal(TransformSignalForPostRejection(ClampSignal(TransformInputBufferForPreRejection(NormalizeToOneSample(HistorySample)), NeighborMin, NeighborMax)), HistorySample.SampleCount - RejectedSampleCount);
  474.                 // 所有的裁剪盒都是无效的，所以历史样本也无效.
  475.                 FLATTEN
  476.                 if (!bIsValid)
  477.                 {
  478.                     HistorySample = CreateSignalSampleFromScalarValue(0.0);
  479.                 }
  480.             }
  481.             #endif
  483.             // 扩大最小的逆反频率.
  484.             if (1)
  485.             {
  486.                 CurrentFrameFrequencies.Array[BatchedSignalId] = MinSignalFrequency(
  487.                     CurrentFrameFrequencies.Array[BatchedSignalId],
  488.                     SignalAccumulators.Array[BatchedSignalId].MinFrequency);
  489.             }
  490.             
  491.             HistorySamples.Array[BatchedSignalId] = HistorySample;
  492.             CurrentFrameSamples.Array[BatchedSignalId] = CurrentFrameSample;
  493.         } // for (uint BatchedSignalId = 0; BatchedSignalId < CONFIG_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  494.     }
  495.     #endif // CONFIG_HISTORY_REJECTION > 0
  496.     
  497.     // 处理并保存当前像素的所有历史样本.
  498.     {
  499.         UNROLL
  500.         for (uint BatchedSignalId = 0; BatchedSignalId < MAX_SIGNAL_BATCH_SIZE; BatchedSignalId++)
  501.         {
  502.             FSSDSignalSample CurrentFrameSample = CurrentFrameSamples.Array[BatchedSignalId];
  503.             FSSDSignalSample HistorySample = HistorySamples.Array[BatchedSignalId];
  504.             FSSDSignalFrequency CurrentFrequency = CurrentFrameFrequencies.Array[BatchedSignalId];
  506.             float TargetedSampleCount;
  507.             {
  508.                 float2 ScreenPosition = DenoiserBufferUVToScreenPosition(SceneBufferUV);
  509.     
  510.                 FSSDSampleSceneInfos RefSceneMetadata = UncompressSampleSceneInfo(
  511.                     CONFIG_METADATA_BUFFER_LAYOUT, /* bPrevFrame = */ false,
  512.                     ScreenPosition, CompressedRefSceneMetadata);
  514.                 // Use the diameter, because that is the distance between two pixel.
  515.                 float PixelWorldBluringRadius = ComputeWorldBluringRadiusCausedByPixelSize(RefSceneMetadata);
  516.                 float WorldBluringRadius = WorldBluringRadiusToBilateralWorldDistance(PixelWorldBluringRadius);
  517.     
  518.                 #if CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_SHADOW_VISIBILITY_MASK
  519.                 {
  520.                     float ResolutionFraction = 0.5;
  521.                     float ToleratedNoiseRatio = 0.25 * rcp(9 * sqrt(2));
  523.                     float OutputPixelRadius = CurrentFrequency.WorldBluringRadius * rcp(PixelWorldBluringRadius) * ResolutionFraction;
  525.                     TargetedSampleCount = clamp(OutputPixelRadius * OutputPixelRadius * (PI * ToleratedNoiseRatio), 1, TARGETED_SAMPLE_COUNT);
  526.                 }
  527.                 #elif CONFIG_SIGNAL_PROCESSING == SIGNAL_PROCESSING_REFLECTIONS
  528.                 {
  529.                     float2 NormalizedScreenMajorAxis;
  530.                     float InifinityMajorViewportRadius;
  531.                     float InifinityMinorViewportRadius;
  532.                     ProjectSpecularLobeToScreenSpace(
  533.                         RefSceneMetadata,
  534.                         /* out */ NormalizedScreenMajorAxis,
  535.                         /* out */ InifinityMajorViewportRadius,
  536.                         /* out */ InifinityMinorViewportRadius);
  538.                     InifinityMajorViewportRadius *= View.ViewSizeAndInvSize.x;
  539.                     InifinityMinorViewportRadius *= View.ViewSizeAndInvSize.x;
  541.                     TargetedSampleCount = PI * InifinityMajorViewportRadius * InifinityMinorViewportRadius;
  542.                     TargetedSampleCount = clamp(TargetedSampleCount, 1, TARGETED_SAMPLE_COUNT);
  543.                 }
  544.                 #else
  545.                 {
  546.                     TargetedSampleCount = TARGETED_SAMPLE_COUNT;
  547.                 }
  548.                 #endif
  549.             }
  551.             float PreviousFrameWeight = min(HistorySample.SampleCount, TargetedSampleCount - CurrentFrameSample.SampleCount);
  552.             float PreviousFrameMultiplier = HistorySample.SampleCount > 0 ? PreviousFrameWeight / HistorySample.SampleCount : 0;
  554.             // 信号的预变换.
  555.             HistorySample = TransformSignal(
  556.                 HistorySample,
  557.                 /* SrcBasis = */ STANDARD_BUFFER_COLOR_SPACE,
  558.                 /* DestBasis = */ CONFIG_HISTORY_BLENDING_COLOR_SPACE);
  559.             CurrentFrameSample = TransformSignal(
  560.                 CurrentFrameSample,
  561.                 /* SrcBasis = */ STANDARD_BUFFER_COLOR_SPACE,
  562.                 /* DestBasis = */ CONFIG_HISTORY_BLENDING_COLOR_SPACE);
  564.             // 混合当前帧和历史帧的样本.
  565.             HistorySample = AddSignal(MulSignal(HistorySample, PreviousFrameMultiplier), CurrentFrameSample);
  566.         
  567.             // 信号的后置变换.
  568.             HistorySample = TransformSignal(
  569.                 HistorySample,
  570.                 /* SrcBasis = */ CONFIG_HISTORY_BLENDING_COLOR_SPACE,
  571.                 /* DestBasis = */ STANDARD_BUFFER_COLOR_SPACE);
  572.             
  573.             HistorySamples.Array[BatchedSignalId] = HistorySample;
  574.         }
  575.     }
  576.     
  577.     // 白名单应该输出，以确保编译器编译出所有最终不需要的东西.
  578.     uint MultiplexCount = 1;
  579.     FSSDSignalArray OutputSamples = CreateSignalArrayFromScalarValue(0.0);
  580.     FSSDSignalFrequencyArray OutputFrequencies = CreateInvalidSignalFrequencyArray();
  581.     {
  582.         MultiplexCount = CONFIG_SIGNAL_BATCH_SIZE;
  583.         
  584.         UNROLL
  585.         for (uint BatchedSignalId = 0; BatchedSignalId < MultiplexCount; BatchedSignalId++)
  586.         {
  587.             OutputSamples.Array[BatchedSignalId] = HistorySamples.Array[BatchedSignalId];
  588.             OutputFrequencies.Array[BatchedSignalId] = CurrentFrameFrequencies.Array[BatchedSignalId];
  589.         }
  590.     }
  591.     
  592.     uint2 OutputPixelPostion = BufferUVToBufferPixelCoord(SceneBufferUV);
  593.         
  594.     BRANCH
  595.     if (all(OutputPixelPostion < ViewportMax))
  596.     {
  597.         OutputMultiplexedSignal(
  598.             SignalHistoryOutput_UAVs_0,
  599.             SignalHistoryOutput_UAVs_1,
  600.             SignalHistoryOutput_UAVs_2,
  601.             SignalHistoryOutput_UAVs_3,
  602.             CONFIG_SIGNAL_HISTORY_LAYOUT,
  603.             MultiplexCount,
  604.             OutputPixelPostion,
  605.             OutputSamples,
  606.             OutputFrequencies);
  607.     }
  608. } // TemporallyAccumulate
  610. // 时间累积主入口.
  611. [numthreads(TILE_PIXEL_SIZE, TILE_PIXEL_SIZE, 1)]
  612. void MainCS(
  613.     uint2 DispatchThreadId : SV_DispatchThreadID,
  614.     uint2 GroupId : SV_GroupID,
  615.     uint2 GroupThreadId : SV_GroupThreadID,
  616.     uint GroupThreadIndex : SV_GroupIndex)
  617. {
  618.     // 时间累积主调用.
  619.     TemporallyAccumulate(DispatchThreadId, GroupId, GroupThreadId, GroupThreadIndex);
  620. }

在实时光线追踪领域，降噪算法有很多，诸如使用引导的模糊内核的滤波，机器学习驱动滤波器或重要采样，通过更好的准随机序列（如蓝色噪声和时空积累）改进采样方案以及近似技术，尝试用某种空间结构来量化结果（如探针、辐照度缓存）。

滤波（Filtering）技术有Gaussian、Bilateral、À-Trous、Guided以及Median，这些方法常用于过滤蒙特卡洛追踪的模糊照片。特别是由特性缓冲区（如延迟渲染的GBuffer）和特殊缓冲区（如first-bounce data, reprojected path length, view position）驱动的引导滤波器已被广泛使用。

采样（Sampling）技术有TAA、Spatio-Temporal Filter、SVGF（Spatio-Temporal Variance Guided Filter）、Adaptive SVGF (A-SVGF)、BMFR（Blockwise Multi-Order Feature Regression）、ReSTIR（Spatiotemporal Importance Resampling for Many-Light Ray Tracing）等技术。

近似（approximation ）技术常用于尝试微调路径跟踪器的不同方面的行为。

还有基于深度学习的技术（如DLSS），更多降噪的说明可以参看Ray Tracing Denoising。

从上面分析的代码来看，UE的屏幕空间降噪综合使用了滤波、采样的若干种技术（双边滤波、空间卷积、时间卷积、随机采样、信号和频率等等）。

结果时间累积之后，可以看到画面的噪点更少且不明显了：

SSGI组合的最后一个阶段，它结合降噪阶段输出的颜色、AO以及GBuffer，组合成当前帧的带非直接光和AO的场景颜色：

组合Pass使用的是PS，代码如下：

  1. // Engine\Shaders\Private\DiffuseIndirectComposite.usf
  3. void MainPS(float4 SvPosition : SV_POSITION, out float4 OutColor : SV_Target0)
  4. {
  5.     float2 BufferUV = SvPositionToBufferUV(SvPosition);
  6.     float2 ScreenPosition = SvPositionToScreenPosition(SvPosition).xy;
  8.     // 采样GBuffer.
  9.     FGBufferData GBuffer = GetGBufferDataFromSceneTextures(BufferUV);
  11.     // 采样每帧动态生成的AO.
  12.     float DynamicAmbientOcclusion = 1.0f;
  13. #if DIM_APPLY_AMBIENT_OCCLUSION
  14.     DynamicAmbientOcclusion = AmbientOcclusionTexture.SampleLevel(AmbientOcclusionSampler, BufferUV, 0).r;
  15. #endif
  17.     // 计算最终要被应用的AO.
  18.     float FinalAmbientOcclusion = GBuffer.GBufferAO * DynamicAmbientOcclusion;
  20.     OutColor.rgb = 0.0f;
  21.     OutColor.a = 1.0f;
  23.     // 应用漫反射非直接光.
  24. #if DIM_APPLY_DIFFUSE_INDIRECT
  25.     {
  26.         float3 DiffuseColor = GBuffer.DiffuseColor;
  27.         if (UseSubsurfaceProfile(GBuffer.ShadingModelID))
  28.         {
  29.             DiffuseColor = GBuffer.StoredBaseColor;
  30.         }
  32.         OutColor.rgb += DiffuseColor * DiffuseIndirectTexture.SampleLevel(DiffuseIndirectSampler, BufferUV, 0).rgb;
  33.     }
  34. #endif
  36.     // 应用AO到场景颜色. 因为在延迟直接照明之前，假设SceneColor中的所有照明都是间接照明.
  37.     {
  38.         float AOMask = (GBuffer.ShadingModelID != SHADINGMODELID_UNLIT);
  39.         OutColor.a = lerp(1.0f, FinalAmbientOcclusion, AOMask * AmbientOcclusionStaticFraction);
  40.     }
  41. }

SSGI的组合逻辑跟SSAO非常相似。

除了上述章节的后处理技术，实际上，还存在很多本章未阐述的技术，例如：

  • 泛光（Bloom）
  • 景深（DOF）
  • 自动曝光（又叫人眼适应，Eye Adaptation）
  • 暗角（Vignette）
  • 颗粒（Grain）
  • 颜色分级（Color Grading）
  • 颜色查找（LUT）
  • ……

这些就留待读者自己去挖掘和研读UE源码了。

 

本篇主要阐述了UE的后处理，包含传统的后处理技术，如抗锯齿、色调映射、Gamma校正、屏幕半分比等，以及广义的后处理技术，如SSR、SSAO、SSGI等。

当然，还有更多后处理本篇为涉及，这里就抛砖引玉，让读者对UE有了基础理解之后，再迈向后处理技术的更广阔的天地。

按惯例，本篇也布置一些小思考，以助理解和加深本篇知识的掌握和理解：

  • 阐述后处理管线的主要流程和步骤。
  • 阐述PassSequence的作用和注意事项。
  • 实现SMAA。
  • 实现自定义色调映射的后处理材质，以替换UE的默认色调映射。

 

  • 感谢所有参考文献的作者，部分图片来自参考文献和网络，侵删。
  • 本系列文章为笔者原创，只发表在博客园上，欢迎分享本文链接，但未经同意，不允许转载！
  • 系列文章，未完待续，完整目录请戳内容纲目。
  • 系列文章，未完待续，完整目录请戳内容纲目。
  • 系列文章，未完待续，完整目录请戳内容纲目。

 

版权声明：本文为timlly原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/timlly/p/15048404.html