devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

剖析虚幻渲染体系（12）- 移动端专题Part 1（UE移动端渲染分析）_ue在rendertarget技术性能

作者：从前慢现在也慢 | 2024-02-18 14:45:39

赞

踩

ue在rendertarget技术性能

目录

12.1 本篇概述

前面的所有篇章都是基于PC端的延迟渲染管线阐述UE的渲染体系的，特别是剖析虚幻渲染体系（04）- 延迟渲染管线详尽地阐述了在PC端的延迟渲染管线的流程和步骤。

此篇只要针对UE的移动端的渲染管线进行阐述，最终还会对比移动和和PC端的渲染差异，以及特殊的优化措施。本篇主要阐述UE渲染体系的以下内容：

  • FMobileSceneRenderer的主要流程和步骤。
  • 移动端的前向和延迟渲染管线。
  • 移动端的光影和阴影。
  • 移动端和PC端的异同，以及涉及的特殊优化技巧。

特别要指出的是，本篇分析的UE源码升级到了4.27.1，需要同步看源码的同学注意更新了。

如果要在PC的UE编辑器开启移动端渲染管线，可以选择如下所示的菜单：

等待Shader编译完成，UE编辑器的视口内便是移动端的预览效果。

12.1.1 移动设备的特点

相比PC桌面平台，移动端在尺寸、电量、硬件性能等诸多方面都存在显著的差异，具体表现在：

  • 更小的尺寸。移动端的便携性就要求整机设备必须轻巧，可置于掌中或口袋内，所以整机只能限制在非常小的体积之内。

  • 有限的能量和功率。受限于电池存储技术，目前的主流锂电池普通在1万毫安，但移动设备的分辨率、画质却越来越高，为了满足足够长的续航和散热限制，必须严格控制移动设备的整机功率，通常在5w以内。

  • 散热方式受限。PC设备通常可以安装散热风扇、甚至水冷系统，而移动设备不具备这些主动散热方式，只能靠热传导散热。如果散热不当，CPU和GPU都会主动降频，以非常有限的性能运行，以免设备元器件因过热而损毁。

  • 有限的硬件性能。移动设备的各类元件（CPU、带宽、内存、GPU等）的性能都只是PC设备的数十分之一。

    2018年，主流PC设备（NV GV100-400-A1 Titan V）和主流移动设备（Samsung Exynos 9 8895）的性能对比图。移动设备的很多硬件性能只是PC设备的几十分之一，但分辨率却接近PC的一半，更加突显了移动设备的挑战和窘境。

    到了2020年，主流的移动设备性能如下所示：

  • 特殊的硬件架构。如CPU和GPU共享内存存储设备，被称为耦合式架构，还有GPU的TB(D)R架构，目的都是为了在低功耗内完成尽可能多的操作。

    PC设备的解耦硬件架构和移动设备的耦合式硬件架构对比图。

除此之外，不同于PC端的CPU和GPU纯粹地追求计算性能，衡量移动端的性能有三个指标：性能（Performance）、能量（Power）、面积（Area），俗称PPA。（下图）

衡量移动设备的三个基本参数：Performance、Area、Power，其中Compute Density（计算密度）涉及性能和面积，能耗比涉及性能和能力消耗，越大越好。

与移动设备一起崛起的还有XR设备，它是移动设备的一个重要发展分支。目前存在着各种不同大小、功能、应用场景的XR设备：

各种形式的XR设备。

随着近来元宇宙（Metaverse）的爆火，以及FaceBook改名为Meta，加之Apple、MicroSoft、NVidia、Google等科技巨头都在加紧布局面向未来的沉浸式体验，XR设备作为能够最接近元宇宙畅想的载体和入口，自然成为一条未来非常有潜力能够出现巨无霸的全新赛道。

12.2 UE移动端渲染特性

本章阐述一下UE4.27在移动端的渲染特性。

12.2.1 Feature Level

UE在移动端支持以下图形API：

Feature Level说明
OpenGL ES 3.1安卓系统的默认特性等级，可以在工程设置（Project Settings > Platforms > Android Material Quality - ES31）配置具体的材质参数。
Android Vulkan可用于某些特定Android设备的高端渲染器，支持Vulkan 1.2 API，轻量级设计理念的Vulkan，多数情况下会比OpenGL更高效。
Metal 2.0专用于iOS设备的特性等级。可以在Project Settings > Platforms > iOS Material Quality配置材质参数。

在目前的主流安卓设备，使用Vulkan能获得更好的性能，原因在于Vulkan轻量级的设计理念，使得UE等应用程序能够更加精准地执行优化。下面是Vulkan和OpenGL的对照表：

VulkanOpenGL
基于对象的状态，没有全局状态。单一的全局状态机。
所有的状态概念都放置到命令缓冲区中。状态被绑定到单个上下文。
可以多线程编码。渲染操作只能被顺序执行。
可以精确、显式地操控GPU的内存和同步。GPU的内存和同步细节通常被驱动程序隐藏起来。
驱动程序没有运行时错误检测，但存在针对开发人员的验证层。广泛的运行时错误检测。

如果在Windows平台，UE编辑器也可以启动OpenGL、Vulkan、Metal的模拟器，以便在编辑器时预览效果，但可能跟实际的运行设备的画面有差异，不可完全依赖此功能。

开启Vulkan前需要在工程中配置一些参数，具体参看官方文档Android Vulkan Mobile Renderer。

另外，UE早前几个版本就移除了windows下的OpenGL支持，虽然目前UE编辑器还存在OpenGL的模拟选项，但实际上底层是用D3D渲染的。

12.2.2 Deferred Shading

UE的Deferred Shading（延迟着色）是在4.26才加入的功能，使得开发者能够在移动端实现较复杂的光影效果，诸如高质量反射、多动态光照、贴花、高级光照特性。

上：前向渲染；下：延迟渲染。

如果要在移动端开启延迟渲染，需要在工程配置目录下的DefaultEngine.ini添加r.Mobile.ShadingPath=1字段，然后重启编辑器。

12.2.3 Ground Truth Ambient Occlusion

Ground Truth Ambient Occlusion (GTAO)是接近现实世界的环境遮挡技术，是阴影的一种补偿，能够遮蔽一部分非直接光照，从而获得良好的软阴影效果。

开启了GTAO的效果，注意机器人靠近墙面时，会在墙面留下具有渐变的软阴影效果。

为了开启GTAO，需要勾选以下所示的选项：

此外，GTAO依赖Mobile HDR的选项，为了在对应目标设备开启，还需要在[Platform]Scalability.ini的配置中添加r.Mobile.AmbientOcclusionQuality字段，并且值需要大于0，否则GTAO将被禁用。

值得注意的是，GTAO在Mali设备上存在性能问题，因为它们的最大Compute Shader线程数量少于1024个。

12.2.4 Dynamic Lighting and Shadow

UE在移动端实现的光源特性有：

  • 线性空间的HDR光照。
  • 带方向的光照图（考虑了法线）。
  • 太阳（平行光）支持距离场阴影 + 解析的镜面高光。
  • IBL光照：每个物体采样了最近的一个反射捕捉器，而没有视差校正。
  • 动态物体能正确地接受光照，也可以投射阴影。

UE移动端支持的动态光源的类型、数量、阴影等信息如下：

光源类型最大数量阴影描述
平行光1CSMCSM默认是2级，最多支持4级。
点光源4不支持点光源阴影需要立方体阴影图，而单Pass渲染立方体阴影（OnePassPointLightShadow）的技术需要GS（SM5才有）才支持。
聚光灯4支持默认禁用，需要在工程中开启。
区域光0不支持目前不支持动态区域光照效果。

动态的聚光灯需要在工程配置中显式开启：

在移动BasePass的像素着色器中，聚光灯阴影图与CSM共享相同的纹理采样器，并且聚光灯阴影和CSM使用相同的阴影图图集。CSM能够保证有足够的空间，而聚光灯将按阴影分辨率排序。

默认情况下，可见阴影的最大数量被限制为8个，但可以通过改变r.Mobile.MaxVisibleMovableSpotLightsShadow的值来改变上限值。聚光灯阴影的分辨率是基于屏幕大小和r.Shadow.TexelsPerPixelSpotlight。

在前向渲染路径中，局部光源（点光源和聚光灯）的总数不能超过4个。

移动端还支持一种特殊的阴影模式，那就是调制阴影（Modulated Shadows），只能用于固定（Stationary）的平行光。开启了调制阴影的效果图如下：

调制阴影还支持改变阴影颜色和混合比例：

左：动态阴影；右：调制阴影。

移动端的阴影同样支持自阴影、阴影质量等级（r.shadowquality）、深度偏移等参数的设置。

此外，移动端默认使用了GGX的高光反射，如果想切换到传统的高光着色模型，可以在以下配置里修改：

12.2.5 Pixel Projected Reflection

UE针对移动端做了一个优化版的SSR，被称为Pixel Projected Reflection（PPR），也是复用屏幕空间像素的核心思想。

PPR效果图。

为了开启PPR效果，需要满足以下条件：

  • 开启MobileHDR选项。

  • r.Mobile.PixelProjectedReflectionQuality的值大于0。

  • 设置Project Settings > Mobile and set the Planar Reflection Mode成正确的模式：

    Planar Reflection Mode有3个选项：

    • Usual：平面反射Actor在所有平台上的作用都是相同的。
    • MobilePPR：平面反射Actor在PC/主机平台上正常工作，但在移动平台上使用PPR渲染。
    • MobilePPRExclusive：平面反射Actor将只用于移动平台上的PPR，为PC和Console项目留下了使用传统SSR的空间。

默认只有高端移动设备才会在[Project]Scalability.ini开启r.Mobile.PixelProjectedReflectionQuality。

12.2.6 Mesh Auto-Instancing

PC端的网格绘制管线已经支持了网格的自动化实例和合并绘制，这个特性可以极大提升渲染性能。4.27已经在移动端支持了这一特性。

若想开启，则需要打开工程配置目录下的DefaultEngine.ini，添加以下字段：

  1. r.Mobile.SupportGPUScene=1
  2. r.Mobile.UseGPUSceneTexture=1

重启编辑器，等待Shader编译完即可预览效果。

由于需要GPUSceneTexture支持，而Mali设备的Uniform Buffer最大只有64kb，以致无法支持足够大的空间，所以，Mali设备会使用纹理而非缓冲区来存储GPUScene数据。

但也存在一些限制：

  • 移动设备上的自动实例化主要有利于CPU密集型项目，而不是GPU密集型项目。虽然启用自动实例化不太可能会对GPU密集型的项目造成损害，但不太可能看到使用它带来的显著性能改进。

  • 如果一款游戏或应用需要大量内存，那么关闭r.Mobile.UseGPUSceneTexture并使用缓冲区可能会更有好处，因为它无法在Mali设备上正常运行。

    也可以针对Mali设备关闭r.Mobile.UseGPUSceneTexture，而其它GPU厂商的设备正常使用。

自动实例化的有效性很大程度上取决于项目的确切规范和定位，建议创建一个启用了自动实例化的构建，并对其进行概要分析，以确定是否会看到实质性的性能提升。

12.2.7 Post Processing

由于移动设备存在更慢的依赖纹理读取（dependent texture read）、有限的硬件特性、特殊的硬件架构、额外的渲染目标解析、有限的带宽等限制性因素，故而后处理在移动设备上执行起来会比较耗性能，有些极端情况会卡住渲染管线。

尽管如此，在某些画质要求高的游戏或应用，依然非常依赖后处理的强劲表现力，为高品质迈上几个台阶。UE不会限制开发者使用后处理。

为了开启后处理，必须先开启MobileHDR选项：

开启后处理之后，就可以在后处理体积（Post Process Volume）设置各种后处理效果。

在移动端可以支持的后处理有Mobile Tonemapper、Color Grading、Lens、Bloom、Dirt Mask、Auto Exposure、Lens Flares、Depth of Field等等。

为了获得更好的性能，官方给出的建议是在移动端只开启Bloom和TAA。

12.2.8 其它特性和限制

  • Reflection Capture Compression

移动端支持反射捕捉器组件（Reflection Capture Component）的压缩，可以减少Reflection Capture运行时的内存和带宽，提升渲染效率。需要在工程配置中开启：

开启之后，默认使用ETC2进行压缩。另外，也可以针对每个Reflection Capture Component进行调整：

  • 材质特性

移动平台上的材质(特性级别Open ES 3.1)使用与其他平台相同的基于节点的创建过程，并且绝大多数节点在移动端都支持。

移动平台支持的材质属性有：BaseColor、Roughness、Metallic、Specular、Normal、Emissive、Refraction，但不支持Scene Color表达式、Tessellation输入、次表面散射着色模型。

移动平台支持的材质存在一些限制：

  • 由于硬件限制，只能使用16个纹理采样器。
  • 只有DefaultLit和Unlit着色模型可用。
  • 自定义UV应该用来避免依赖纹理读取（没有纹理uv的数学计算）。
  • 半透明和Masked材质是及其耗性能， 建议尽量使用不透明材质。
  • 深度淡出（Depth fade）可以在iOS平台的半透明材质中使用，但在硬件不支持从深度缓冲区获取数据的平台上，是不受支持的，将导致不可接受的性能成本。

材质属性面板存在一些针对移动端的特殊选项：

这些属性的说明如下：

  • Mobile Separate Translucency：是否在移动端开启单独的半透明渲染纹理。

  • Use Full Precision：是否使用全精度，如果否，可以减少带宽占用和能耗，提升性能，但可能会出现远处物体的瑕疵：

    左：全精度材质；右：半精度材质，远处的太阳出现了瑕疵。

  • Use Lightmap Directionality：是否开启光照图的方向性，若勾选，会考虑光照图的方向和像素法线，但会提升性能消耗。

  • Use Alpha to Coverage：是否为Masked材质开启MSAA抗锯齿，若勾选，会开启MSAA。

  • Fully Rough：是否完全粗糙，如果勾选，将极大提升此材质的渲染效率。

此外，移动端支持的网格类型有：

  • Skeletal Mesh
  • Static Mesh
  • Landscape
  • CPU particle sprites, particle meshes

除上述类型以外的其它都不被支持。其它限制还有：

  • 单个网格最多只能到65k，因为顶点索引只有16位。
  • 单个Skeletal Mesh的骨骼数量必须在75个以内，因为受硬件性能的限制。

12.3 FMobileSceneRenderer

FMobileSceneRenderer继承自FSceneRenderer，它负责移动端的场景渲染流程，而PC端是同样继承自FSceneRenderer的FDeferredShadingSceneRenderer。它们的继承关系图如下：

FSceneRenderer

FMobileSceneRenderer

FDeferredShadingSceneRenderer

前述多篇文章已经提及了FDeferredShadingSceneRenderer，它的渲染流程尤为复杂，包含了复杂的光影和渲染步骤。相比之下，FMobileSceneRenderer的逻辑和步骤会简单许多，下面是RenderDoc的截帧：

以上主要包含了InitViews、ShadowDepths、PrePass、BasePass、OcclusionTest、ShadowProjectionOnOpaque、Translucency、PostProcessing等步骤。其中这些步骤在PC端都是存在的，但实现过程可能会有所不同。见后续章节剖析。

12.3.1 渲染器主流程

移动端的场景渲染器的主流程也发生在FMobileSceneRenderer::Render中，代码和解析如下：

  1. // Engine\Source\Runtime\Renderer\Private\MobileShadingRenderer.cpp
  2.  
  3. void FMobileSceneRenderer::Render(FRHICommandListImmediate& RHICmdList)
  4. {
  5.     // 更新图元场景信息。
  6.     Scene->UpdateAllPrimitiveSceneInfos(RHICmdList);
  7.  
  8.     // 准备视图的渲染区域.
  9.     PrepareViewRectsForRendering(RHICmdList);
  10.  
  11.     // 准备天空大气的数据
  12.     if (ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags))
  13.     {
  14.         for (int32 LightIndex = 0; LightIndex < NUM_ATMOSPHERE_LIGHTS; ++LightIndex)
  15.         {
  16.             if (Scene->AtmosphereLights[LightIndex])
  17.             {
  18.                 PrepareSunLightProxy(*Scene->GetSkyAtmosphereSceneInfo(), LightIndex, *Scene->AtmosphereLights[LightIndex]);
  19.             }
  20.         }
  21.     }
  22.     else
  23.     {
  24.         Scene->ResetAtmosphereLightsProperties();
  25.     }
  26.  
  27.     if(!ViewFamily.EngineShowFlags.Rendering)
  28.     {
  29.         return;
  30.     }
  31.  
  32.     // 等待遮挡剔除测试.
  33.     WaitOcclusionTests(RHICmdList);
  34.     FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  35.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  36.  
  37.     // 初始化视图, 查找可见图元, 准备渲染所需的RT和缓冲区等数据.
  38.     InitViews(RHICmdList);
  39.     
  40.     if (GRHINeedsExtraDeletionLatency || !GRHICommandList.Bypass())
  41.     {
  42.         QUICK_SCOPE_CYCLE_COUNTER(STAT_FMobileSceneRenderer_PostInitViewsFlushDel);
  43.  
  44.         // 可能会暂停遮挡查询，所以最好在等待时让RHI线程和GPU工作. 此外，当执行RHI线程时，这是唯一将处理挂起删除的位置.
  45.         FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  46.         FRHICommandListExecutor::GetImmediateCommandList().ImmediateFlush(EImmediateFlushType::FlushRHIThreadFlushResources);
  47.     }
  48.  
  49.     GEngine->GetPreRenderDelegate().Broadcast();
  50.  
  51.     // 在渲染开始前提交全局动态缓冲.
  52.     DynamicIndexBuffer.Commit();
  53.     DynamicVertexBuffer.Commit();
  54.     DynamicReadBuffer.Commit();
  55.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  56.  
  57.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_SceneSim));
  58.  
  59.     if (ViewFamily.bLateLatchingEnabled)
  60.     {
  61.         BeginLateLatching(RHICmdList);
  62.     }
  63.  
  64.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  65.  
  66.     // 处理虚拟纹理
  67.     if (bUseVirtualTexturing)
  68.     {
  69.         SCOPED_GPU_STAT(RHICmdList, VirtualTextureUpdate);
  70.         
  71.         FVirtualTextureSystem::Get().Update(RHICmdList, FeatureLevel, Scene);
  72.         
  73.         // Clear virtual texture feedback to default value
  74.         FUnorderedAccessViewRHIRef FeedbackUAV = SceneContext.GetVirtualTextureFeedbackUAV();
  75.         RHICmdList.Transition(FRHITransitionInfo(FeedbackUAV, ERHIAccess::SRVMask, ERHIAccess::UAVMask));
  76.         RHICmdList.ClearUAVUint(FeedbackUAV, FUintVector4(~0u, ~0u, ~0u, ~0u));
  77.         RHICmdList.Transition(FRHITransitionInfo(FeedbackUAV, ERHIAccess::UAVMask, ERHIAccess::UAVMask));
  78.         RHICmdList.BeginUAVOverlap(FeedbackUAV);
  79.     }
  80.     
  81.     // 已排序的光源信息.
  82.     FSortedLightSetSceneInfo SortedLightSet;
  83.     
  84.     // 延迟渲染.
  85.     if (bDeferredShading)
  86.     {
  87.         // 收集和排序光源.
  88.         GatherAndSortLights(SortedLightSet);
  89.         
  90.         int32 NumReflectionCaptures = Views[0].NumBoxReflectionCaptures + Views[0].NumSphereReflectionCaptures;
  91.         bool bCullLightsToGrid = (NumReflectionCaptures > 0 || GMobileUseClusteredDeferredShading != 0);
  92.         FRDGBuilder GraphBuilder(RHICmdList);
  93.         // 计算光源格子.
  94.         ComputeLightGrid(GraphBuilder, bCullLightsToGrid, SortedLightSet);
  95.         GraphBuilder.Execute();
  96.     }
  97.  
  98.     // 生成天空/大气LUT.
  99.     const bool bShouldRenderSkyAtmosphere = ShouldRenderSkyAtmosphere(Scene, ViewFamily.EngineShowFlags);
  100.     if (bShouldRenderSkyAtmosphere)
  101.     {
  102.         FRDGBuilder GraphBuilder(RHICmdList);
  103.         RenderSkyAtmosphereLookUpTables(GraphBuilder);
  104.         GraphBuilder.Execute();
  105.     }
  106.  
  107.     // 通知特效系统场景准备渲染.
  108.     if (FXSystem && ViewFamily.EngineShowFlags.Particles)
  109.     {
  110.         FXSystem->PreRender(RHICmdList, NULL, !Views[0].bIsPlanarReflection);
  111.         if (FGPUSortManager* GPUSortManager = FXSystem->GetGPUSortManager())
  112.         {
  113.             GPUSortManager->OnPreRender(RHICmdList);
  114.         }
  115.     }
  116.     // 轮询遮挡剔除请求.
  117.     FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  118.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  119.  
  120.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Shadows));
  121.  
  122.     // 渲染阴影.
  123.     RenderShadowDepthMaps(RHICmdList);
  124.     FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  125.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  126.  
  127.     // 收集视图列表.
  128.     TArray<const FViewInfo*> ViewList;
  129.     for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++) 
  130.     {
  131.         ViewList.Add(&Views[ViewIndex]);
  132.     }
  133.  
  134.     // 渲染自定义深度.
  135.     if (bShouldRenderCustomDepth)
  136.     {
  137.         FRDGBuilder GraphBuilder(RHICmdList);
  138.         FSceneTextureShaderParameters SceneTextures = CreateSceneTextureShaderParameters(GraphBuilder, Views[0].GetFeatureLevel(), ESceneTextureSetupMode::None);
  139.         RenderCustomDepthPass(GraphBuilder, SceneTextures);
  140.         GraphBuilder.Execute();
  141.     }
  142.  
  143.     // 渲染深度PrePass.
  144.     if (bIsFullPrepassEnabled)
  145.     {
  146.         // SDF和AO需要完整的PrePass深度.
  147.  
  148.         FRHIRenderPassInfo DepthPrePassRenderPassInfo(
  149.             SceneContext.GetSceneDepthSurface(),
  150.             EDepthStencilTargetActions::ClearDepthStencil_StoreDepthStencil);
  151.  
  152.         DepthPrePassRenderPassInfo.NumOcclusionQueries = ComputeNumOcclusionQueriesToBatch();
  153.         DepthPrePassRenderPassInfo.bOcclusionQueries = DepthPrePassRenderPassInfo.NumOcclusionQueries != 0;
  154.  
  155.         RHICmdList.BeginRenderPass(DepthPrePassRenderPassInfo, TEXT("DepthPrepass"));
  156.  
  157.         RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_MobilePrePass));
  158.         
  159.         // 渲染完整的深度PrePass.
  160.         RenderPrePass(RHICmdList);
  161.  
  162.         // 提交遮挡剔除.
  163.         RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Occlusion));
  164.         RenderOcclusion(RHICmdList);
  165.  
  166.         RHICmdList.EndRenderPass();
  167.  
  168.         // SDF阴影
  169.         if (bRequiresDistanceFieldShadowingPass)
  170.         {
  171.             CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderSDFShadowing);
  172.             RenderSDFShadowing(RHICmdList);
  173.         }
  174.  
  175.         // HZB.
  176.         if (bShouldRenderHZB)
  177.         {
  178.             RenderHZB(RHICmdList, SceneContext.SceneDepthZ);
  179.         }
  180.  
  181.         // AO.
  182.         if (bRequiresAmbientOcclusionPass)
  183.         {
  184.             RenderAmbientOcclusion(RHICmdList, SceneContext.SceneDepthZ);
  185.         }
  186.     }
  187.  
  188.     FRHITexture* SceneColor = nullptr;
  189.     
  190.     // 延迟渲染.
  191.     if (bDeferredShading)
  192.     {
  193.         SceneColor = RenderDeferred(RHICmdList, ViewList, SortedLightSet);
  194.     }
  195.     // 前向渲染.
  196.     else
  197.     {
  198.         SceneColor = RenderForward(RHICmdList, ViewList);
  199.     }
  200.     
  201.     // 渲染速度缓冲.
  202.     if (bShouldRenderVelocities)
  203.     {
  204.         FRDGBuilder GraphBuilder(RHICmdList);
  205.  
  206.         FRDGTextureMSAA SceneDepthTexture = RegisterExternalTextureMSAA(GraphBuilder, SceneContext.SceneDepthZ);
  207.         FRDGTextureRef VelocityTexture = TryRegisterExternalTexture(GraphBuilder, SceneContext.SceneVelocity);
  208.  
  209.         if (VelocityTexture != nullptr)
  210.         {
  211.             AddClearRenderTargetPass(GraphBuilder, VelocityTexture);
  212.         }
  213.  
  214.         // 渲染可移动物体的速度缓冲.
  215.         AddSetCurrentStatPass(GraphBuilder, GET_STATID(STAT_CLMM_Velocity));
  216.         RenderVelocities(GraphBuilder, SceneDepthTexture.Resolve, VelocityTexture, FSceneTextureShaderParameters(), EVelocityPass::Opaque, false);
  217.         AddSetCurrentStatPass(GraphBuilder, GET_STATID(STAT_CLMM_AfterVelocity));
  218.  
  219.         // 渲染透明物体的速度缓冲.
  220.         AddSetCurrentStatPass(GraphBuilder, GET_STATID(STAT_CLMM_TranslucentVelocity));
  221.         RenderVelocities(GraphBuilder, SceneDepthTexture.Resolve, VelocityTexture, GetSceneTextureShaderParameters(CreateMobileSceneTextureUniformBuffer(GraphBuilder, EMobileSceneTextureSetupMode::SceneColor)), EVelocityPass::Translucent, false);
  222.  
  223.         GraphBuilder.Execute();
  224.     }
  225.  
  226.     // 处理场景渲染后的逻辑.
  227.     {
  228.         FRendererModule& RendererModule = static_cast<FRendererModule&>(GetRendererModule());
  229.         FRDGBuilder GraphBuilder(RHICmdList);
  230.         RendererModule.RenderPostOpaqueExtensions(GraphBuilder, Views, SceneContext);
  231.  
  232.         if (FXSystem && Views.IsValidIndex(0))
  233.         {
  234.             AddUntrackedAccessPass(GraphBuilder, [this](FRHICommandListImmediate& RHICmdList)
  235.             {
  236.                 check(RHICmdList.IsOutsideRenderPass());
  237.  
  238.                 FXSystem->PostRenderOpaque(
  239.                     RHICmdList,
  240.                     Views[0].ViewUniformBuffer,
  241.                     nullptr,
  242.                     nullptr,
  243.                     Views[0].AllowGPUParticleUpdate()
  244.                 );
  245.                 if (FGPUSortManager* GPUSortManager = FXSystem->GetGPUSortManager())
  246.                 {
  247.                     GPUSortManager->OnPostRenderOpaque(RHICmdList);
  248.                 }
  249.             });
  250.         }
  251.         GraphBuilder.Execute();
  252.     }
  253.  
  254.     // 刷新/提交命令缓冲.
  255.     if (bSubmitOffscreenRendering)
  256.     {
  257.         RHICmdList.SubmitCommandsHint();
  258.         RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  259.     }
  260.     
  261.     // 转换场景颜色成SRV, 以供后续步骤读取.
  262.     if (!bGammaSpace || bRenderToSceneColor)
  263.     {
  264.         RHICmdList.Transition(FRHITransitionInfo(SceneColor, ERHIAccess::Unknown, ERHIAccess::SRVMask));
  265.     }
  266.  
  267.     if (bDeferredShading)
  268.     {
  269.         // 释放场景渲染目标上的原始引用.
  270.         SceneContext.AdjustGBufferRefCount(RHICmdList, -1);
  271.     }
  272.  
  273.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Post));
  274.  
  275.     // 处理虚拟纹理.
  276.     if (bUseVirtualTexturing)
  277.     {    
  278.         SCOPED_GPU_STAT(RHICmdList, VirtualTextureUpdate);
  279.  
  280.         // No pass after this should make VT page requests
  281.         RHICmdList.EndUAVOverlap(SceneContext.VirtualTextureFeedbackUAV);
  282.         RHICmdList.Transition(FRHITransitionInfo(SceneContext.VirtualTextureFeedbackUAV, ERHIAccess::UAVMask, ERHIAccess::SRVMask));
  283.  
  284.         TArray<FIntRect, TInlineAllocator<4>> ViewRects;
  285.         ViewRects.AddUninitialized(Views.Num());
  286.         for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
  287.         {
  288.             ViewRects[ViewIndex] = Views[ViewIndex].ViewRect;
  289.         }
  290.         
  291.         FVirtualTextureFeedbackBufferDesc Desc;
  292.         Desc.Init2D(SceneContext.GetBufferSizeXY(), ViewRects, SceneContext.GetVirtualTextureFeedbackScale());
  293.  
  294.         SubmitVirtualTextureFeedbackBuffer(RHICmdList, SceneContext.VirtualTextureFeedback, Desc);
  295.     }
  296.  
  297.     FMemMark Mark(FMemStack::Get());
  298.     FRDGBuilder GraphBuilder(RHICmdList);
  299.  
  300.     FRDGTextureRef ViewFamilyTexture = TryCreateViewFamilyTexture(GraphBuilder, ViewFamily);
  301.     
  302.     // 解析场景
  303.     if (ViewFamily.bResolveScene)
  304.     {
  305.         if (!bGammaSpace || bRenderToSceneColor)
  306.         {
  307.             // 完成每个视图的渲染或完整的立体声缓冲区(如果启用)
  308.             {
  309.                 RDG_EVENT_SCOPE(GraphBuilder, "PostProcessing");
  310.                 SCOPE_CYCLE_COUNTER(STAT_FinishRenderViewTargetTime);
  311.  
  312.                 TArray<TRDGUniformBufferRef<FMobileSceneTextureUniformParameters>, TInlineAllocator<1, SceneRenderingAllocator>> MobileSceneTexturesPerView;
  313.                 MobileSceneTexturesPerView.SetNumZeroed(Views.Num());
  314.  
  315.                 const auto SetupMobileSceneTexturesPerView = [&]()
  316.                 {
  317.                     for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex)
  318.                     {
  319.                         EMobileSceneTextureSetupMode SetupMode = EMobileSceneTextureSetupMode::SceneColor;
  320.                         if (Views[ViewIndex].bCustomDepthStencilValid)
  321.                         {
  322.                             SetupMode |= EMobileSceneTextureSetupMode::CustomDepth;
  323.                         }
  324.  
  325.                         if (bShouldRenderVelocities)
  326.                         {
  327.                             SetupMode |= EMobileSceneTextureSetupMode::SceneVelocity;
  328.                         }
  329.  
  330.                         MobileSceneTexturesPerView[ViewIndex] = CreateMobileSceneTextureUniformBuffer(GraphBuilder, SetupMode);
  331.                     }
  332.                 };
  333.  
  334.                 SetupMobileSceneTexturesPerView();
  335.  
  336.                 FMobilePostProcessingInputs PostProcessingInputs;
  337.                 PostProcessingInputs.ViewFamilyTexture = ViewFamilyTexture;
  338.  
  339.                 // 渲染后处理效果.
  340.                 for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
  341.                 {
  342.                     RDG_EVENT_SCOPE_CONDITIONAL(GraphBuilder, Views.Num() > 1, "View%d", ViewIndex);
  343.                     PostProcessingInputs.SceneTextures = MobileSceneTexturesPerView[ViewIndex];
  344.                     AddMobilePostProcessingPasses(GraphBuilder, Views[ViewIndex], PostProcessingInputs, NumMSAASamples > 1);
  345.                 }
  346.             }
  347.         }
  348.     }
  349.  
  350.     GEngine->GetPostRenderDelegate().Broadcast();
  351.  
  352.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_SceneEnd));
  353.  
  354.     if (bShouldRenderVelocities)
  355.     {
  356.         SceneContext.SceneVelocity.SafeRelease();
  357.     }
  358.     
  359.     if (ViewFamily.bLateLatchingEnabled)
  360.     {
  361.         EndLateLatching(RHICmdList, Views[0]);
  362.     }
  363.  
  364.     RenderFinish(GraphBuilder, ViewFamilyTexture);
  365.     GraphBuilder.Execute();
  366.  
  367.     // 轮询遮挡剔除请求.
  368.     FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  369.     FRHICommandListExecutor::GetImmediateCommandList().ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  370. }

看过剖析虚幻渲染体系（04）- 延迟渲染管线篇章的同学应该都知道，移动端的场景渲染过程精简了很多很多步骤，相当于是PC端场景渲染器的一个子集。当然，为了适应移动端特有的GPU硬件架构，移动端的场景渲染也有区别于PC端的地方。后面会详细剖析。移动端场景的主要步骤和流程如下所示：

No

Yes

No

Yes

No

Yes

UpdateAllPrimitiveSceneInfos

PrepareViewRectsForRendering

InitViews

RenderSkyAtmosphereLookUpTables*

GatherAndSortLights

ComputeLightGrid

RenderShadowDepthMaps

RenderCustomDepthPass*

bDeferredShading2

RenderPrePass

RenderOcclusion

RenderSDFShadowing*

RenderHZB*

RenderAmbientOcclusion*

RenderForward

RenderDeferred

RenderVelocities*

AddMobilePostProcessingPasses*

RenderFinish

关于上面的流程图，有以下几点需要加以说明：

  • 流程图节点bDeferredShading和bDeferredShading2是同一个变量，这里区分开主要是为了防止mermaid语法绘图错误。
  • 带*的节点是有条件的，非必然执行的步骤。

UE4.26便加入了移动端的延迟渲染管线，所以上述代码中有前向渲染分支RenderForward和延迟渲染分支RenderDeferred，它们返回的都是渲染结果SceneColor。

移动端也支持了图元GPU场景、SDF阴影、AO、天空大气、虚拟纹理、遮挡剔除等渲染特性。

自UE4.26开始，渲染体系广泛地使用了RDG系统，移动端的场景渲染器也不例外。上述代码中总共声明了数个FRDGBuilder实例，用于计算光源格子，以及渲染天空大气LUT、自定义深度、速度缓冲、渲染后置事件、后处理等，它们都是相对独立的功能模块或渲染阶段。

12.3.2 RenderForward

RenderForward在移动端场景渲染器中负责前向渲染的分支，它的代码和解析如下：

  1. FRHITexture* FMobileSceneRenderer::RenderForward(FRHICommandListImmediate& RHICmdList, const TArrayView<const FViewInfo*> ViewList)
  2. {
  3.     const FViewInfo& View = *ViewList[0];
  4.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  5.                 
  6.     FRHITexture* SceneColor = nullptr;
  7.     FRHITexture* SceneColorResolve = nullptr;
  8.     FRHITexture* SceneDepth = nullptr;
  9.     ERenderTargetActions ColorTargetAction = ERenderTargetActions::Clear_Store;
  10.     EDepthStencilTargetActions DepthTargetAction = EDepthStencilTargetActions::ClearDepthStencil_DontStoreDepthStencil;
  11.  
  12.     // 是否启用移动端MSAA.
  13.     bool bMobileMSAA = NumMSAASamples > 1 && SceneContext.GetSceneColorSurface()->GetNumSamples() > 1;
  14.  
  15.     // 是否启用移动端多试图模式.
  16.     static const auto CVarMobileMultiView = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("vr.MobileMultiView"));
  17.     const bool bIsMultiViewApplication = (CVarMobileMultiView && CVarMobileMultiView->GetValueOnAnyThread() != 0);
  18.     
  19.     // gamma空间的渲染分支.
  20.     if (bGammaSpace && !bRenderToSceneColor)
  21.     {
  22.         // 如果开启MSAA, 则从SceneContext获取渲染纹理(包含场景颜色和解析纹理)
  23.         if (bMobileMSAA)
  24.         {
  25.             SceneColor = SceneContext.GetSceneColorSurface();
  26.             SceneColorResolve = ViewFamily.RenderTarget->GetRenderTargetTexture();
  27.             ColorTargetAction = ERenderTargetActions::Clear_Resolve;
  28.             RHICmdList.Transition(FRHITransitionInfo(SceneColorResolve, ERHIAccess::Unknown, ERHIAccess::RTV | ERHIAccess::ResolveDst));
  29.         }
  30.         // 非MSAA，从视图家族获取渲染纹理.
  31.         else
  32.         {
  33.             SceneColor = ViewFamily.RenderTarget->GetRenderTargetTexture();
  34.             RHICmdList.Transition(FRHITransitionInfo(SceneColor, ERHIAccess::Unknown, ERHIAccess::RTV));
  35.         }
  36.         SceneDepth = SceneContext.GetSceneDepthSurface();
  37.     }
  38.     // 线性空间或渲染到场景纹理.
  39.     else
  40.     {
  41.         SceneColor = SceneContext.GetSceneColorSurface();
  42.         if (bMobileMSAA)
  43.         {
  44.             SceneColorResolve = SceneContext.GetSceneColorTexture();
  45.             ColorTargetAction = ERenderTargetActions::Clear_Resolve;
  46.             RHICmdList.Transition(FRHITransitionInfo(SceneColorResolve, ERHIAccess::Unknown, ERHIAccess::RTV | ERHIAccess::ResolveDst));
  47.         }
  48.         else
  49.         {
  50.             SceneColorResolve = nullptr;
  51.             ColorTargetAction = ERenderTargetActions::Clear_Store;
  52.         }
  53.  
  54.         SceneDepth = SceneContext.GetSceneDepthSurface();
  55.                 
  56.         if (bRequiresMultiPass)
  57.         {    
  58.             // store targets after opaque so translucency render pass can be restarted
  59.             ColorTargetAction = ERenderTargetActions::Clear_Store;
  60.             DepthTargetAction = EDepthStencilTargetActions::ClearDepthStencil_StoreDepthStencil;
  61.         }
  62.                         
  63.         if (bKeepDepthContent)
  64.         {
  65.             // store depth if post-processing/capture needs it
  66.             DepthTargetAction = EDepthStencilTargetActions::ClearDepthStencil_StoreDepthStencil;
  67.         }
  68.     }
  69.  
  70.     // prepass的深度纹理状态.
  71.     if (bIsFullPrepassEnabled)
  72.     {
  73.         ERenderTargetActions DepthTarget = MakeRenderTargetActions(ERenderTargetLoadAction::ELoad, GetStoreAction(GetDepthActions(DepthTargetAction)));
  74.         ERenderTargetActions StencilTarget = MakeRenderTargetActions(ERenderTargetLoadAction::ELoad, GetStoreAction(GetStencilActions(DepthTargetAction)));
  75.         DepthTargetAction = MakeDepthStencilTargetActions(DepthTarget, StencilTarget);
  76.     }
  77.  
  78.     FRHITexture* ShadingRateTexture = nullptr;
  79.     
  80.     if (!View.bIsSceneCapture && !View.bIsReflectionCapture)
  81.     {
  82.         TRefCountPtr<IPooledRenderTarget> ShadingRateTarget = GVRSImageManager.GetMobileVariableRateShadingImage(ViewFamily);
  83.         if (ShadingRateTarget.IsValid())
  84.         {
  85.             ShadingRateTexture = ShadingRateTarget->GetRenderTargetItem().ShaderResourceTexture;
  86.         }
  87.     }
  88.  
  89.     // 场景颜色渲染Pass信息.
  90.     FRHIRenderPassInfo SceneColorRenderPassInfo(
  91.         SceneColor,
  92.         ColorTargetAction,
  93.         SceneColorResolve,
  94.         SceneDepth,
  95.         DepthTargetAction,
  96.         nullptr, // we never resolve scene depth on mobile
  97.         ShadingRateTexture,
  98.         VRSRB_Sum,
  99.         FExclusiveDepthStencil::DepthWrite_StencilWrite
  100.     );
  101.     SceneColorRenderPassInfo.SubpassHint = ESubpassHint::DepthReadSubpass;
  102.     if (!bIsFullPrepassEnabled)
  103.     {
  104.         SceneColorRenderPassInfo.NumOcclusionQueries = ComputeNumOcclusionQueriesToBatch();
  105.         SceneColorRenderPassInfo.bOcclusionQueries = SceneColorRenderPassInfo.NumOcclusionQueries != 0;
  106.     }
  107.     // 如果场景颜色不是多视图，但应用程序是，需要渲染为单视图的多视图给着色器.
  108.     SceneColorRenderPassInfo.MultiViewCount = View.bIsMobileMultiViewEnabled ? 2 : (bIsMultiViewApplication ? 1 : 0);
  109.  
  110.     // 开始渲染场景颜色.
  111.     RHICmdList.BeginRenderPass(SceneColorRenderPassInfo, TEXT("SceneColorRendering"));
  112.     
  113.     if (GIsEditor && !View.bIsSceneCapture)
  114.     {
  115.         DrawClearQuad(RHICmdList, Views[0].BackgroundColor);
  116.     }
  117.  
  118.     if (!bIsFullPrepassEnabled)
  119.     {
  120.         RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_MobilePrePass));
  121.         // 渲染深度pre-pass
  122.         RenderPrePass(RHICmdList);
  123.     }
  124.  
  125.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Opaque));
  126.     // 渲染BasePass: 不透明和masked物体.
  127.     RenderMobileBasePass(RHICmdList, ViewList);
  128.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  129.  
  130.     //渲染调试模式.
  131. #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
  132.     if (ViewFamily.UseDebugViewPS())
  133.     {
  134.         // Here we use the base pass depth result to get z culling for opaque and masque.
  135.         // The color needs to be cleared at this point since shader complexity renders in additive.
  136.         DrawClearQuad(RHICmdList, FLinearColor::Black);
  137.         RenderMobileDebugView(RHICmdList, ViewList);
  138.         RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  139.     }
  140. #endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
  141.  
  142.     const bool bAdrenoOcclusionMode = CVarMobileAdrenoOcclusionMode.GetValueOnRenderThread() != 0;
  143.     if (!bIsFullPrepassEnabled)
  144.     {
  145.         // 遮挡剔除
  146.         if (!bAdrenoOcclusionMode)
  147.         {
  148.             // 提交遮挡剔除
  149.             RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Occlusion));
  150.             RenderOcclusion(RHICmdList);
  151.             RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  152.         }
  153.     }
  154.  
  155.     // 后置事件, 处理插件渲染.
  156.     {
  157.         CSV_SCOPED_TIMING_STAT_EXCLUSIVE(ViewExtensionPostRenderBasePass);
  158.         QUICK_SCOPE_CYCLE_COUNTER(STAT_FMobileSceneRenderer_ViewExtensionPostRenderBasePass);
  159.         for (int32 ViewExt = 0; ViewExt < ViewFamily.ViewExtensions.Num(); ++ViewExt)
  160.         {
  161.             for (int32 ViewIndex = 0; ViewIndex < ViewFamily.Views.Num(); ++ViewIndex)
  162.             {
  163.                 ViewFamily.ViewExtensions[ViewExt]->PostRenderBasePass_RenderThread(RHICmdList, Views[ViewIndex]);
  164.             }
  165.         }
  166.     }
  167.     
  168.     // 如果需要渲染透明物体或像素投影的反射, 则需要拆分pass.
  169.     if (bRequiresMultiPass || bRequiresPixelProjectedPlanarRelfectionPass)
  170.     {
  171.         RHICmdList.EndRenderPass();
  172.     }
  173.        
  174.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Translucency));
  175.  
  176.     // 如果需要, 则重新开启透明渲染通道.
  177.     if (bRequiresMultiPass || bRequiresPixelProjectedPlanarRelfectionPass)
  178.     {
  179.         check(RHICmdList.IsOutsideRenderPass());
  180.  
  181.         // 如果当前硬件不支持读写相同的深度缓冲区，则复制场景深度.
  182.         ConditionalResolveSceneDepth(RHICmdList, View);
  183.  
  184.         if (bRequiresPixelProjectedPlanarRelfectionPass)
  185.         {
  186.             const FPlanarReflectionSceneProxy* PlanarReflectionSceneProxy = Scene ? Scene->GetForwardPassGlobalPlanarReflection() : nullptr;
  187.             RenderPixelProjectedReflection(RHICmdList, SceneContext, PlanarReflectionSceneProxy);
  188.  
  189.             FRHITransitionInfo TranslucentRenderPassTransitions[] = {
  190.             FRHITransitionInfo(SceneColor, ERHIAccess::SRVMask, ERHIAccess::RTV),
  191.             FRHITransitionInfo(SceneDepth, ERHIAccess::SRVMask, ERHIAccess::DSVWrite)
  192.             };
  193.             RHICmdList.Transition(MakeArrayView(TranslucentRenderPassTransitions, UE_ARRAY_COUNT(TranslucentRenderPassTransitions)));
  194.         }
  195.  
  196.         DepthTargetAction = EDepthStencilTargetActions::LoadDepthStencil_DontStoreDepthStencil;
  197.         FExclusiveDepthStencil::Type ExclusiveDepthStencil = FExclusiveDepthStencil::DepthRead_StencilRead;
  198.         if (bModulatedShadowsInUse)
  199.         {
  200.             ExclusiveDepthStencil = FExclusiveDepthStencil::DepthRead_StencilWrite;
  201.         }
  202.  
  203.         // 用于移动端像素投影反射的不透明网格必须将深度写入深度RT, 因为只渲染一次网格(如果质量水平低于或等于BestPerformance).
  204.         if (IsMobilePixelProjectedReflectionEnabled(View.GetShaderPlatform())
  205.             && GetMobilePixelProjectedReflectionQuality() == EMobilePixelProjectedReflectionQuality::BestPerformance)
  206.         {
  207.             ExclusiveDepthStencil = FExclusiveDepthStencil::DepthWrite_StencilWrite;
  208.         }
  209.  
  210.         if (bKeepDepthContent && !bMobileMSAA)
  211.         {
  212.             DepthTargetAction = EDepthStencilTargetActions::LoadDepthStencil_StoreDepthStencil;
  213.         }
  214.  
  215. #if PLATFORM_HOLOLENS
  216.         if (bShouldRenderDepthToTranslucency)
  217.         {
  218.             ExclusiveDepthStencil = FExclusiveDepthStencil::DepthWrite_StencilWrite;
  219.         }
  220. #endif
  221.  
  222.         // 透明物体渲染Pass.
  223.         FRHIRenderPassInfo TranslucentRenderPassInfo(
  224.             SceneColor,
  225.             SceneColorResolve ? ERenderTargetActions::Load_Resolve : ERenderTargetActions::Load_Store,
  226.             SceneColorResolve,
  227.             SceneDepth,
  228.             DepthTargetAction, 
  229.             nullptr,
  230.             ShadingRateTexture,
  231.             VRSRB_Sum,
  232.             ExclusiveDepthStencil
  233.         );
  234.         TranslucentRenderPassInfo.NumOcclusionQueries = 0;
  235.         TranslucentRenderPassInfo.bOcclusionQueries = false;
  236.         TranslucentRenderPassInfo.SubpassHint = ESubpassHint::DepthReadSubpass;
  237.         
  238.         // 开始渲染半透明物体.
  239.         RHICmdList.BeginRenderPass(TranslucentRenderPassInfo, TEXT("SceneColorTranslucencyRendering"));
  240.     }
  241.  
  242.     // 场景深度是只读的，可以获取.
  243.     RHICmdList.NextSubpass();
  244.  
  245.     if (!View.bIsPlanarReflection)
  246.     {
  247.         // 渲染贴花.
  248.         if (ViewFamily.EngineShowFlags.Decals)
  249.         {
  250.             CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderDecals);
  251.             RenderDecals(RHICmdList);
  252.         }
  253.  
  254.         // 渲染调制阴影投射.
  255.         if (ViewFamily.EngineShowFlags.DynamicShadows)
  256.         {
  257.             CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderShadowProjections);
  258.             RenderModulatedShadowProjections(RHICmdList);
  259.         }
  260.     }
  261.     
  262.     // 绘制半透明.
  263.     if (ViewFamily.EngineShowFlags.Translucency)
  264.     {
  265.         CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderTranslucency);
  266.         SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime);
  267.         
  268.         RenderTranslucency(RHICmdList, ViewList);
  269.         
  270.         FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  271.         RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  272.     }
  273.  
  274.     if (!bIsFullPrepassEnabled)
  275.     {
  276.         // Adreno遮挡剔除模式.
  277.         if (bAdrenoOcclusionMode)
  278.         {
  279.             RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Occlusion));
  280.             // flush
  281.             RHICmdList.SubmitCommandsHint();
  282.             bSubmitOffscreenRendering = false; // submit once
  283.             // Issue occlusion queries
  284.             RenderOcclusion(RHICmdList);
  285.             RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  286.         }
  287.     }
  288.  
  289.     // 在MSAA被解析前预计算色调映射(只在iOS有效)
  290.     if (!bGammaSpace)
  291.     {
  292.         PreTonemapMSAA(RHICmdList);
  293.     }
  294.  
  295.     // 结束场景颜色渲染.
  296.     RHICmdList.EndRenderPass();
  297.  
  298.     // 优化返回场景颜色的解析纹理(开启了MSAA才有).
  299.     return SceneColorResolve ? SceneColorResolve : SceneColor;
  300. }

移动端前向渲染主要步骤跟PC端类似，依次渲染PrePass、BasePass、特殊渲染（贴花、AO、遮挡剔除等）、半透明物体。它们的流程图如下：

DrawClearQuad*

RenderPrePass*

RenderMobileBasePass

RenderOcclusion*

RenderDecals*

RenderModulatedShadowProjections*

RenderTranslucency*

PreTonemapMSAA*

其中遮挡剔除和GPU厂商相关，比如高通Adreno系列GPU芯片要求在Flush渲染指令和Switch FBO之间：

Render Opaque -> Render Translucent -> Flush -> Render Queries -> Switch FBO

那么UE也遵循了Adreno系列芯片的特殊要求，对其的遮挡剔除做了特殊的处理。

Adreno系列芯片支持TBDR架构的Bin和普通的Direct两种混合模式的渲染，会在遮挡查询时自动切换到Direct模式，以降低遮挡查询的开销。如果不在Flush渲染指令和Switch FBO之间提交查询，会卡住整个渲染管线，引发渲染性能下降。

MSAA由于天然硬件支持且效果和效率达到很好的平衡，是UE在移动端前向渲染的首选抗锯齿。因此，上述代码中出现了不少处理MSAA的逻辑，包含颜色和深度纹理及其资源状态。如果开启了MSAA，默认情况下是在RHICmdList.EndRenderPass()解析场景颜色（同时将芯片分块上的数据写回到系统显存中），由此获得抗锯齿的纹理。移动端的MSAA默认不开启，但可在以下界面中设置：

前向渲染支持Gamma空间和HDR（线性空间）两种颜色空间模式。如果是线性空间，则渲染后期需要色调映射等步骤。默认是HDR，可在项目配置中更改：

上述代码的bRequiresMultiPass标明了是否需要专用的渲染Pass绘制半透明物体，决定它的值由以下代码完成：

  1. // Engine\Source\Runtime\Renderer\Private\MobileShadingRenderer.cpp
  2.  
  3. bool FMobileSceneRenderer::RequiresMultiPass(FRHICommandListImmediate& RHICmdList, const FViewInfo& View) const
  4. {
  5.     // Vulkan uses subpasses
  6.     if (IsVulkanPlatform(ShaderPlatform))
  7.     {
  8.         return false;
  9.     }
  10.  
  11.     // All iOS support frame_buffer_fetch
  12.     if (IsMetalMobilePlatform(ShaderPlatform))
  13.     {
  14.         return false;
  15.     }
  16.  
  17.     if (IsMobileDeferredShadingEnabled(ShaderPlatform))
  18.     {
  19.         // TODO: add GL support
  20.         return true;
  21.     }
  22.     
  23.     // Some Androids support frame_buffer_fetch
  24.     if (IsAndroidOpenGLESPlatform(ShaderPlatform) && (GSupportsShaderFramebufferFetch || GSupportsShaderDepthStencilFetch))
  25.     {
  26.         return false;
  27.     }
  28.         
  29.     // Always render reflection capture in single pass
  30.     if (View.bIsPlanarReflection || View.bIsSceneCapture)
  31.     {
  32.         return false;
  33.     }
  34.  
  35.     // Always render LDR in single pass
  36.     if (!IsMobileHDR())
  37.     {
  38.         return false;
  39.     }
  40.  
  41.     // MSAA depth can't be sampled or resolved, unless we are on PC (no vulkan)
  42.     if (NumMSAASamples > 1 && !IsSimulatedPlatform(ShaderPlatform))
  43.     {
  44.         return false;
  45.     }
  46.  
  47.     return true;
  48. }

与之类似但意义不同的是bIsMultiViewApplication和bIsMobileMultiViewEnabled标记，标明是否开启多视图渲染以及多视图的个数。只用于VR，由控制台变量vr.MobileMultiView及图形API等因素决定。MultiView用于XR，用于优化渲染两次的情形，它存在Basic和Advanced两种模式：

用于优化VR等渲染的MultiView对比图。上：未采用MultiView模式的渲染，两个眼睛各自提交绘制指令；中：基础MultiView模式，复用提交指令，在GPU层复制多一份Command List；下：高级MultiView模式，可以复用DC、Command List、几何信息。

bKeepDepthContent标明是否要保留深度内容，决定它的代码：

  1. bKeepDepthContent = 
  2.     bRequiresMultiPass || 
  3.     bForceDepthResolve ||
  4.     bRequiresPixelProjectedPlanarRelfectionPass ||
  5.     bSeparateTranslucencyActive ||
  6.     Views[0].bIsReflectionCapture ||
  7.     (bDeferredShading && bPostProcessUsesSceneDepth) ||
  8.     bShouldRenderVelocities ||
  9.     bIsFullPrepassEnabled;
  10.  
  11. // 带MSAA的深度从不保留.
  12. bKeepDepthContent = (NumMSAASamples > 1 ? false : bKeepDepthContent);

上述代码还揭示了平面反射在移动端的一种特殊渲染方式：Pixel Projected Reflection（PPR）。它的实现原理类似于SSR，但需要的数据更少，只需要场景颜色、深度缓冲和反射区域。它的核心步骤：

  • 计算场景颜色的所有像素在反射平面的镜像位置。
  • 测试像素的反射是否在反射区域内。
    • 光线投射到镜像像素位置。
    • 测试交点是否在反射区域内。
  • 如果找到相交点，计算像素在屏幕的镜像位置。
  • 在交点处写入镜像像素的颜色。

  • 如果反射区域内的交点被其它物体遮挡，则剔除此位置的反射。

PPR效果一览。

PPR可以在工程配置中设置：

12.3.3 RenderDeferred

UE在4.26在移动端渲染管线增加了延迟渲染分支，并在4.27做了改进和优化。移动端是否开启延迟着色的特性由以下代码决定：

  1. // Engine\Source\Runtime\RenderCore\Private\RenderUtils.cpp
  2.  
  3. bool IsMobileDeferredShadingEnabled(const FStaticShaderPlatform Platform)
  4. {
  5.     // 禁用OpenGL的延迟着色.
  6.     if (IsOpenGLPlatform(Platform))
  7.     {
  8.         // needs MRT framebuffer fetch or PLS
  9.         return false;
  10.     }
  11.     
  12.     // 控制台变量"r.Mobile.ShadingPath"要为1.
  13.     static auto* MobileShadingPathCvar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.Mobile.ShadingPath"));
  14.     return MobileShadingPathCvar->GetValueOnAnyThread() == 1;
  15. }

简单地说就是非OpenGL图形API且控制台变量r.Mobile.ShadingPath设为1。

r.Mobile.ShadingPath不可在编辑器动态设置值，只能在项目工程根目录/Config/DefaultEngine.ini增加以下字段来开启：

[/Script/Engine.RendererSettings]

r.Mobile.ShadingPath=1

添加以上字段后，重启UE编辑器，等待shader编译完成即可预览移动端延迟着色效果。

以下是延迟渲染分支FMobileSceneRenderer::RenderDeferred的代码和解析：

  1. FRHITexture* FMobileSceneRenderer::RenderDeferred(FRHICommandListImmediate& RHICmdList, const TArrayView<const FViewInfo*> ViewList, const FSortedLightSetSceneInfo& SortedLightSet)
  2. {
  3.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  4.     
  5.     // 准备GBuffer.
  6.     FRHITexture* ColorTargets[4] = {
  7.         SceneContext.GetSceneColorSurface(),
  8.         SceneContext.GetGBufferATexture().GetReference(),
  9.         SceneContext.GetGBufferBTexture().GetReference(),
  10.         SceneContext.GetGBufferCTexture().GetReference()
  11.     };
  12.  
  13.     // RHI是否需要将GBuffer存储到GPU的系统内存中，并在单独的渲染通道中进行着色.
  14.     ERenderTargetActions GBufferAction = bRequiresMultiPass ? ERenderTargetActions::Clear_Store : ERenderTargetActions::Clear_DontStore;
  15.     EDepthStencilTargetActions DepthAction = bKeepDepthContent ? EDepthStencilTargetActions::ClearDepthStencil_StoreDepthStencil : EDepthStencilTargetActions::ClearDepthStencil_DontStoreDepthStencil;
  16.     
  17.     // RT的load/store动作.
  18.     ERenderTargetActions ColorTargetsAction[4] = {ERenderTargetActions::Clear_Store, GBufferAction, GBufferAction, GBufferAction};
  19.     if (bIsFullPrepassEnabled)
  20.     {
  21.         ERenderTargetActions DepthTarget = MakeRenderTargetActions(ERenderTargetLoadAction::ELoad, GetStoreAction(GetDepthActions(DepthAction)));
  22.         ERenderTargetActions StencilTarget = MakeRenderTargetActions(ERenderTargetLoadAction::ELoad, GetStoreAction(GetStencilActions(DepthAction)));
  23.         DepthAction = MakeDepthStencilTargetActions(DepthTarget, StencilTarget);
  24.     }
  25.     
  26.     FRHIRenderPassInfo BasePassInfo = FRHIRenderPassInfo();
  27.     int32 ColorTargetIndex = 0;
  28.     for (; ColorTargetIndex < UE_ARRAY_COUNT(ColorTargets); ++ColorTargetIndex)
  29.     {
  30.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].RenderTarget = ColorTargets[ColorTargetIndex];
  31.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].ResolveTarget = nullptr;
  32.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].ArraySlice = -1;
  33.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].MipIndex = 0;
  34.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].Action = ColorTargetsAction[ColorTargetIndex];
  35.     }
  36.     
  37.     if (MobileRequiresSceneDepthAux(ShaderPlatform))
  38.     {
  39.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].RenderTarget = SceneContext.SceneDepthAux->GetRenderTargetItem().ShaderResourceTexture.GetReference();
  40.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].ResolveTarget = nullptr;
  41.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].ArraySlice = -1;
  42.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].MipIndex = 0;
  43.         BasePassInfo.ColorRenderTargets[ColorTargetIndex].Action = GBufferAction;
  44.         ColorTargetIndex++;
  45.     }
  46.  
  47.     BasePassInfo.DepthStencilRenderTarget.DepthStencilTarget = SceneContext.GetSceneDepthSurface();
  48.     BasePassInfo.DepthStencilRenderTarget.ResolveTarget = nullptr;
  49.     BasePassInfo.DepthStencilRenderTarget.Action = DepthAction;
  50.     BasePassInfo.DepthStencilRenderTarget.ExclusiveDepthStencil = FExclusiveDepthStencil::DepthWrite_StencilWrite;
  51.         
  52.     BasePassInfo.SubpassHint = ESubpassHint::DeferredShadingSubpass;
  53.     if (!bIsFullPrepassEnabled)
  54.     {
  55.         BasePassInfo.NumOcclusionQueries = ComputeNumOcclusionQueriesToBatch();
  56.         BasePassInfo.bOcclusionQueries = BasePassInfo.NumOcclusionQueries != 0;
  57.     }
  58.     BasePassInfo.ShadingRateTexture = nullptr;
  59.     BasePassInfo.bIsMSAA = false;
  60.     BasePassInfo.MultiViewCount = 0;
  61.  
  62.     RHICmdList.BeginRenderPass(BasePassInfo, TEXT("BasePassRendering"));
  63.     
  64.     if (GIsEditor && !Views[0].bIsSceneCapture)
  65.     {
  66.         DrawClearQuad(RHICmdList, Views[0].BackgroundColor);
  67.     }
  68.  
  69.     // 深度PrePass
  70.     if (!bIsFullPrepassEnabled)
  71.     {
  72.         RHICmdList.SetCurrentStat(GET_STATID(STAT_CLM_MobilePrePass));
  73.         // Depth pre-pass
  74.         RenderPrePass(RHICmdList);
  75.     }
  76.  
  77.     // BasePass: 不透明和镂空物体.
  78.     RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Opaque));
  79.     RenderMobileBasePass(RHICmdList, ViewList);
  80.     RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  81.  
  82.     // 遮挡剔除.
  83.     if (!bIsFullPrepassEnabled)
  84.     {
  85.         // Issue occlusion queries
  86.         RHICmdList.SetCurrentStat(GET_STATID(STAT_CLMM_Occlusion));
  87.         RenderOcclusion(RHICmdList);
  88.         RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  89.     }
  90.  
  91.     // 非多Pass模式
  92.     if (!bRequiresMultiPass)
  93.     {
  94.         // 下个子Pass: SSceneColor + GBuffer写入, SceneDepth只读.
  95.         RHICmdList.NextSubpass();
  96.         
  97.         // 渲染贴花.
  98.         if (ViewFamily.EngineShowFlags.Decals)
  99.         {
  100.             CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderDecals);
  101.             RenderDecals(RHICmdList);
  102.         }
  103.  
  104.         // 下个子Pass: SceneColor写入, SceneDepth只读
  105.         RHICmdList.NextSubpass();
  106.         
  107.         // 延迟光照着色.
  108.         MobileDeferredShadingPass(RHICmdList, *Scene, ViewList, SortedLightSet);
  109.         
  110.         // 绘制半透明.
  111.         if (ViewFamily.EngineShowFlags.Translucency)
  112.         {
  113.             CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderTranslucency);
  114.             SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime);
  115.             RenderTranslucency(RHICmdList, ViewList);
  116.             FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  117.             RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  118.         }
  119.         
  120.         // 结束渲染Pass.
  121.         RHICmdList.EndRenderPass();
  122.     }
  123.     // 多Pass模式(PC设备模拟的移动端).
  124.     else
  125.     {
  126.         // 结束子pass.
  127.         RHICmdList.NextSubpass();
  128.         RHICmdList.NextSubpass();
  129.         RHICmdList.EndRenderPass();
  130.         
  131.         // SceneColor + GBuffer write, SceneDepth is read only
  132.         {
  133.             for (int32 Index = 0; Index < UE_ARRAY_COUNT(ColorTargets); ++Index)
  134.             {
  135.                 BasePassInfo.ColorRenderTargets[Index].Action = ERenderTargetActions::Load_Store;
  136.             }
  137.             BasePassInfo.DepthStencilRenderTarget.Action = EDepthStencilTargetActions::LoadDepthStencil_StoreDepthStencil;
  138.             BasePassInfo.DepthStencilRenderTarget.ExclusiveDepthStencil = FExclusiveDepthStencil::DepthRead_StencilRead;
  139.             BasePassInfo.SubpassHint = ESubpassHint::None;
  140.             BasePassInfo.NumOcclusionQueries = 0;
  141.             BasePassInfo.bOcclusionQueries = false;
  142.             
  143.             RHICmdList.BeginRenderPass(BasePassInfo, TEXT("AfterBasePass"));
  144.             
  145.             // 渲染贴花.
  146.             if (ViewFamily.EngineShowFlags.Decals)
  147.             {
  148.                 CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderDecals);
  149.                 RenderDecals(RHICmdList);
  150.             }
  151.             
  152.             RHICmdList.EndRenderPass();
  153.         }
  154.  
  155.         // SceneColor write, SceneDepth is read only
  156.         {
  157.             FRHIRenderPassInfo ShadingPassInfo(
  158.                 SceneContext.GetSceneColorSurface(),
  159.                 ERenderTargetActions::Load_Store,
  160.                 nullptr,
  161.                 SceneContext.GetSceneDepthSurface(),
  162.                 EDepthStencilTargetActions::LoadDepthStencil_StoreDepthStencil, 
  163.                 nullptr,
  164.                 nullptr,
  165.                 VRSRB_Passthrough,
  166.                 FExclusiveDepthStencil::DepthRead_StencilWrite
  167.             );
  168.             ShadingPassInfo.NumOcclusionQueries = 0;
  169.             ShadingPassInfo.bOcclusionQueries = false;
  170.             
  171.             RHICmdList.BeginRenderPass(ShadingPassInfo, TEXT("MobileShadingPass"));
  172.             
  173.             // 延迟光照着色.
  174.             MobileDeferredShadingPass(RHICmdList, *Scene, ViewList, SortedLightSet);
  175.             
  176.             // 绘制半透明.
  177.             if (ViewFamily.EngineShowFlags.Translucency)
  178.             {
  179.                 CSV_SCOPED_TIMING_STAT_EXCLUSIVE(RenderTranslucency);
  180.                 SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime);
  181.                 RenderTranslucency(RHICmdList, ViewList);
  182.                 FRHICommandListExecutor::GetImmediateCommandList().PollOcclusionQueries();
  183.                 RHICmdList.ImmediateFlush(EImmediateFlushType::DispatchToRHIThread);
  184.             }
  185.  
  186.             RHICmdList.EndRenderPass();
  187.         }
  188.     }
  189.  
  190.     return ColorTargets[0];
  191. }

由上面可知，移动端的延迟渲染管线和PC比较类似，先渲染BasePass，获得GBuffer几何信息，再执行光照计算。它们的流程图如下：

DrawClearQuad*

RenderPrePass*

RenderMobileBasePass

RenderOcclusion*

RenderDecals*

MobileDeferredShadingPass*

RenderTranslucency*

PreTonemapMSAA*

当然，也有和PC不一样的地方，最明显的是移动端使用了适配TB(D)R架构的SubPass渲染，使得移动端在渲染PrePass深度、BasePass、光照计算时，让场景颜色、深度、GBuffer等信息一直在On-Chip的缓冲区中，提升渲染效率，降低设备能耗。

12.3.3.1 MobileDeferredShadingPass

延迟渲染光照的过程由MobileDeferredShadingPass担当：

  1. void MobileDeferredShadingPass(
  2.     FRHICommandListImmediate& RHICmdList, 
  3.     const FScene& Scene, 
  4.     const TArrayView<const FViewInfo*> PassViews, 
  5.     const FSortedLightSetSceneInfo &SortedLightSet)
  6. {
  7.     SCOPED_DRAW_EVENT(RHICmdList, MobileDeferredShading);
  8.  
  9.     const FViewInfo& View0 = *PassViews[0];
  10.  
  11.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  12.     // 创建Uniform Buffer.
  13.     FUniformBufferRHIRef PassUniformBuffer = CreateMobileSceneTextureUniformBuffer(RHICmdList);
  14.     FUniformBufferStaticBindings GlobalUniformBuffers(PassUniformBuffer);
  15.     SCOPED_UNIFORM_BUFFER_GLOBAL_BINDINGS(RHICmdList, GlobalUniformBuffers);
  16.     // 设置视口.
  17.     RHICmdList.SetViewport(View0.ViewRect.Min.X, View0.ViewRect.Min.Y, 0.0f, View0.ViewRect.Max.X, View0.ViewRect.Max.Y, 1.0f);
  18.  
  19.     // 光照的默认材质.
  20.     FCachedLightMaterial DefaultMaterial;
  21.     DefaultMaterial.MaterialProxy = UMaterial::GetDefaultMaterial(MD_LightFunction)->GetRenderProxy();
  22.     DefaultMaterial.Material = DefaultMaterial.MaterialProxy->GetMaterialNoFallback(ERHIFeatureLevel::ES3_1);
  23.     check(DefaultMaterial.Material);
  24.  
  25.     // 绘制平行光.
  26.     RenderDirectLight(RHICmdList, Scene, View0, DefaultMaterial);
  27.  
  28.     if (GMobileUseClusteredDeferredShading == 0)
  29.     {
  30.         // 渲染非分簇的简单光源.
  31.         RenderSimpleLights(RHICmdList, Scene, PassViews, SortedLightSet, DefaultMaterial);
  32.     }
  33.  
  34.     // 渲染非分簇的局部光源.
  35.     int32 NumLights = SortedLightSet.SortedLights.Num();
  36.     int32 StandardDeferredStart = SortedLightSet.SimpleLightsEnd;
  37.     if (GMobileUseClusteredDeferredShading != 0)
  38.     {
  39.         StandardDeferredStart = SortedLightSet.ClusteredSupportedEnd;
  40.     }
  41.  
  42.     // 渲染局部光源.
  43.     for (int32 LightIdx = StandardDeferredStart; LightIdx < NumLights; ++LightIdx)
  44.     {
  45.         const FSortedLightSceneInfo& SortedLight = SortedLightSet.SortedLights[LightIdx];
  46.         const FLightSceneInfo& LightSceneInfo = *SortedLight.LightSceneInfo;
  47.         RenderLocalLight(RHICmdList, Scene, View0, LightSceneInfo, DefaultMaterial);
  48.     }
  49. }

下面继续分析渲染不同类型光源的接口：

  1. // Engine\Source\Runtime\Renderer\Private\MobileDeferredShadingPass.cpp
  2.  
  3. // 渲染平行光
  4. static void RenderDirectLight(FRHICommandListImmediate& RHICmdList, const FScene& Scene, const FViewInfo& View, const FCachedLightMaterial& DefaultLightMaterial)
  5. {
  6.     FSceneRenderTargets& SceneContext = FSceneRenderTargets::Get(RHICmdList);
  7.  
  8.     // 查找第一个平行光.
  9.     FLightSceneInfo* DirectionalLight = nullptr;
  10.     for (int32 ChannelIdx = 0; ChannelIdx < UE_ARRAY_COUNT(Scene.MobileDirectionalLights) && !DirectionalLight; ChannelIdx++)
  11.     {
  12.         DirectionalLight = Scene.MobileDirectionalLights[ChannelIdx];
  13.     }
  14.  
  15.     // 渲染状态.
  16.     FGraphicsPipelineStateInitializer GraphicsPSOInit;
  17.     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  18.     // 增加自发光到SceneColor.
  19.     GraphicsPSOInit.BlendState = TStaticBlendState<CW_RGB, BO_Add, BF_One, BF_One>::GetRHI();
  20.     GraphicsPSOInit.RasterizerState = TStaticRasterizerState<>::GetRHI();
  21.     // 只绘制默认光照模型(MSM_DefaultLit)的像素.
  22.     uint8 StencilRef = GET_STENCIL_MOBILE_SM_MASK(MSM_DefaultLit);
  23.     GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<
  24.                                         false, CF_Always,
  25.                                         true, CF_Equal, SO_Keep, SO_Keep, SO_Keep,        
  26.                                         false, CF_Always, SO_Keep, SO_Keep, SO_Keep,
  27.                                         GET_STENCIL_MOBILE_SM_MASK(0x7), 0x00>::GetRHI(); // 4 bits for shading models
  28.     
  29.     // 处理VS.
  30.     TShaderMapRef<FPostProcessVS> VertexShader(View.ShaderMap);
  31.     
  32.     const FMaterialRenderProxy* LightFunctionMaterialProxy = nullptr;
  33.     if (View.Family->EngineShowFlags.LightFunctions && DirectionalLight)
  34.     {
  35.         LightFunctionMaterialProxy = DirectionalLight->Proxy->GetLightFunctionMaterial();
  36.     }
  37.     FMobileDirectLightFunctionPS::FPermutationDomain PermutationVector = FMobileDirectLightFunctionPS::BuildPermutationVector(View, DirectionalLight != nullptr);
  38.     FCachedLightMaterial LightMaterial;
  39.     TShaderRef<FMobileDirectLightFunctionPS> PixelShader;
  40.     GetLightMaterial(DefaultLightMaterial, LightFunctionMaterialProxy, PermutationVector.ToDimensionValueId(), LightMaterial, PixelShader);
  41.     
  42.     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GFilterVertexDeclaration.VertexDeclarationRHI;
  43.     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  44.     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  45.     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  46.     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  47.  
  48.     // 处理PS.
  49.     FMobileDirectLightFunctionPS::FParameters PassParameters;
  50.     PassParameters.Forward = View.ForwardLightingResources->ForwardLightDataUniformBuffer;
  51.     PassParameters.MobileDirectionalLight = Scene.UniformBuffers.MobileDirectionalLightUniformBuffers[1];
  52.     PassParameters.ReflectionCaptureData = Scene.UniformBuffers.ReflectionCaptureUniformBuffer;
  53.     FReflectionUniformParameters ReflectionUniformParameters;
  54.     SetupReflectionUniformParameters(View, ReflectionUniformParameters);
  55.     PassParameters.ReflectionsParameters = CreateUniformBufferImmediate(ReflectionUniformParameters, UniformBuffer_SingleDraw);
  56.     PassParameters.LightFunctionParameters = FVector4(1.0f, 1.0f, 0.0f, 0.0f);
  57.     if (DirectionalLight)
  58.     {
  59.         const bool bUseMovableLight = DirectionalLight && !DirectionalLight->Proxy->HasStaticShadowing();
  60.         PassParameters.LightFunctionParameters2 = FVector(DirectionalLight->Proxy->GetLightFunctionFadeDistance(), DirectionalLight->Proxy->GetLightFunctionDisabledBrightness(), bUseMovableLight ? 1.0f : 0.0f);
  61.         const FVector Scale = DirectionalLight->Proxy->GetLightFunctionScale();
  62.         // Switch x and z so that z of the user specified scale affects the distance along the light direction
  63.         const FVector InverseScale = FVector(1.f / Scale.Z, 1.f / Scale.Y, 1.f / Scale.X);
  64.         PassParameters.WorldToLight = DirectionalLight->Proxy->GetWorldToLight() * FScaleMatrix(FVector(InverseScale));
  65.     }
  66.     FMobileDirectLightFunctionPS::SetParameters(RHICmdList, PixelShader, View, LightMaterial.MaterialProxy, *LightMaterial.Material, PassParameters);
  67.     
  68.     RHICmdList.SetStencilRef(StencilRef);
  69.             
  70.     const FIntPoint TargetSize = SceneContext.GetBufferSizeXY();
  71.     
  72.     // 用全屏幕的矩形绘制.
  73.     DrawRectangle(
  74.         RHICmdList, 
  75.         0, 0, 
  76.         View.ViewRect.Width(), View.ViewRect.Height(), 
  77.         View.ViewRect.Min.X, View.ViewRect.Min.Y, 
  78.         View.ViewRect.Width(), View.ViewRect.Height(),
  79.         FIntPoint(View.ViewRect.Width(), View.ViewRect.Height()), 
  80.         TargetSize, 
  81.         VertexShader);
  82. }
  83.  
  84. // 渲染非分簇模式的简单光源.
  85. static void RenderSimpleLights(
  86.     FRHICommandListImmediate& RHICmdList, 
  87.     const FScene& Scene, 
  88.     const TArrayView<const FViewInfo*> PassViews, 
  89.     const FSortedLightSetSceneInfo &SortedLightSet, 
  90.     const FCachedLightMaterial& DefaultMaterial)
  91. {
  92.     const FSimpleLightArray& SimpleLights = SortedLightSet.SimpleLights;
  93.     const int32 NumViews = PassViews.Num();
  94.     const FViewInfo& View0 = *PassViews[0];
  95.  
  96.     // 处理VS.
  97.     TShaderMapRef<TDeferredLightVS<true>> VertexShader(View0.ShaderMap);
  98.     TShaderRef<FMobileRadialLightFunctionPS> PixelShaders[2];
  99.     {
  100.         const FMaterialShaderMap* MaterialShaderMap = DefaultMaterial.Material->GetRenderingThreadShaderMap();
  101.         FMobileRadialLightFunctionPS::FPermutationDomain PermutationVector;
  102.         PermutationVector.Set<FMobileRadialLightFunctionPS::FSpotLightDim>(false);
  103.         PermutationVector.Set<FMobileRadialLightFunctionPS::FIESProfileDim>(false);
  104.         PermutationVector.Set<FMobileRadialLightFunctionPS::FInverseSquaredDim>(false);
  105.         PixelShaders[0] = MaterialShaderMap->GetShader<FMobileRadialLightFunctionPS>(PermutationVector);
  106.         PermutationVector.Set<FMobileRadialLightFunctionPS::FInverseSquaredDim>(true);
  107.         PixelShaders[1] = MaterialShaderMap->GetShader<FMobileRadialLightFunctionPS>(PermutationVector);
  108.     }
  109.  
  110.     // 设置PSO.
  111.     FGraphicsPipelineStateInitializer GraphicsPSOLight[2];
  112.     {
  113.         SetupSimpleLightPSO(RHICmdList, View0, VertexShader, PixelShaders[0], GraphicsPSOLight[0]);
  114.         SetupSimpleLightPSO(RHICmdList, View0, VertexShader, PixelShaders[1], GraphicsPSOLight[1]);
  115.     }
  116.     
  117.     // 设置模板缓冲.
  118.     FGraphicsPipelineStateInitializer GraphicsPSOLightMask;
  119.     {
  120.         RHICmdList.ApplyCachedRenderTargets(GraphicsPSOLightMask);
  121.         GraphicsPSOLightMask.PrimitiveType = PT_TriangleList;
  122.         GraphicsPSOLightMask.BlendState = TStaticBlendStateWriteMask<CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE>::GetRHI();
  123.         GraphicsPSOLightMask.RasterizerState = View0.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI();
  124.         // set stencil to 1 where depth test fails
  125.         GraphicsPSOLightMask.DepthStencilState = TStaticDepthStencilState<
  126.             false, CF_DepthNearOrEqual,
  127.             true, CF_Always, SO_Keep, SO_Replace, SO_Keep,        
  128.             false, CF_Always, SO_Keep, SO_Keep, SO_Keep,
  129.             0x00, STENCIL_SANDBOX_MASK>::GetRHI();
  130.         GraphicsPSOLightMask.BoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
  131.         GraphicsPSOLightMask.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  132.         GraphicsPSOLightMask.BoundShaderState.PixelShaderRHI = nullptr;
  133.     }
  134.     
  135.     // 遍历所有简单光源列表, 执行着色计算.
  136.     for (int32 LightIndex = 0; LightIndex < SimpleLights.InstanceData.Num(); LightIndex++)
  137.     {
  138.         const FSimpleLightEntry& SimpleLight = SimpleLights.InstanceData[LightIndex];
  139.         for (int32 ViewIndex = 0; ViewIndex < NumViews; ViewIndex++)
  140.         {
  141.             const FViewInfo& View = *PassViews[ViewIndex];
  142.             const FSimpleLightPerViewEntry& SimpleLightPerViewData = SimpleLights.GetViewDependentData(LightIndex, ViewIndex, NumViews);
  143.             const FSphere LightBounds(SimpleLightPerViewData.Position, SimpleLight.Radius);
  144.             
  145.             if (NumViews > 1)
  146.             {
  147.                 // set viewports only we we have more than one 
  148.                 // otherwise it is set at the start of the pass
  149.                 RHICmdList.SetViewport(View.ViewRect.Min.X, View.ViewRect.Min.Y, 0.0f, View.ViewRect.Max.X, View.ViewRect.Max.Y, 1.0f);
  150.             }
  151.  
  152.             // 渲染光源遮罩.
  153.             SetGraphicsPipelineState(RHICmdList, GraphicsPSOLightMask);
  154.             VertexShader->SetSimpleLightParameters(RHICmdList, View, LightBounds);
  155.             RHICmdList.SetStencilRef(1);
  156.             StencilingGeometry::DrawSphere(RHICmdList);
  157.                         
  158.             // 渲染光源.
  159.             FMobileRadialLightFunctionPS::FParameters PassParameters;
  160.             FDeferredLightUniformStruct DeferredLightUniformsValue;
  161.             SetupSimpleDeferredLightParameters(SimpleLight, SimpleLightPerViewData, DeferredLightUniformsValue);
  162.             PassParameters.DeferredLightUniforms = TUniformBufferRef<FDeferredLightUniformStruct>::CreateUniformBufferImmediate(DeferredLightUniformsValue, EUniformBufferUsage::UniformBuffer_SingleFrame);
  163.             PassParameters.IESTexture = GWhiteTexture->TextureRHI;
  164.             PassParameters.IESTextureSampler = GWhiteTexture->SamplerStateRHI;
  165.             if (SimpleLight.Exponent == 0)
  166.             {
  167.                 SetGraphicsPipelineState(RHICmdList, GraphicsPSOLight[1]);
  168.                 FMobileRadialLightFunctionPS::SetParameters(RHICmdList, PixelShaders[1], View, DefaultMaterial.MaterialProxy, *DefaultMaterial.Material, PassParameters);
  169.             }
  170.             else
  171.             {
  172.                 SetGraphicsPipelineState(RHICmdList, GraphicsPSOLight[0]);
  173.                 FMobileRadialLightFunctionPS::SetParameters(RHICmdList, PixelShaders[0], View, DefaultMaterial.MaterialProxy, *DefaultMaterial.Material, PassParameters);
  174.             }
  175.             VertexShader->SetSimpleLightParameters(RHICmdList, View, LightBounds);
  176.             
  177.             // 只绘制默认光照模型(MSM_DefaultLit)的像素.
  178.             uint8 StencilRef = GET_STENCIL_MOBILE_SM_MASK(MSM_DefaultLit);
  179.             RHICmdList.SetStencilRef(StencilRef);
  180.  
  181.             // 用球体渲染光源(点光源和聚光灯)， 以快速剔除光源影响之外的像素.
  182.             StencilingGeometry::DrawSphere(RHICmdList);
  183.         }
  184.     }
  185. }
  186.  
  187. // 渲染局部光源.
  188. static void RenderLocalLight(
  189.     FRHICommandListImmediate& RHICmdList, 
  190.     const FScene& Scene, 
  191.     const FViewInfo& View, 
  192.     const FLightSceneInfo& LightSceneInfo, 
  193.     const FCachedLightMaterial& DefaultLightMaterial)
  194. {
  195.     if (!LightSceneInfo.ShouldRenderLight(View))
  196.     {
  197.         return;
  198.     }
  199.  
  200.     // 忽略非局部光源(光源和聚光灯之外的光源).
  201.     const uint8 LightType = LightSceneInfo.Proxy->GetLightType();
  202.     const bool bIsSpotLight = LightType == LightType_Spot;
  203.     const bool bIsPointLight = LightType == LightType_Point;
  204.     if (!bIsSpotLight && !bIsPointLight)
  205.     {
  206.         return;
  207.     }
  208.     
  209.     // 绘制光源模板.
  210.     if (GMobileUseLightStencilCulling != 0)
  211.     {
  212.         RenderLocalLight_StencilMask(RHICmdList, Scene, View, LightSceneInfo);
  213.     }
  214.  
  215.     // 处理IES光照.
  216.     bool bUseIESTexture = false;
  217.     FTexture* IESTextureResource = GWhiteTexture;
  218.     if (View.Family->EngineShowFlags.TexturedLightProfiles && LightSceneInfo.Proxy->GetIESTextureResource())
  219.     {
  220.         IESTextureResource = LightSceneInfo.Proxy->GetIESTextureResource();
  221.         bUseIESTexture = true;
  222.     }
  223.         
  224.     FGraphicsPipelineStateInitializer GraphicsPSOInit;
  225.     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  226.     GraphicsPSOInit.BlendState = TStaticBlendState<CW_RGBA, BO_Add, BF_One, BF_One, BO_Add, BF_One, BF_One>::GetRHI();
  227.     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  228.     const FSphere LightBounds = LightSceneInfo.Proxy->GetBoundingSphere();
  229.     
  230.     // 设置光源光栅化和深度状态.
  231.     if (GMobileUseLightStencilCulling != 0)
  232.     {
  233.         SetLocalLightRasterizerAndDepthState_StencilMask(GraphicsPSOInit, View);
  234.     }
  235.     else
  236.     {
  237.         SetLocalLightRasterizerAndDepthState(GraphicsPSOInit, View, LightBounds);
  238.     }
  239.  
  240.     // 设置VS
  241.     TShaderMapRef<TDeferredLightVS<true>> VertexShader(View.ShaderMap);
  242.         
  243.     const FMaterialRenderProxy* LightFunctionMaterialProxy = nullptr;
  244.     if (View.Family->EngineShowFlags.LightFunctions)
  245.     {
  246.         LightFunctionMaterialProxy = LightSceneInfo.Proxy->GetLightFunctionMaterial();
  247.     }
  248.     FMobileRadialLightFunctionPS::FPermutationDomain PermutationVector;
  249.     PermutationVector.Set<FMobileRadialLightFunctionPS::FSpotLightDim>(bIsSpotLight);
  250.     PermutationVector.Set<FMobileRadialLightFunctionPS::FInverseSquaredDim>(LightSceneInfo.Proxy->IsInverseSquared());
  251.     PermutationVector.Set<FMobileRadialLightFunctionPS::FIESProfileDim>(bUseIESTexture);
  252.     FCachedLightMaterial LightMaterial;
  253.     TShaderRef<FMobileRadialLightFunctionPS> PixelShader;
  254.     GetLightMaterial(DefaultLightMaterial, LightFunctionMaterialProxy, PermutationVector.ToDimensionValueId(), LightMaterial, PixelShader);
  255.             
  256.     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
  257.     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  258.     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = PixelShader.GetPixelShader();
  259.     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  260.  
  261.     VertexShader->SetParameters(RHICmdList, View, &LightSceneInfo);
  262.  
  263.     // 设置PS.
  264.     FMobileRadialLightFunctionPS::FParameters PassParameters;
  265.     PassParameters.DeferredLightUniforms = TUniformBufferRef<FDeferredLightUniformStruct>::CreateUniformBufferImmediate(GetDeferredLightParameters(View, LightSceneInfo), EUniformBufferUsage::UniformBuffer_SingleFrame);
  266.     PassParameters.IESTexture = IESTextureResource->TextureRHI;
  267.     PassParameters.IESTextureSampler = IESTextureResource->SamplerStateRHI;
  268.     const float TanOuterAngle = bIsSpotLight ? FMath::Tan(LightSceneInfo.Proxy->GetOuterConeAngle()) : 1.0f;
  269.     PassParameters.LightFunctionParameters = FVector4(TanOuterAngle, 1.0f /*ShadowFadeFraction*/, bIsSpotLight ? 1.0f : 0.0f, bIsPointLight ? 1.0f : 0.0f);
  270.     PassParameters.LightFunctionParameters2 = FVector(LightSceneInfo.Proxy->GetLightFunctionFadeDistance(), LightSceneInfo.Proxy->GetLightFunctionDisabledBrightness(),    0.0f);
  271.     const FVector Scale = LightSceneInfo.Proxy->GetLightFunctionScale();
  272.     // Switch x and z so that z of the user specified scale affects the distance along the light direction
  273.     const FVector InverseScale = FVector(1.f / Scale.Z, 1.f / Scale.Y, 1.f / Scale.X);
  274.     PassParameters.WorldToLight = LightSceneInfo.Proxy->GetWorldToLight() * FScaleMatrix(FVector(InverseScale));
  275.     FMobileRadialLightFunctionPS::SetParameters(RHICmdList, PixelShader, View, LightMaterial.MaterialProxy, *LightMaterial.Material, PassParameters);
  276.  
  277.     // 只绘制默认光照模型(MSM_DefaultLit)的像素.
  278.     uint8 StencilRef = GET_STENCIL_MOBILE_SM_MASK(MSM_DefaultLit);
  279.     RHICmdList.SetStencilRef(StencilRef);
  280.  
  281.     // 点光源用球体绘制.
  282.     if (LightType == LightType_Point)
  283.     {
  284.         StencilingGeometry::DrawSphere(RHICmdList);
  285.     }
  286.     // 聚光灯用锥体绘制.
  287.     else // LightType_Spot
  288.     {
  289.         StencilingGeometry::DrawCone(RHICmdList);
  290.     }
  291. }

绘制光源时，按光源类型划分为三个步骤：平行光、非分簇简单光源、局部光源（点光源和聚光灯）。需要注意的是，移动端只支持默认光照模型(MSM_DefaultLit)的计算，其它高级光照模型（头发、次表面散射、清漆、眼睛、布料等）暂不支持。

绘制平行光时，最多只能绘制1个，采用的是全屏幕矩形绘制，支持若干级CSM阴影。

绘制非分簇简单光源时，无论是点光源还是聚光灯，都采用球体绘制，不支持阴影。

绘制局部光源时，会复杂许多，先绘制局部光源模板缓冲，再设置光栅化和深度状态，最后才绘制光源。其中点光源采用球体绘制，不支持阴影；聚光灯采用锥体绘制，可以支持阴影，默认情况下，聚光灯不支持动态光影计算，需要在工程配置中开启：

此外，是否开启模板剔除光源不相交的像素由GMobileUseLightStencilCulling决定，而GMobileUseLightStencilCulling又由r.Mobile.UseLightStencilCulling决定，默认为1（即开启状态）。渲染光源的模板缓冲代码如下：

  1. static void RenderLocalLight_StencilMask(FRHICommandListImmediate& RHICmdList, const FScene& Scene, const FViewInfo& View, const FLightSceneInfo& LightSceneInfo)
  2. {
  3.     const uint8 LightType = LightSceneInfo.Proxy->GetLightType();
  4.  
  5.     FGraphicsPipelineStateInitializer GraphicsPSOInit;
  6.     // 应用缓存好的RT(颜色/深度等).
  7.     RHICmdList.ApplyCachedRenderTargets(GraphicsPSOInit);
  8.     GraphicsPSOInit.PrimitiveType = PT_TriangleList;
  9.     // 禁用所有RT的写操作.
  10.     GraphicsPSOInit.BlendState = TStaticBlendStateWriteMask<CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE, CW_NONE>::GetRHI();
  11.     GraphicsPSOInit.RasterizerState = View.bReverseCulling ? TStaticRasterizerState<FM_Solid, CM_CCW>::GetRHI() : TStaticRasterizerState<FM_Solid, CM_CW>::GetRHI();
  12.     // 如果深度测试失败, 则写入模板缓冲值为1.
  13.     GraphicsPSOInit.DepthStencilState = TStaticDepthStencilState<
  14.         false, CF_DepthNearOrEqual,
  15.         true, CF_Always, SO_Keep, SO_Replace, SO_Keep,        
  16.         false, CF_Always, SO_Keep, SO_Keep, SO_Keep,
  17.         0x00, 
  18.         // 注意只写入Pass专用的沙盒(SANBOX)位, 即模板缓冲的索引为0的位.
  19.         STENCIL_SANDBOX_MASK>::GetRHI();
  20.     
  21.     // 绘制光源模板的VS是TDeferredLightVS.
  22.     TShaderMapRef<TDeferredLightVS<true> > VertexShader(View.ShaderMap);
  23.     GraphicsPSOInit.BoundShaderState.VertexDeclarationRHI = GetVertexDeclarationFVector4();
  24.     GraphicsPSOInit.BoundShaderState.VertexShaderRHI = VertexShader.GetVertexShader();
  25.     // PS为空.
  26.     GraphicsPSOInit.BoundShaderState.PixelShaderRHI = nullptr;
  27.  
  28.     SetGraphicsPipelineState(RHICmdList, GraphicsPSOInit);
  29.     VertexShader->SetParameters(RHICmdList, View, &LightSceneInfo);
  30.     // 模板值为1.
  31.     RHICmdList.SetStencilRef(1);
  32.  
  33.     // 根据不同光源用不同形状绘制.
  34.     if (LightType == LightType_Point)
  35.     {
  36.         StencilingGeometry::DrawSphere(RHICmdList);
  37.     }
  38.     else // LightType_Spot
  39.     {
  40.         StencilingGeometry::DrawCone(RHICmdList);
  41.     }
  42. }

每个局部光源首先绘制光源范围内的Mask，再计算通过了Stencil测试（Early-Z）的像素的光照。具体的剖析过程以下图的聚光灯为例：

上：场景中一盏等待渲染的聚光灯；中：利用模板Pass绘制出的模板Mask（白色区域），标记了屏幕空间中和聚光灯形状重叠且深度更近的像素 ；下：对有效像素进行光照计算后的效果。

对有效像素进行光照计算时，使用的DepthStencil状态如下：

翻译成文字就是，执行光照的像素必须在光源形状体之内，光源形状之外的像素会被剔除。模板Pass标记的是比光源形状深度更近的像素（光源形状体之外的像素），光源绘制Pass通过模板测试剔除模板Pass标记的像素，然后再通过深度测试找出在光源形状体内的像素，从而提升光照计算效率。

移动端的这种光源模板裁剪（Light Stencil Culling）技术和Siggraph2020的Unity演讲Deferred Shading in Unity URP提及的基于模板的光照计算相似（思想一致，但做法可能不完全一样）。该论文还提出了更加契合光源形状的几何体模拟：

以及对比了各种光源计算方法在PC和移动端的性能，下面是Mali GPU的对比图：

Mali Gpu在使用不同光照渲染技术的性能对比，可见在移动端，基于模板裁剪的光照算法要优于常规和分块算法。

值得一提的是，光源模板裁剪技术结合GPU的Early-Z技术，将极大提升光照渲染性能。而当前主流的移动端GPU都支持Early-Z技术，也为光源模板裁剪的应用奠定了基础。

UE目前实现的光源裁剪算法兴许还有改进的空间，比如背向光源的像素（下图红框所示）其实也是可以不计算的。（但如何快速有效地找到背向光源的像素又是一个问题）

12.3.3.2 MobileBasePassShader

本节主要阐述移动端BasePass涉及的shader，包括VS和PS。先看VS：

  1. // Engine\Shaders\Private\MobileBasePassVertexShader.usf
  2.  
  3. (......)
  4.  
  5. struct FMobileShadingBasePassVSToPS
  6. {
  7.     FVertexFactoryInterpolantsVSToPS FactoryInterpolants;
  8.     FMobileBasePassInterpolantsVSToPS BasePassInterpolants;
  9.     float4 Position : SV_POSITION;
  10. };
  11.  
  12. #define FMobileShadingBasePassVSOutput FMobileShadingBasePassVSToPS
  13. #define VertexFactoryGetInterpolants VertexFactoryGetInterpolantsVSToPS
  14.  
  15. // VS主入口.
  16. void Main(
  17.     FVertexFactoryInput Input
  18.     , out FMobileShadingBasePassVSOutput Output
  19. #if INSTANCED_STEREO
  20.     , uint InstanceId : SV_InstanceID
  21.     , out uint LayerIndex : SV_RenderTargetArrayIndex
  22. #elif MOBILE_MULTI_VIEW
  23.     , in uint ViewId : SV_ViewID
  24. #endif
  25.     )
  26. {
  27. // 立体视图模式.
  28. #if INSTANCED_STEREO
  29.     const uint EyeIndex = GetEyeIndex(InstanceId);
  30.     ResolvedView = ResolveView(EyeIndex);
  31.     LayerIndex = EyeIndex;
  32.     Output.BasePassInterpolants.MultiViewId = float(EyeIndex);
  33. // 多视图模式.
  34. #elif MOBILE_MULTI_VIEW
  35.     #if COMPILER_GLSL_ES3_1
  36.         const int MultiViewId = int(ViewId);
  37.         ResolvedView = ResolveView(uint(MultiViewId));
  38.         Output.BasePassInterpolants.MultiViewId = float(MultiViewId);
  39.     #else
  40.         ResolvedView = ResolveView(ViewId);
  41.         Output.BasePassInterpolants.MultiViewId = float(ViewId);
  42.     #endif
  43. #else
  44.     ResolvedView = ResolveView();
  45. #endif
  46.  
  47.     // 初始化打包的插值数据.
  48. #if PACK_INTERPOLANTS
  49.     float4 PackedInterps[NUM_VF_PACKED_INTERPOLANTS];
  50.     UNROLL 
  51.     for(int i = 0; i < NUM_VF_PACKED_INTERPOLANTS; ++i)
  52.     {
  53.         PackedInterps[i] = 0;
  54.     }
  55. #endif
  56.  
  57.     // 处理顶点工厂数据.
  58.     FVertexFactoryIntermediates VFIntermediates = GetVertexFactoryIntermediates(Input);
  59.     float4 WorldPositionExcludingWPO = VertexFactoryGetWorldPosition(Input, VFIntermediates);
  60.     float4 WorldPosition = WorldPositionExcludingWPO;
  61.  
  62.     // 获取材质的顶点数据, 处理坐标等.
  63.     half3x3 TangentToLocal = VertexFactoryGetTangentToLocal(Input, VFIntermediates);    
  64.     FMaterialVertexParameters VertexParameters = GetMaterialVertexParameters(Input, VFIntermediates, WorldPosition.xyz, TangentToLocal);
  65.  
  66.     half3 WorldPositionOffset = GetMaterialWorldPositionOffset(VertexParameters);
  67.     
  68.     WorldPosition.xyz += WorldPositionOffset;
  69.  
  70.     float4 RasterizedWorldPosition = VertexFactoryGetRasterizedWorldPosition(Input, VFIntermediates, WorldPosition);
  71.     Output.Position = mul(RasterizedWorldPosition, ResolvedView.TranslatedWorldToClip);
  72.     Output.BasePassInterpolants.PixelPosition = WorldPosition;
  73.  
  74. #if USE_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS
  75.     Output.BasePassInterpolants.PixelPositionExcludingWPO = WorldPositionExcludingWPO.xyz;
  76. #endif
  77.  
  78.     // 裁剪面.
  79. #if USE_PS_CLIP_PLANE
  80.     Output.BasePassInterpolants.OutClipDistance = dot(ResolvedView.GlobalClippingPlane, float4(WorldPosition.xyz - ResolvedView.PreViewTranslation.xyz, 1));
  81. #endif
  82.  
  83.     // 顶点雾.
  84. #if USE_VERTEX_FOG
  85.     float4 VertexFog = CalculateHeightFog(WorldPosition.xyz - ResolvedView.TranslatedWorldCameraOrigin);
  86.  
  87.     #if PROJECT_SUPPORT_SKY_ATMOSPHERE && MATERIAL_IS_SKY==0 // Do not apply aerial perpsective on sky materials
  88.         if (ResolvedView.SkyAtmosphereApplyCameraAerialPerspectiveVolume > 0.0f)
  89.         {
  90.             const float OneOverPreExposure = USE_PREEXPOSURE ? ResolvedView.OneOverPreExposure : 1.0f;
  91.             // Sample the aerial perspective (AP). It is also blended under the VertexFog parameter.
  92.             VertexFog = GetAerialPerspectiveLuminanceTransmittanceWithFogOver(
  93.                 ResolvedView.RealTimeReflectionCapture, ResolvedView.SkyAtmosphereCameraAerialPerspectiveVolumeSizeAndInvSize,
  94.                 Output.Position, WorldPosition.xyz*CM_TO_SKY_UNIT, ResolvedView.TranslatedWorldCameraOrigin*CM_TO_SKY_UNIT,
  95.                 View.CameraAerialPerspectiveVolume, View.CameraAerialPerspectiveVolumeSampler,
  96.                 ResolvedView.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolutionInv,
  97.                 ResolvedView.SkyAtmosphereCameraAerialPerspectiveVolumeDepthResolution,
  98.                 ResolvedView.SkyAtmosphereAerialPerspectiveStartDepthKm,
  99.                 ResolvedView.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKm,
  100.                 ResolvedView.SkyAtmosphereCameraAerialPerspectiveVolumeDepthSliceLengthKmInv,
  101.                 OneOverPreExposure, VertexFog);
  102.         }
  103.     #endif
  104.  
  105.     #if PACK_INTERPOLANTS
  106.         PackedInterps[0] = VertexFog;
  107.     #else
  108.         Output.BasePassInterpolants.VertexFog = VertexFog;
  109.     #endif // PACK_INTERPOLANTS
  110. #endif // USE_VERTEX_FOG
  111.  
  112.     (......)
  113.  
  114.     // 获取待插值的数据.
  115.     Output.FactoryInterpolants = VertexFactoryGetInterpolants(Input, VFIntermediates, VertexParameters);
  116.  
  117.     Output.BasePassInterpolants.PixelPosition.w = Output.Position.w;
  118.  
  119.     // 打包插值数据.
  120. #if PACK_INTERPOLANTS
  121.     VertexFactoryPackInterpolants(Output.FactoryInterpolants, PackedInterps);
  122. #endif // PACK_INTERPOLANTS
  123.  
  124. #if !OUTPUT_MOBILE_HDR && COMPILER_GLSL_ES3_1
  125.     Output.Position.y *= -1;
  126. #endif
  127. }

以上可知，视图实例会根据立体绘制、多视图和普通模式不同而不同处理。支持顶点雾，但默认是关闭的，需要在工程配置内开启。

存在打包插值模式，为了压缩VS到PS之间的插值消耗和带宽。是否开启由宏PACK_INTERPOLANTS决定，它的定义如下：

  1. // Engine\Shaders\Private\MobileBasePassCommon.ush
  2.  
  3. #define PACK_INTERPOLANTS (USE_VERTEX_FOG && NUM_VF_PACKED_INTERPOLANTS > 0 && (ES3_1_PROFILE))

也就是说，只有开启顶点雾、存在顶点工厂打包插值数据且是OpenGLES3.1着色平台才开启打包插值的特性。相比PC端的BasePass的VS，移动端的做了大量的简化，可以简单地认为只是PC端的一个很小的子集。下面继续分析PS：

  1. // Engine\Shaders\Private\MobileBasePassPixelShader.usf
  2.  
  3. #include "Common.ush"
  4.  
  5. // 各类宏定义.
  6. #define MobileSceneTextures MobileBasePass.SceneTextures
  7. #define EyeAdaptationStruct MobileBasePass
  8.  
  9. (......)
  10.  
  11. // 最接近被渲染对象的场景的预归一化捕获(完全粗糙材质不支持)
  12. #if !FULLY_ROUGH
  13.     #if HQ_REFLECTIONS
  14.     #define MAX_HQ_REFLECTIONS 3
  15.     TextureCube ReflectionCubemap0;
  16.     SamplerState ReflectionCubemapSampler0;
  17.     TextureCube ReflectionCubemap1;
  18.     SamplerState ReflectionCubemapSampler1;
  19.     TextureCube ReflectionCubemap2;
  20.     SamplerState ReflectionCubemapSampler2;
  21.     // x,y,z - inverted average brightness for 0, 1, 2; w - sky cube texture max mips.
  22.     float4 ReflectionAverageBrigtness;
  23.     float4 ReflectanceMaxValueRGBM;
  24.     float4 ReflectionPositionsAndRadii[MAX_HQ_REFLECTIONS];
  25.         #if ALLOW_CUBE_REFLECTIONS
  26.         float4x4 CaptureBoxTransformArray[MAX_HQ_REFLECTIONS];
  27.         float4 CaptureBoxScalesArray[MAX_HQ_REFLECTIONS];
  28.         #endif
  29.     #endif
  30. #endif
  31.  
  32. // 反射球/IBL等接口.
  33. half4 GetPlanarReflection(float3 WorldPosition, half3 WorldNormal, half Roughness);
  34. half MobileComputeMixingWeight(half IndirectIrradiance, half AverageBrightness, half Roughness);
  35. half3 GetLookupVectorForBoxCaptureMobile(half3 ReflectionVector, ...);
  36. half3 GetLookupVectorForSphereCaptureMobile(half3 ReflectionVector, ...);
  37. void GatherSpecularIBL(FMaterialPixelParameters MaterialParameters, ...);
  38. void BlendReflectionCaptures(FMaterialPixelParameters MaterialParameters, ...)
  39. half3 GetImageBasedReflectionLighting(FMaterialPixelParameters MaterialParameters, ...);
  40.  
  41. // 其它接口.
  42. half3 FrameBufferBlendOp(half4 Source);
  43. bool UseCSM();
  44. void ApplyPixelDepthOffsetForMobileBasePass(inout FMaterialPixelParameters MaterialParameters, FPixelMaterialInputs PixelMaterialInputs, out float OutDepth);
  45.  
  46. // 累积动态点光源.
  47. #if MAX_DYNAMIC_POINT_LIGHTS > 0
  48. void AccumulateLightingOfDynamicPointLight(
  49.     FMaterialPixelParameters MaterialParameters, 
  50.     FMobileShadingModelContext ShadingModelContext,
  51.     FGBufferData GBuffer,
  52.     float4 LightPositionAndInvRadius, 
  53.     float4 LightColorAndFalloffExponent, 
  54.     float4 SpotLightDirectionAndSpecularScale, 
  55.     float4 SpotLightAnglesAndSoftTransitionScaleAndLightShadowType, 
  56.     #if SUPPORT_SPOTLIGHTS_SHADOW
  57.     FPCFSamplerSettings Settings,
  58.     float4 SpotLightShadowSharpenAndShadowFadeFraction,
  59.     float4 SpotLightShadowmapMinMax,
  60.     float4x4 SpotLightShadowWorldToShadowMatrix,
  61.     #endif
  62.     inout half3 Color)
  63. {
  64.     uint LightShadowType = SpotLightAnglesAndSoftTransitionScaleAndLightShadowType.w;
  65.     float FadedShadow = 1.0f;
  66.  
  67.     // 计算聚光灯阴影.
  68. #if SUPPORT_SPOTLIGHTS_SHADOW
  69.     if ((LightShadowType & LightShadowType_Shadow) == LightShadowType_Shadow)
  70.     {
  71.  
  72.         float4 HomogeneousShadowPosition = mul(float4(MaterialParameters.AbsoluteWorldPosition, 1), SpotLightShadowWorldToShadowMatrix);
  73.         float2 ShadowUVs = HomogeneousShadowPosition.xy / HomogeneousShadowPosition.w;
  74.         if (all(ShadowUVs >= SpotLightShadowmapMinMax.xy && ShadowUVs <= SpotLightShadowmapMinMax.zw))
  75.         {
  76.             // Clamp pixel depth in light space for shadowing opaque, because areas of the shadow depth buffer that weren't rendered to will have been cleared to 1
  77.             // We want to force the shadow comparison to result in 'unshadowed' in that case, regardless of whether the pixel being shaded is in front or behind that plane
  78.             float LightSpacePixelDepthForOpaque = min(HomogeneousShadowPosition.z, 0.99999f);
  79.             Settings.SceneDepth = LightSpacePixelDepthForOpaque;
  80.             Settings.TransitionScale = SpotLightAnglesAndSoftTransitionScaleAndLightShadowType.z;
  82.             half Shadow = MobileShadowPCF(ShadowUVs, Settings);
  84.             Shadow = saturate((Shadow - 0.5) * SpotLightShadowSharpenAndShadowFadeFraction.x + 0.5);
  86.             FadedShadow = lerp(1.0f, Square(Shadow), SpotLightShadowSharpenAndShadowFadeFraction.y);
  87.         }
  88.     }
  89. #endif
  91.     // 计算光照.
  92.     if ((LightShadowType & ValidLightType) != 0)
  93.     {
  94.         float3 ToLight = LightPositionAndInvRadius.xyz - MaterialParameters.AbsoluteWorldPosition;
  95.         float DistanceSqr = dot(ToLight, ToLight);
  96.         float3 L = ToLight * rsqrt(DistanceSqr);
  97.         half3 PointH = normalize(MaterialParameters.CameraVector + L);
  99.         half PointNoL = max(0, dot(MaterialParameters.WorldNormal, L));
  100.         half PointNoH = max(0, dot(MaterialParameters.WorldNormal, PointH));
  102.         // 计算光源的衰减.
  103.         float Attenuation;
  104.         if (LightColorAndFalloffExponent.w == 0)
  105.         {
  106.             // Sphere falloff (technically just 1/d2 but this avoids inf)
  107.             Attenuation = 1 / (DistanceSqr + 1);
  109.             float LightRadiusMask = Square(saturate(1 - Square(DistanceSqr * (LightPositionAndInvRadius.w * LightPositionAndInvRadius.w))));
  110.             Attenuation *= LightRadiusMask;
  111.         }
  112.         else
  113.         {
  114.             Attenuation = RadialAttenuation(ToLight * LightPositionAndInvRadius.w, LightColorAndFalloffExponent.w);
  115.         }
  117. #if PROJECT_MOBILE_ENABLE_MOVABLE_SPOTLIGHTS
  118.         if ((LightShadowType & LightShadowType_SpotLight) == LightShadowType_SpotLight)
  119.         {
  120.             Attenuation *= SpotAttenuation(L, -SpotLightDirectionAndSpecularScale.xyz, SpotLightAnglesAndSoftTransitionScaleAndLightShadowType.xy) * FadedShadow;
  121.         }
  122. #endif
  124.         // 累加光照结果.
  125. #if !FULLY_ROUGH
  126.         FMobileDirectLighting Lighting = MobileIntegrateBxDF(ShadingModelContext, GBuffer, PointNoL, MaterialParameters.CameraVector, PointH, PointNoH);
  127.         Color += min(65000.0, (Attenuation) * LightColorAndFalloffExponent.rgb * (1.0 / PI) * (Lighting.Diffuse + Lighting.Specular * SpotLightDirectionAndSpecularScale.w));
  128. #else
  129.         Color += (Attenuation * PointNoL) * LightColorAndFalloffExponent.rgb * (1.0 / PI) * ShadingModelContext.DiffuseColor;
  130. #endif
  131.     }
  132. }
  133. #endif
  135. (......)
  137. // 计算非直接光照.
  138. half ComputeIndirect(VTPageTableResult LightmapVTPageTableResult, FVertexFactoryInterpolantsVSToPS Interpolants, float3 DiffuseDir, FMobileShadingModelContext ShadingModelContext, out half IndirectIrradiance, out half3 Color)
  139. {
  140.     //To keep IndirectLightingCache conherence with PC, initialize the IndirectIrradiance to zero.
  141.     IndirectIrradiance = 0;
  142.     Color = 0;
  144.     // 非直接漫反射.
  145. #if LQ_TEXTURE_LIGHTMAP
  146.     float2 LightmapUV0, LightmapUV1;
  147.     uint LightmapDataIndex;
  148.     GetLightMapCoordinates(Interpolants, LightmapUV0, LightmapUV1, LightmapDataIndex);
  150.     half4 LightmapColor = GetLightMapColorLQ(LightmapVTPageTableResult, LightmapUV0, LightmapUV1, LightmapDataIndex, DiffuseDir);
  151.     Color += LightmapColor.rgb * ShadingModelContext.DiffuseColor * View.IndirectLightingColorScale;
  152.     IndirectIrradiance = LightmapColor.a;
  153. #elif CACHED_POINT_INDIRECT_LIGHTING
  154.     #if MATERIALBLENDING_MASKED || MATERIALBLENDING_SOLID
  155.         // 将法线应用到半透明物体.
  156.         FThreeBandSHVectorRGB PointIndirectLighting;
  157.         PointIndirectLighting.R.V0 = IndirectLightingCache.IndirectLightingSHCoefficients0[0];
  158.         PointIndirectLighting.R.V1 = IndirectLightingCache.IndirectLightingSHCoefficients1[0];
  159.         PointIndirectLighting.R.V2 = IndirectLightingCache.IndirectLightingSHCoefficients2[0];
  161.         PointIndirectLighting.G.V0 = IndirectLightingCache.IndirectLightingSHCoefficients0[1];
  162.         PointIndirectLighting.G.V1 = IndirectLightingCache.IndirectLightingSHCoefficients1[1];
  163.         PointIndirectLighting.G.V2 = IndirectLightingCache.IndirectLightingSHCoefficients2[1];
  165.         PointIndirectLighting.B.V0 = IndirectLightingCache.IndirectLightingSHCoefficients0[2];
  166.         PointIndirectLighting.B.V1 = IndirectLightingCache.IndirectLightingSHCoefficients1[2];
  167.         PointIndirectLighting.B.V2 = IndirectLightingCache.IndirectLightingSHCoefficients2[2];
  169.         FThreeBandSHVector DiffuseTransferSH = CalcDiffuseTransferSH3(DiffuseDir, 1);
  171.         // 计算加入了法线影响的漫反射光照.
  172.         half3 DiffuseGI = max(half3(0, 0, 0), DotSH3(PointIndirectLighting, DiffuseTransferSH));
  174.         IndirectIrradiance = Luminance(DiffuseGI);
  175.         Color += ShadingModelContext.DiffuseColor * DiffuseGI * View.IndirectLightingColorScale;
  176.     #else 
  177.         // 半透明使用无方向(Non-directional), 漫反射被打包在xyz, 已经在cpu端除了PI和SH漫反射.
  178.         half3 PointIndirectLighting = IndirectLightingCache.IndirectLightingSHSingleCoefficient.rgb;
  179.         half3 DiffuseGI = PointIndirectLighting;
  181.         IndirectIrradiance = Luminance(DiffuseGI);
  182.         Color += ShadingModelContext.DiffuseColor * DiffuseGI * View.IndirectLightingColorScale;
  183.     #endif
  184. #endif
  186.     return IndirectIrradiance;
  187. }
  189. // PS主入口.
  190. PIXELSHADER_EARLYDEPTHSTENCIL
  191. void Main( 
  192.     FVertexFactoryInterpolantsVSToPS Interpolants
  193.     , FMobileBasePassInterpolantsVSToPS BasePassInterpolants
  194.     , in float4 SvPosition : SV_Position
  195.     OPTIONAL_IsFrontFace
  196.     , out half4 OutColor    : SV_Target0
  197. #if DEFERRED_SHADING_PATH
  198.     , out half4 OutGBufferA    : SV_Target1
  199.     , out half4 OutGBufferB    : SV_Target2
  200.     , out half4 OutGBufferC    : SV_Target3
  201. #endif
  202. #if USE_SCENE_DEPTH_AUX
  203.     , out float OutSceneDepthAux : SV_Target4
  204. #endif
  205. #if OUTPUT_PIXEL_DEPTH_OFFSET
  206.     , out float OutDepth : SV_Depth
  207. #endif
  208.     )
  209. {
  210. #if MOBILE_MULTI_VIEW
  211.     ResolvedView = ResolveView(uint(BasePassInterpolants.MultiViewId));
  212. #else
  213.     ResolvedView = ResolveView();
  214. #endif
  216. #if USE_PS_CLIP_PLANE
  217.     clip(BasePassInterpolants.OutClipDistance);
  218. #endif
  220.     // 解压打包的插值数据.
  221. #if PACK_INTERPOLANTS
  222.     float4 PackedInterpolants[NUM_VF_PACKED_INTERPOLANTS];
  223.     VertexFactoryUnpackInterpolants(Interpolants, PackedInterpolants);
  224. #endif
  226. #if COMPILER_GLSL_ES3_1 && !OUTPUT_MOBILE_HDR && !MOBILE_EMULATION
  227.     // LDR Mobile needs screen vertical flipped
  228.     SvPosition.y = ResolvedView.BufferSizeAndInvSize.y - SvPosition.y - 1;
  229. #endif
  231.     // 获取材质的像素属性.
  232.     FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(Interpolants, SvPosition);
  233.     FPixelMaterialInputs PixelMaterialInputs;
  234.     {
  235.         float4 ScreenPosition = SvPositionToResolvedScreenPosition(SvPosition);
  236.         float3 WorldPosition = BasePassInterpolants.PixelPosition.xyz;
  237.         float3 WorldPositionExcludingWPO = BasePassInterpolants.PixelPosition.xyz;
  238.         #if USE_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS
  239.             WorldPositionExcludingWPO = BasePassInterpolants.PixelPositionExcludingWPO;
  240.         #endif
  241.         CalcMaterialParametersEx(MaterialParameters, PixelMaterialInputs, SvPosition, ScreenPosition, bIsFrontFace, WorldPosition, WorldPositionExcludingWPO);
  243. #if FORCE_VERTEX_NORMAL
  244.         // Quality level override of material's normal calculation, can be used to avoid normal map reads etc.
  245.         MaterialParameters.WorldNormal = MaterialParameters.TangentToWorld[2];
  246.         MaterialParameters.ReflectionVector = ReflectionAboutCustomWorldNormal(MaterialParameters, MaterialParameters.WorldNormal, false);
  247. #endif
  248.     }
  249.  
  250.     // 像素深度偏移.
  251. #if OUTPUT_PIXEL_DEPTH_OFFSET
  252.     ApplyPixelDepthOffsetForMobileBasePass(MaterialParameters, PixelMaterialInputs, OutDepth);
  253. #endif
  254.       
  255.     // Mask材质.
  256. #if !EARLY_Z_PASS_ONLY_MATERIAL_MASKING
  257.     //Clip if the blend mode requires it.
  258.     GetMaterialCoverageAndClipping(MaterialParameters, PixelMaterialInputs);
  259. #endif
  260.  
  261.     // 计算并缓存GBuffer数据, 防止后续多次采用纹理.
  262.     FGBufferData GBuffer = (FGBufferData)0;
  263.     GBuffer.WorldNormal = MaterialParameters.WorldNormal;
  264.     GBuffer.BaseColor = GetMaterialBaseColor(PixelMaterialInputs);
  265.     GBuffer.Metallic = GetMaterialMetallic(PixelMaterialInputs);
  266.     GBuffer.Specular = GetMaterialSpecular(PixelMaterialInputs);
  267.     GBuffer.Roughness = GetMaterialRoughness(PixelMaterialInputs);
  268.     GBuffer.ShadingModelID = GetMaterialShadingModel(PixelMaterialInputs);
  269.     half MaterialAO = GetMaterialAmbientOcclusion(PixelMaterialInputs);
  270.  
  271.     // 应用AO.
  272. #if APPLY_AO
  273.     half4 GatheredAmbientOcclusion = Texture2DSample(AmbientOcclusionTexture, AmbientOcclusionSampler, SvPositionToBufferUV(SvPosition));
  274.  
  275.     MaterialAO *= GatheredAmbientOcclusion.r;
  276. #endif
  277.  
  278.     GBuffer.GBufferAO = MaterialAO;
  279.  
  280.     // 由于IEEE 754 (FP16)可表示的最小标准值是2^-24 = 5.96e-8, 而后面的粗糙度涉及到1.0 / Roughness^4的计算, 所以为了防止除零错误, 需保证Roughness^4 >= 5.96e-8, 此处直接Clamp粗糙度到0.015625(0.015625^4 = 5.96e-8).
  281.     // 另外, 为了匹配PC端的延迟渲染(粗糙度存储在8位的值), 因此也自动Clamp到1.0.
  282.     GBuffer.Roughness = max(0.015625, GetMaterialRoughness(PixelMaterialInputs));
  283.     
  284.     // 初始化移动端着色模型上下文FMobileShadingModelContext.
  285.     FMobileShadingModelContext ShadingModelContext = (FMobileShadingModelContext)0;
  286.     ShadingModelContext.Opacity = GetMaterialOpacity(PixelMaterialInputs);
  287.  
  288.     // 薄层透明度物
  289. #if MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT
  290.     (......)
  291. #endif
  292.  
  293.     half3 Color = 0;
  294.  
  295.     // 自定义数据.
  296.     half CustomData0 = GetMaterialCustomData0(MaterialParameters);
  297.     half CustomData1 = GetMaterialCustomData1(MaterialParameters);
  298.     InitShadingModelContext(ShadingModelContext, GBuffer, MaterialParameters.SvPosition, MaterialParameters.CameraVector, CustomData0, CustomData1);
  299.     float3 DiffuseDir = MaterialParameters.WorldNormal;
  300.  
  301.     // 头发模型.
  302. #if MATERIAL_SHADINGMODEL_HAIR
  303.     (......)
  304. #endif
  305.  
  306.     // 光照图虚拟纹理.
  307.     VTPageTableResult LightmapVTPageTableResult = (VTPageTableResult)0.0f;
  308. #if LIGHTMAP_VT_ENABLED
  309.     {
  310.         float2 LightmapUV0, LightmapUV1;
  311.         uint LightmapDataIndex;
  312.         GetLightMapCoordinates(Interpolants, LightmapUV0, LightmapUV1, LightmapDataIndex);
  313.         LightmapVTPageTableResult = LightmapGetVTSampleInfo(LightmapUV0, LightmapDataIndex, SvPosition.xy);
  314.     }
  315. #endif
  316.  
  317. #if LIGHTMAP_VT_ENABLED
  318.     // This must occur after CalcMaterialParameters(), which is required to initialize the VT feedback mechanism
  319.     // Lightmap request is always the first VT sample in the shader
  320.     StoreVirtualTextureFeedback(MaterialParameters.VirtualTextureFeedback, 0, LightmapVTPageTableResult.PackedRequest);
  321. #endif
  322.  
  323.     // 计算非直接光.
  324.     half IndirectIrradiance;
  325.     half3 IndirectColor;
  326.     ComputeIndirect(LightmapVTPageTableResult, Interpolants, DiffuseDir, ShadingModelContext, IndirectIrradiance, IndirectColor);
  327.     Color += IndirectColor;
  328.  
  329.     // 预计算的阴影图.
  330.     half Shadow = GetPrimaryPrecomputedShadowMask(LightmapVTPageTableResult, Interpolants).r;
  331.  
  332. #if DEFERRED_SHADING_PATH
  333.     float4 OutGBufferD;
  334.     float4 OutGBufferE;
  335.     float4 OutGBufferF;
  336.     float4 OutGBufferVelocity = 0;
  337.  
  338.     GBuffer.IndirectIrradiance = IndirectIrradiance;
  339.     GBuffer.PrecomputedShadowFactors.r = Shadow;
  340.  
  341.     // 编码GBuffer数据.
  342.     EncodeGBuffer(GBuffer, OutGBufferA, OutGBufferB, OutGBufferC, OutGBufferD, OutGBufferE, OutGBufferF, OutGBufferVelocity);
  343. #else
  344.  
  345. #if !MATERIAL_SHADINGMODEL_UNLIT
  346.  
  347.     // 天光.
  348. #if ENABLE_SKY_LIGHT
  349.     half3 SkyDiffuseLighting = GetSkySHDiffuseSimple(MaterialParameters.WorldNormal);
  350.     half3 DiffuseLookup = SkyDiffuseLighting * ResolvedView.SkyLightColor.rgb;
  351.     IndirectIrradiance += Luminance(DiffuseLookup);
  352. #endif
  353.             
  354.     Color *= MaterialAO;
  355.     IndirectIrradiance *= MaterialAO;
  356.  
  357.     float  ShadowPositionZ = 0;
  358. #if DIRECTIONAL_LIGHT_CSM && !MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  359.     // CSM阴影.
  360.     if (UseCSM())
  361.     {
  362.         half ShadowMap = MobileDirectionalLightCSM(MaterialParameters.ScreenPosition.xy, MaterialParameters.ScreenPosition.w, ShadowPositionZ);
  363.     #if ALLOW_STATIC_LIGHTING
  364.         Shadow = min(ShadowMap, Shadow);
  365.     #else
  366.         Shadow = ShadowMap;
  367.     #endif
  368.     }
  369. #endif /* DIRECTIONAL_LIGHT_CSM */
  370.  
  371.     // 距离场阴影.
  372. #if APPLY_DISTANCE_FIELD
  373.     if (ShadowPositionZ == 0)
  374.     {
  375.         Shadow = Texture2DSample(MobileBasePass.ScreenSpaceShadowMaskTexture, MobileBasePass.ScreenSpaceShadowMaskSampler, SvPositionToBufferUV(SvPosition)).x;
  376.     }
  377. #endif
  378.  
  379.     half NoL = max(0, dot(MaterialParameters.WorldNormal, MobileDirectionalLight.DirectionalLightDirectionAndShadowTransition.xyz));
  380.     half3 H = normalize(MaterialParameters.CameraVector + MobileDirectionalLight.DirectionalLightDirectionAndShadowTransition.xyz);
  381.     half NoH = max(0, dot(MaterialParameters.WorldNormal, H));
  382.  
  383.     // 平行光 + IBL
  384. #if FULLY_ROUGH
  385.     Color += (Shadow * NoL) * MobileDirectionalLight.DirectionalLightColor.rgb * ShadingModelContext.DiffuseColor;
  386. #else
  387.     FMobileDirectLighting Lighting = MobileIntegrateBxDF(ShadingModelContext, GBuffer, NoL, MaterialParameters.CameraVector, H, NoH);
  388.     // MobileDirectionalLight.DirectionalLightDistanceFadeMADAndSpecularScale.z保存了平行光的SpecularScale.
  389.     Color += (Shadow) * MobileDirectionalLight.DirectionalLightColor.rgb * (Lighting.Diffuse + Lighting.Specular * MobileDirectionalLight.DirectionalLightDistanceFadeMADAndSpecularScale.z);
  390.  
  391.     // 头发着色.
  392. #if    !(MATERIAL_SINGLE_SHADINGMODEL && MATERIAL_SHADINGMODEL_HAIR)
  393.     (......)
  394. #endif
  395. #endif /* FULLY_ROUGH */
  396.  
  397.     // 局部光源, 最多4个.
  398. #if MAX_DYNAMIC_POINT_LIGHTS > 0 && !MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  399.  
  400.         if(NumDynamicPointLights > 0)
  401.         {
  402.  
  403.             #if SUPPORT_SPOTLIGHTS_SHADOW
  404.                 FPCFSamplerSettings Settings;
  405.                 Settings.ShadowDepthTexture = DynamicSpotLightShadowTexture;
  406.                 Settings.ShadowDepthTextureSampler = DynamicSpotLightShadowSampler;
  407.                 Settings.ShadowBufferSize = DynamicSpotLightShadowBufferSize;
  408.                 Settings.bSubsurface = false;
  409.                 Settings.bTreatMaxDepthUnshadowed = false;
  410.                 Settings.DensityMulConstant = 0;
  411.                 Settings.ProjectionDepthBiasParameters = 0;
  412.             #endif
  413.  
  414.             AccumulateLightingOfDynamicPointLight(MaterialParameters, ...);
  415.         
  416.             if (MAX_DYNAMIC_POINT_LIGHTS > 1 && NumDynamicPointLights > 1)
  417.             {
  418.                 AccumulateLightingOfDynamicPointLight(MaterialParameters, ...);
  419.  
  420.                 if (MAX_DYNAMIC_POINT_LIGHTS > 2 && NumDynamicPointLights > 2)
  421.                 {
  422.                     AccumulateLightingOfDynamicPointLight(MaterialParameters, ...);
  423.  
  424.                     if (MAX_DYNAMIC_POINT_LIGHTS > 3 && NumDynamicPointLights > 3)
  425.                     {
  426.                         AccumulateLightingOfDynamicPointLight(MaterialParameters, ...);
  427.                     }
  428.                 }
  429.             }
  430.         }
  431.  
  432. #endif
  433.  
  434.     // 天空光.
  435. #if ENABLE_SKY_LIGHT
  436.     #if MATERIAL_TWOSIDED && LQ_TEXTURE_LIGHTMAP
  437.     if (NoL == 0)
  438.     {
  439.     #endif
  440.  
  441.     #if MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  442.         ShadingModelContext.WaterDiffuseIndirectLuminance += SkyDiffuseLighting;
  443.     #endif
  444.         Color += SkyDiffuseLighting * half3(ResolvedView.SkyLightColor.rgb) * ShadingModelContext.DiffuseColor * MaterialAO;
  445.     #if MATERIAL_TWOSIDED && LQ_TEXTURE_LIGHTMAP
  446.     }
  447.     #endif
  448. #endif
  449.  
  450. #endif /* !MATERIAL_SHADINGMODEL_UNLIT */
  451.  
  452. #if MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  453.     (......)
  454. #endif // MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  455.  
  456. #endif// DEFERRED_SHADING_PATH
  457.  
  458.     // 处理顶点雾.
  459.     half4 VertexFog = half4(0, 0, 0, 1);
  460. #if USE_VERTEX_FOG
  461. #if PACK_INTERPOLANTS
  462.     VertexFog = PackedInterpolants[0];
  463. #else
  464.     VertexFog = BasePassInterpolants.VertexFog;
  465. #endif
  466. #endif
  467.     
  468.     // 自发光.
  469.     half3 Emissive = GetMaterialEmissive(PixelMaterialInputs);
  470. #if MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT
  471.     Emissive *= TopMaterialCoverage;
  472. #endif
  473.     Color += Emissive;
  474.  
  475. #if !MATERIAL_SHADINGMODEL_UNLIT && MOBILE_EMULATION
  476.     Color = lerp(Color, ShadingModelContext.DiffuseColor, ResolvedView.UnlitViewmodeMask);
  477. #endif
  478.  
  479.     // 组合雾颜色到输出颜色.
  480.     #if MATERIALBLENDING_ALPHACOMPOSITE || MATERIAL_SHADINGMODEL_SINGLELAYERWATER
  481.         OutColor = half4(Color * VertexFog.a + VertexFog.rgb * ShadingModelContext.Opacity, ShadingModelContext.Opacity);
  482.     #elif MATERIALBLENDING_ALPHAHOLDOUT
  483.         // not implemented for holdout
  484.         OutColor = half4(Color * VertexFog.a + VertexFog.rgb * ShadingModelContext.Opacity, ShadingModelContext.Opacity);
  485.     #elif MATERIALBLENDING_TRANSLUCENT
  486.         OutColor = half4(Color * VertexFog.a + VertexFog.rgb, ShadingModelContext.Opacity);
  487.     #elif MATERIALBLENDING_ADDITIVE
  488.         OutColor = half4(Color * (VertexFog.a * ShadingModelContext.Opacity.x), 0.0f);
  489.     #elif MATERIALBLENDING_MODULATE
  490.         half3 FoggedColor = lerp(half3(1, 1, 1), Color, VertexFog.aaa * VertexFog.aaa);
  491.         OutColor = half4(FoggedColor, ShadingModelContext.Opacity);
  492.     #else
  493.         OutColor.rgb = Color * VertexFog.a + VertexFog.rgb;
  494.  
  495.         #if !MATERIAL_USE_ALPHA_TO_COVERAGE
  496.             // Scene color alpha is not used yet so we set it to 1
  497.             OutColor.a = 1.0;
  498.  
  499.             #if OUTPUT_MOBILE_HDR 
  500.                 // Store depth in FP16 alpha. This depth value can be fetched during translucency or sampled in post-processing
  501.                 OutColor.a = SvPosition.z;
  502.             #endif
  503.         #else
  504.             half MaterialOpacityMask = GetMaterialMaskInputRaw(PixelMaterialInputs);
  505.             OutColor.a = GetMaterialMask(PixelMaterialInputs) / max(abs(ddx(MaterialOpacityMask)) + abs(ddy(MaterialOpacityMask)), 0.0001f) + 0.5f;
  506.         #endif
  507.     #endif
  508.  
  509.     #if !MATERIALBLENDING_MODULATE && USE_PREEXPOSURE
  510.         OutColor.rgb *= ResolvedView.PreExposure;
  511.     #endif
  512.  
  513.     #if MATERIAL_IS_SKY
  514.         OutColor.rgb = min(OutColor.rgb, Max10BitsFloat.xxx * 0.5f);
  515.     #endif
  516.  
  517. #if USE_SCENE_DEPTH_AUX
  518.     OutSceneDepthAux = SvPosition.z;
  519. #endif
  520.  
  521.     // 处理颜色的alpha.
  522. #if USE_EDITOR_COMPOSITING && (MOBILE_EMULATION)
  523.     // Editor primitive depth testing
  524.     OutColor.a = 1.0;
  525.     #if MATERIALBLENDING_MASKED
  526.         // some material might have an opacity value
  527.         OutColor.a = GetMaterialMaskInputRaw(PixelMaterialInputs);
  528.     #endif
  529.     clip(OutColor.a - GetMaterialOpacityMaskClipValue());
  530. #else
  531.     #if OUTPUT_GAMMA_SPACE
  532.         OutColor.rgb = sqrt(OutColor.rgb);
  533.     #endif
  534. #endif
  535.  
  536. #if NUM_VIRTUALTEXTURE_SAMPLES || LIGHTMAP_VT_ENABLED
  537.     FinalizeVirtualTextureFeedback(
  538.         MaterialParameters.VirtualTextureFeedback,
  539.         MaterialParameters.SvPosition,
  540.         ShadingModelContext.Opacity,
  541.         View.FrameNumber,
  542.         View.VTFeedbackBuffer
  543.     );
  544. #endif
  545. }

移动端的BasePassPS的处理过程比较复杂，步骤繁多，主要有：解压插值数据，获取并计算材质属性，计算并缓村GBuffer，处理或调整GBuffer数据，计算前向渲染分支的光照（平行光、局部光），计算距离场、CSM等阴影，计算天空光，处理静态光照、非直接光和IBL，计算雾效，以及处理水体、头发、薄层透明度等特殊着色模型。

由于标准16位浮点数（FP16）可表示的最小值是1.0224=5.96⋅10−81.0224=5.96⋅10−8，而后续的光照计算涉及到粗糙度的4次方运算（1.0Roughness41.0Roughness4），为了防止除零错误，需要将粗糙度截取到0.0156250.015625（0.0156254=5.96⋅10−80.0156254=5.96⋅10−8）。

GBuffer.Roughness = max(0.015625, GetMaterialRoughness(PixelMaterialInputs));

这也警示我们在开发移动端的渲染特性时，需要格外注意和把控数据精度，否则在低端设备经常由于数据精度不足而出现各种奇葩的画面异常。

虽然上面的代码较多，但由很多宏控制着，实际渲染单个材质所需的代码可能只是其中的很小的一个子集。比如说，默认支持4个局部光源，但如果在工程配置（下图）中可以设为2或更少，则实际执行的光源指令少了很多。

如果是前向渲染分支，则GBuffer的很多处理将被忽略；如果是延迟渲染分支，则平行光、局部光源的计算将被忽略，由延迟渲染Pass的shader执行。

下面对重要接口EncodeGBuffer做剖析：

  1. void EncodeGBuffer(
  2.     FGBufferData GBuffer,
  3.     out float4 OutGBufferA,
  4.     out float4 OutGBufferB,
  5.     out float4 OutGBufferC,
  6.     out float4 OutGBufferD,
  7.     out float4 OutGBufferE,
  8.     out float4 OutGBufferVelocity,
  9.     float QuantizationBias = 0        // -0.5 to 0.5 random float. Used to bias quantization.
  10.     )
  11. {
  12.     if (GBuffer.ShadingModelID == SHADINGMODELID_UNLIT)
  13.     {
  14.         OutGBufferA = 0;
  15.         SetGBufferForUnlit(OutGBufferB);
  16.         OutGBufferC = 0;
  17.         OutGBufferD = 0;
  18.         OutGBufferE = 0;
  19.     }
  20.     else
  21.     {
  22.         // GBufferA: 八面体压缩后的法线, 预计算阴影因子, 逐物体数据.
  23. #if MOBILE_DEFERRED_SHADING
  24.         OutGBufferA.rg = UnitVectorToOctahedron( normalize(GBuffer.WorldNormal) ) * 0.5f + 0.5f;
  25.         OutGBufferA.b = GBuffer.PrecomputedShadowFactors.x;
  26.         OutGBufferA.a = GBuffer.PerObjectGBufferData;
  27. #else
  28.         (......)
  29. #endif
  30.  
  31.         // GBufferB: 金属度, 高光度, 粗糙度, 着色模型, 其它Mask.
  32.         OutGBufferB.r = GBuffer.Metallic;
  33.         OutGBufferB.g = GBuffer.Specular;
  34.         OutGBufferB.b = GBuffer.Roughness;
  35.         OutGBufferB.a = EncodeShadingModelIdAndSelectiveOutputMask(GBuffer.ShadingModelID, GBuffer.SelectiveOutputMask);
  36.  
  37.         // GBufferC: 基础色, AO或非直接光.
  38.         OutGBufferC.rgb = EncodeBaseColor( GBuffer.BaseColor );
  39.  
  40. #if ALLOW_STATIC_LIGHTING
  41.         // No space for AO. Multiply IndirectIrradiance by AO instead of storing.
  42.         OutGBufferC.a = EncodeIndirectIrradiance(GBuffer.IndirectIrradiance * GBuffer.GBufferAO) + QuantizationBias * (1.0 / 255.0);
  43. #else
  44.         OutGBufferC.a = GBuffer.GBufferAO;
  45. #endif
  46.  
  47.         OutGBufferD = GBuffer.CustomData;
  48.         OutGBufferE = GBuffer.PrecomputedShadowFactors;
  49.     }
  50.  
  51. #if WRITES_VELOCITY_TO_GBUFFER
  52.     OutGBufferVelocity = GBuffer.Velocity;
  53. #else
  54.     OutGBufferVelocity = 0;
  55. #endif
  56. }

在默认光照模型(DefaultLit)下，BasePass输出的结果有以下几种纹理：

12.3.3.3 MobileDeferredShading

移动端延迟光照的VS和PC端是一样的，都是DeferredLightVertexShaders.usf，但PS不一样，用的是MobileDeferredShading.usf。由于VS和PC一样，且没有特殊的操作，此处就忽略，如果有兴趣的同学可以看第五篇的小节5.5.3.1 DeferredLightVertexShader。

下面直接分析PS代码：

  1. // Engine\Shaders\Private\MobileDeferredShading.usf
  2.  
  3. (......)
  4.  
  5. // 移动端光源数据结构体.
  6. struct FMobileLightData
  7. {
  8.     float3 Position;
  9.     float  InvRadius;
  10.     float3 Color;
  11.     float  FalloffExponent;
  12.     float3 Direction;
  13.     float2 SpotAngles;
  14.     float SourceRadius;
  15.     float SpecularScale;
  16.     bool bInverseSquared;
  17.     bool bSpotLight;
  18. };
  19.  
  20. // 获取GBuffer数据.
  21. void FetchGBuffer(in float2 UV, out float4 GBufferA, out float4 GBufferB, out float4 GBufferC, out float4 GBufferD, out float SceneDepth)
  22. {
  23.     // Vulkan的子pass获取数据.
  24. #if VULKAN_PROFILE
  25.     GBufferA = VulkanSubpassFetch1(); 
  26.     GBufferB = VulkanSubpassFetch2(); 
  27.     GBufferC = VulkanSubpassFetch3(); 
  28.     GBufferD = 0;
  29.     SceneDepth = ConvertFromDeviceZ(VulkanSubpassDepthFetch());
  30.     // Metal的子pass获取数据.
  31. #elif METAL_PROFILE
  32.     GBufferA = SubpassFetchRGBA_1(); 
  33.     GBufferB = SubpassFetchRGBA_2(); 
  34.     GBufferC = SubpassFetchRGBA_3(); 
  35.     GBufferD = 0; 
  36.     SceneDepth = ConvertFromDeviceZ(SubpassFetchR_4());
  37.     // 其它平台(DX, OpenGL)的子pass获取数据.
  38. #else
  39.     GBufferA = Texture2DSampleLevel(MobileSceneTextures.GBufferATexture, MobileSceneTextures.GBufferATextureSampler, UV, 0); 
  40.     GBufferB = Texture2DSampleLevel(MobileSceneTextures.GBufferBTexture, MobileSceneTextures.GBufferBTextureSampler, UV, 0);
  41.     GBufferC = Texture2DSampleLevel(MobileSceneTextures.GBufferCTexture, MobileSceneTextures.GBufferCTextureSampler, UV, 0);
  42.     GBufferD = 0;
  43.     SceneDepth = ConvertFromDeviceZ(Texture2DSampleLevel(MobileSceneTextures.SceneDepthTexture, MobileSceneTextures.SceneDepthTextureSampler, UV, 0).r);
  44. #endif
  45. }
  46.  
  47. // 解压GBuffer数据.
  48. FGBufferData DecodeGBufferMobile(
  49.     float4 InGBufferA,
  50.     float4 InGBufferB,
  51.     float4 InGBufferC,
  52.     float4 InGBufferD)
  53. {
  54.     FGBufferData GBuffer;
  55.     GBuffer.WorldNormal = OctahedronToUnitVector( InGBufferA.xy * 2.0f - 1.0f );
  56.     GBuffer.PrecomputedShadowFactors = InGBufferA.z;
  57.     GBuffer.PerObjectGBufferData = InGBufferA.a;  
  58.     GBuffer.Metallic    = InGBufferB.r;
  59.     GBuffer.Specular    = InGBufferB.g;
  60.     GBuffer.Roughness    = max(0.015625, InGBufferB.b);
  61.     // Note: must match GetShadingModelId standalone function logic
  62.     // Also Note: SimpleElementPixelShader directly sets SV_Target2 ( GBufferB ) to indicate unlit.
  63.     // An update there will be required if this layout changes.
  64.     GBuffer.ShadingModelID = DecodeShadingModelId(InGBufferB.a);
  65.     GBuffer.SelectiveOutputMask = DecodeSelectiveOutputMask(InGBufferB.a);
  66.     GBuffer.BaseColor = DecodeBaseColor(InGBufferC.rgb);
  67. #if ALLOW_STATIC_LIGHTING
  68.     GBuffer.GBufferAO = 1;
  69.     GBuffer.IndirectIrradiance = DecodeIndirectIrradiance(InGBufferC.a);
  70. #else
  71.     GBuffer.GBufferAO = InGBufferC.a;
  72.     GBuffer.IndirectIrradiance = 1;
  73. #endif
  74.     GBuffer.CustomData = HasCustomGBufferData(GBuffer.ShadingModelID) ? InGBufferD : 0;
  75.     return GBuffer;
  76. }
  77.  
  78. // 直接光照.
  79. half3 GetDirectLighting(
  80.     FMobileLightData LightData, 
  81.     FMobileShadingModelContext ShadingModelContext, 
  82.     FGBufferData GBuffer, 
  83.     float3 WorldPosition, 
  84.     half3 CameraVector)
  85. {
  86.     half3 DirectLighting = 0;
  87.     
  88.     float3 ToLight = LightData.Position - WorldPosition;
  89.     float DistanceSqr = dot(ToLight, ToLight);
  90.     float3 L = ToLight * rsqrt(DistanceSqr);
  91.     
  92.     // 光源衰减.
  93.     float Attenuation = 0.0;
  94.     if (LightData.bInverseSquared)
  95.     {
  96.         // Sphere falloff (technically just 1/d2 but this avoids inf)
  97.         Attenuation = 1.0f / (DistanceSqr + 1.0f);
  98.         Attenuation *= Square(saturate(1 - Square(DistanceSqr * Square(LightData.InvRadius))));
  99.     }
  100.     else
  101.     {
  102.         Attenuation = RadialAttenuation(ToLight * LightData.InvRadius, LightData.FalloffExponent);
  103.     }
  104.  
  105.     // 聚光灯衰减.
  106.     if (LightData.bSpotLight)
  107.     {
  108.         Attenuation *= SpotAttenuation(L, -LightData.Direction, LightData.SpotAngles);
  109.     }
  110.     
  111.     // 如果衰减不为0, 则计算直接光照.
  112.     if (Attenuation > 0.0)
  113.     {
  114.         half3 H = normalize(CameraVector + L);
  115.         half NoL = max(0.0, dot(GBuffer.WorldNormal, L));
  116.         half NoH = max(0.0, dot(GBuffer.WorldNormal, H));
  117.         FMobileDirectLighting Lighting = MobileIntegrateBxDF(ShadingModelContext, GBuffer, NoL, CameraVector, H, NoH);
  118.         DirectLighting = (Lighting.Diffuse + Lighting.Specular * LightData.SpecularScale) * (LightData.Color * (1.0 / PI) * Attenuation);
  119.     }
  120.     return DirectLighting;
  121. }
  122.  
  123. // 光照函数.
  124. half ComputeLightFunctionMultiplier(float3 WorldPosition);
  125. // 使用光网格添加局部光照, 不支持动态阴影, 因为需要逐光源阴影图.
  126. half3 GetLightGridLocalLighting(const FCulledLightsGridData InLightGridData, ...);
  127.  
  128. // 平行光的PS主入口.
  129. void MobileDirectLightPS(
  130.     noperspective float4 UVAndScreenPos : TEXCOORD0, 
  131.     float4 SvPosition : SV_POSITION, 
  132.     out half4 OutColor : SV_Target0)
  133. {
  134.     // 恢复(读取)GBuffer数据.
  135.     FGBufferData GBuffer = (FGBufferData)0;
  136.     float SceneDepth = 0; 
  137.     {
  138.         float4 GBufferA = 0; 
  139.         float4 GBufferB = 0; 
  140.         float4 GBufferC = 0; 
  141.         float4 GBufferD = 0;
  142.         FetchGBuffer(UVAndScreenPos.xy, GBufferA, GBufferB, GBufferC, GBufferD, SceneDepth);
  143.         GBuffer = DecodeGBufferMobile(GBufferA, GBufferB, GBufferC, GBufferD);
  144.     }
  145.     
  146.     // 计算基础向量.
  147.     float2 ScreenPos = UVAndScreenPos.zw;
  148.     float3 WorldPosition = mul(float4(ScreenPos * SceneDepth, SceneDepth, 1), View.ScreenToWorld).xyz;
  149.     half3 CameraVector = normalize(View.WorldCameraOrigin - WorldPosition);
  150.     half NoV = max(0, dot(GBuffer.WorldNormal, CameraVector));
  151.     half3 ReflectionVector = GBuffer.WorldNormal * (NoV * 2.0) - CameraVector;
  152.     
  153.     half3 Color = 0;
  154.     // Check movable light param to determine if we should be using precomputed shadows
  155.     half Shadow = LightFunctionParameters2.z > 0.0f ? 1.0f : GBuffer.PrecomputedShadowFactors.r;
  156.  
  157.     // CSM阴影.
  158. #if APPLY_CSM
  159.     float  ShadowPositionZ = 0;
  160.     float4 ScreenPosition = SvPositionToScreenPosition(float4(SvPosition.xyz,SceneDepth));
  161.     float ShadowMap = MobileDirectionalLightCSM(ScreenPosition.xy, SceneDepth, ShadowPositionZ);
  162.     Shadow = min(ShadowMap, Shadow);
  163. #endif
  164.  
  165.     // 着色模型上下文.
  166.     FMobileShadingModelContext ShadingModelContext = (FMobileShadingModelContext)0;
  167.     {
  168.         half DielectricSpecular = 0.08 * GBuffer.Specular;
  169.         ShadingModelContext.DiffuseColor = GBuffer.BaseColor - GBuffer.BaseColor * GBuffer.Metallic;    // 1 mad
  170.         ShadingModelContext.SpecularColor = (DielectricSpecular - DielectricSpecular * GBuffer.Metallic) + GBuffer.BaseColor * GBuffer.Metallic;    // 2 mad
  171.         // 计算环境的BRDF.
  172.         ShadingModelContext.SpecularColor = GetEnvBRDF(ShadingModelContext.SpecularColor, GBuffer.Roughness, NoV);
  173.     }
  174.     
  175.     // 局部光源.
  176.     float2 LocalPosition = SvPosition.xy - View.ViewRectMin.xy;
  177.     uint GridIndex = ComputeLightGridCellIndex(uint2(LocalPosition.x, LocalPosition.y), SceneDepth);
  178.     // 分簇光源
  179. #if USE_CLUSTERED
  180.     {
  181.         const uint EyeIndex = 0;
  182.         const FCulledLightsGridData CulledLightGridData = GetCulledLightsGrid(GridIndex, EyeIndex);
  183.         Color += GetLightGridLocalLighting(CulledLightGridData, ShadingModelContext, GBuffer, WorldPosition, CameraVector, EyeIndex, 0);
  184.     }
  185. #endif
  186.             
  187.     // 计算平行光.
  188.     half NoL = max(0, dot(GBuffer.WorldNormal, MobileDirectionalLight.DirectionalLightDirectionAndShadowTransition.xyz));
  189.     half3 H = normalize(CameraVector + MobileDirectionalLight.DirectionalLightDirectionAndShadowTransition.xyz);
  190.     half NoH = max(0, dot(GBuffer.WorldNormal, H));
  191.     FMobileDirectLighting Lighting;
  192.     Lighting.Specular = ShadingModelContext.SpecularColor * CalcSpecular(GBuffer.Roughness, NoH);
  193.     Lighting.Diffuse = ShadingModelContext.DiffuseColor;
  194.     Color += (Shadow * NoL) * MobileDirectionalLight.DirectionalLightColor.rgb * (Lighting.Diffuse + Lighting.Specular * MobileDirectionalLight.DirectionalLightDistanceFadeMADAndSpecularScale.z);
  195.  
  196.     // 处理反射(IBL, 反射捕捉器).
  197. #if APPLY_REFLECTION
  198.     uint NumCulledEntryIndex = (ForwardLightData.NumGridCells + GridIndex) * NUM_CULLED_LIGHTS_GRID_STRIDE;
  199.     uint NumLocalReflectionCaptures = min(ForwardLightData.NumCulledLightsGrid[NumCulledEntryIndex + 0], ForwardLightData.NumReflectionCaptures);
  200.     uint DataStartIndex = ForwardLightData.NumCulledLightsGrid[NumCulledEntryIndex + 1];
  201.  
  202.     float3 SpecularIBL = CompositeReflectionCapturesAndSkylight(
  203.         1.0f,
  204.         WorldPosition,
  205.         ReflectionVector,//RayDirection,
  206.         GBuffer.Roughness,
  207.         GBuffer.IndirectIrradiance,
  208.         1.0f,
  209.         0.0f,
  210.         NumLocalReflectionCaptures,
  211.         DataStartIndex,
  212.         0,
  213.         true);
  214.         
  215.     Color += SpecularIBL * ShadingModelContext.SpecularColor;
  216. #elif APPLY_SKY_REFLECTION
  217.     float SkyAverageBrightness = 1.0f;
  218.     float3 SpecularIBL = GetSkyLightReflection(ReflectionVector, GBuffer.Roughness, SkyAverageBrightness);
  219.     SpecularIBL *= ComputeMixingWeight(GBuffer.IndirectIrradiance, SkyAverageBrightness, GBuffer.Roughness);
  220.     Color += SpecularIBL * ShadingModelContext.SpecularColor;
  221. #endif
  222.     // 天空光漫反射.
  223.     half3 SkyDiffuseLighting = GetSkySHDiffuseSimple(GBuffer.WorldNormal);
  224.     Color+= SkyDiffuseLighting * half3(View.SkyLightColor.rgb) * ShadingModelContext.DiffuseColor * GBuffer.GBufferAO;
  225.     half LightAttenuation = ComputeLightFunctionMultiplier(WorldPosition);
  226.  
  227. #if USE_PREEXPOSURE
  228.     // MobileHDR applies PreExposure in tonemapper
  229.     LightAttenuation *= View.PreExposure;    
  230. #endif
  231.                     
  232.     OutColor.rgb = Color.rgb * LightAttenuation;
  233.     OutColor.a = 1;
  234. }
  235.  
  236. // 局部光源的PS主入口.
  237. void MobileRadialLightPS(
  238.     float4 InScreenPosition : TEXCOORD0,
  239.     float4 SVPos            : SV_POSITION,
  240.     out half4 OutColor        : SV_Target0
  241. )
  242. {
  243.     FGBufferData GBuffer = (FGBufferData)0;
  244.     float SceneDepth = 0; 
  245.     {
  246.         float2 ScreenUV = InScreenPosition.xy / InScreenPosition.w * View.ScreenPositionScaleBias.xy + View.ScreenPositionScaleBias.wz;
  247.         float4 GBufferA = 0;  
  248.         float4 GBufferB = 0; 
  249.         float4 GBufferC = 0; 
  250.         float4 GBufferD = 0;
  251.         FetchGBuffer(ScreenUV, GBufferA, GBufferB, GBufferC, GBufferD, SceneDepth);
  252.         GBuffer = DecodeGBufferMobile(GBufferA, GBufferB, GBufferC, GBufferD);
  253.     }
  254.     
  255.     // With a perspective projection, the clip space position is NDC * Clip.w
  256.     // With an orthographic projection, clip space is the same as NDC
  257.     float2 ClipPosition = InScreenPosition.xy / InScreenPosition.w * (View.ViewToClip[3][3] < 1.0f ? SceneDepth : 1.0f);
  258.     float3 WorldPosition = mul(float4(ClipPosition, SceneDepth, 1), View.ScreenToWorld).xyz;
  259.     half3 CameraVector = normalize(View.WorldCameraOrigin - WorldPosition);
  260.     half NoV = max(0, dot(GBuffer.WorldNormal, CameraVector));
  261.     
  262.     // 组装光源数据结构体.
  263.     FMobileLightData LightData = (FMobileLightData)0;
  264.     {
  265.         LightData.Position = DeferredLightUniforms.Position;
  266.         LightData.InvRadius = DeferredLightUniforms.InvRadius;
  267.         LightData.Color = DeferredLightUniforms.Color;
  268.         LightData.FalloffExponent = DeferredLightUniforms.FalloffExponent;
  269.         LightData.Direction = DeferredLightUniforms.Direction;
  270.         LightData.SpotAngles = DeferredLightUniforms.SpotAngles;
  271.         LightData.SpecularScale = 1.0;
  272.         LightData.bInverseSquared = INVERSE_SQUARED_FALLOFF; 
  273.         LightData.bSpotLight = IS_SPOT_LIGHT; 
  274.     }
  275.  
  276.     FMobileShadingModelContext ShadingModelContext = (FMobileShadingModelContext)0;
  277.     {
  278.         half DielectricSpecular = 0.08 * GBuffer.Specular;
  279.         ShadingModelContext.DiffuseColor = GBuffer.BaseColor - GBuffer.BaseColor * GBuffer.Metallic;    // 1 mad
  280.         ShadingModelContext.SpecularColor = (DielectricSpecular - DielectricSpecular * GBuffer.Metallic) + GBuffer.BaseColor * GBuffer.Metallic;    // 2 mad
  281.         // 计算环境BRDF.
  282.         ShadingModelContext.SpecularColor = GetEnvBRDF(ShadingModelContext.SpecularColor, GBuffer.Roughness, NoV);
  283.     }
  284.     
  285.     // 计算直接光.
  286.     half3 Color = GetDirectLighting(LightData, ShadingModelContext, GBuffer, WorldPosition, CameraVector);
  287.     
  288.     // IES, 光照函数.
  289.     half LightAttenuation = ComputeLightProfileMultiplier(WorldPosition, DeferredLightUniforms.Position, -DeferredLightUniforms.Direction, DeferredLightUniforms.Tangent);
  290.     LightAttenuation*= ComputeLightFunctionMultiplier(WorldPosition);
  291.  
  292. #if USE_PREEXPOSURE
  293.     // MobileHDR applies PreExposure in tonemapper
  294.     LightAttenuation*= View.PreExposure;    
  295. #endif
  296.  
  297.     OutColor.rgb = Color * LightAttenuation;
  298.     OutColor.a = 1;
  299. }

以上可知，平行光和局部光源的PS是不同的入口，主要是因为两者的区别较大，平行光直接在主入口计算光照，附带计算了反射（IBL、捕捉器）、天空光漫反射；而局部光源会构建一个光源结构体，进入直接光计算函数，最后处理局部光源特有的IES和光照函数。

另外，获取GBuffer时，采用了SubPass特有的读取模式，不同的着色平台有所不同：

  1. // Vulkan
  2. [[vk::input_attachment_index(1)]]
  3. SubpassInput<float4> GENERATED_SubpassFetchAttachment0;
  4. #define VulkanSubpassFetch0() GENERATED_SubpassFetchAttachment0.SubpassLoad()
  5.  
  6. // Metal
  7. Texture2D<float4> gl_LastFragDataRGBA_1;
  8. #define SubpassFetchRGBA_1() gl_LastFragDataRGBA_1.Load(uint3(0, 0, 0), 0)
  9.  
  10. // DX / OpenGL
  11. Texture2DSampleLevel(GBufferATexture, GBufferATextureSampler, UV, 0);

团队招员

博主所在的团队正在用UE4开发一种全新的沉浸式体验产品，急需各路豪士一同加入，共谋宏图大业。目前急招以下职位：

  • UE逻辑开发。
  • UE引擎程序。
  • UE图形渲染。
  • TA（技术向、美术向）。

要求：对技术有热情，扎实的技术基础，良好的沟通和合作能力，有UE使用经验或移动端开发经验者更佳。

有意向或想了解更多的请添加博主微信：81079389（注明博客园求职），或者发简历到博主邮箱：81079389#qq.com（#换成@）。

静待各路英雄豪杰相会。

特别说明

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

参考文献

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/108599
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号