Scriptable Render Pipeline

SRP的核心是一堆API集合，使得整个渲染过程及相关配置暴露给用户，使得用户可以精确地控制项目的渲染流程。

SRP API为原有的Unity构件提供了一些新的接口(interface):

Lights
Materials
Cameras
Command Buffers

但是和Unity交互的方式变了。由于性能原因，当自定义SRP时，通常是在使用一组renderers(这里的render应该是指MeshRender之类的)，而不是一个。

What is a Render Pipeline

什么是渲染管线？“Render Pipeline”，渲染管线，是许多技术的总称，用于把物体(Objects，比如三维物体)显示到屏幕上。概括性讲，渲染管线包括：

Culling
Rendering Objects
Post processing

除了上面这些高级概念，渲染管线的每一个环节或者子任务，还可以进一步分解，你可以选择如何去完成它。例如：可以使用一下方式渲染物体:

Multi-pass rendering - one pass per object per light 即一个物体被"渲染多次(多个pass)"，每一个影响到该物体的light，都在一个单独的pass中渲染
Single-pass - one pass per object 即每个物体中一个pass中渲染，也即一个物体只“渲染”一次
Deferred - Render surface properties to a g-buffer, perform screen space lighting 即先在g-buffer pass中把法线等几何属性“渲染”到g-buffer纹理中，然后在Lighting pass中进行屏幕空间的光照计算

当自定义SRP时，上面这些就是需要你做出决策的地方。每种技术都有许多权衡(trade offs)需要考虑，没有一种技术是完美的。

What is a Scriptable Render Pipeline

如果Render Pipeline是为了完成渲染而需要执行的许多步骤，则Scriptable Render Pipeline是一个可以让用户使用Unity的C#脚本控制的pipeline，用于以用户定义的方式完成渲染。

The Problem (Built-in pipelines存在的问题)

之前Unity已经提供了一些built-in pipelines，一些适合用于手游或者VR游戏(如 forward renderer)，另一些用于高级终端游戏上，如主机游戏 (如 deferred renderer)。这些Unity内置的拿来即用的渲染方案具有通用性，“黑盒性”，但也有一些缺陷：

只能用于做它们设计好的任务
它们被设计的非常具有通用性，功能过于宽泛，意味着它们可以完成任何需求，但没有任何完美精通或者适用的地方。(But they need to do everything, they are masters at nothing)
它们不是那可配置的。(black box with injection points)
扩展和修改容易产生错误(小的内部改变可能产生大的外部影响)
有许多bugs无法修复(因为擅自“修复”可能会破坏项目)。

The Solution (用SRP来解决)

SRP API的出现就是为了解决上面的问题。它把渲染部分从Unity内置的“黑盒”概念转变成了用户可控的每个项目可脚本控制的概念。也就是说，使用SRP，每一个项目都可以有一个符合自己的特色的渲染管线。使用SRP api可以对how rendering进行精细粒度的自定义，从低层到高层(form the low level to the high level)。

SRP 概述

从高层次用户角度来看，SRP可以分为两部分：SRP asset和SRP instance。在制作custom rendering pipeline时，两者都很重要。

SRP Asset

SRP Asset是project asset，表示渲染管线的一个具体配置，例如：

是否支持阴影？
使用什么级别的shader quality?
shadow distance值是多少？
默认材质配置

用户想要控制的东西可以保存为配置的一部分，基本上是任何需要序列化的东西。SRP Asset表示SRP的类型(type)和其中的设置(settings)。

SRP Instance

SRP Instance是实际完成渲染的类(class)。当Unity发现SRP被启用时，Unity会查看当前选择的SRP Asset并且要求它提供一个渲染实例("rendering instance")，即SRP asset要返回一个实例包含一个'Render'函数。通常这个实例会缓存许多对应SRP asset中的配置信息。

SRP instance表示一个已知的渲染管线配置(pipeline configuration)。从渲染器角度看，调用动作可能如下：

Clearing the framebuffer
Performing scene culling
Rendering sets of objects
Doing blits from one frame buffer to another
Rendering shadows
Applying post process effects

SRP instance表示一个实际将要被实施的渲染(actual rendering)。

SRP Asset

SRP Asset包含一个接口，用户用它配置渲染管线。当Unity第一次开始渲染时，Unity会调用 SRP Asset上的InternalCreatePipeline函数，然后，SRP Asset会返回一个可用的SRP instance。

SRP Asset是一个ScriptableObject，这意味着它可以保存为一个project asset(见下面的BasicAssetPipe)。

为了使项目启用一个SRP asset，需要在Edit>Project Settings>Graphics的Scriptable Render Pipeline Settings栏中选择你生成的SRP Asset。这样设置好后，Unity就会使用SRP Asset中的配置进行rendering了，而不再使用standard Unity rendering。

An Simple Asset Example

SRP Asset的职责是包含配置信息和返回一个渲染实例。若SRP Asset上的某个设置发生了变化，则所有由这个Asset创建的实例会被销毁，并且用新的设置创建新的实例，来进行下一帧的渲染。

下面的代码是一个简单的pipeline asset类。它包含一个color，由它返回的实例用来清除屏幕。CreateBasicAssetPipeline是在Editor下使用的一个工具，在菜单栏上点SRP-Demo，再点01 - Create Basic Asset Pipeline即可创建一个BasicAssetPipe对应的SRP Asset，它在项目中的路径为Assets/BasicAssetPipe.asset。

[ExecuteInEditMode]

public class BasicAssetPipe : RenderPipelineAsset

{

    public Color clearColor = Color.green;

#if UNITY_EDITOR

    // Call to create a simple pipeline

    [UnityEditor.MenuItem("SRP-Demo/01 - Create Basic Asset Pipeline")]

    static void CreateBasicAssetPipeline()

    {

        var instance = ScriptableObject.CreateInstance<BasicAssetPipe>();

        UnityEditor.AssetDatabase.CreateAsset(instance, "Assets/BasicAssetPipe.asset");

    }

#endif

    // Function to return an instance of this pipeline

    protected override IRenderPipeline InternalCreatePipeline()

    {

        return new BasicPipeInstance(clearColor);

    }

}

A complete asset example

除了返回实例和保存配置，SRP asset也用于做许多辅助功能，如：

Default material to use when creating 3d objects
Default material to use when creating 2d objects
Default material to use when creating particle systems
Default material to use when creating terrain systems

The Rendering entry point

SRP asset控制渲染配置，但是最终渲染是由SRP Render Pipeline instance完成的。SRP instance对应的类(class)是渲染逻辑(rendering logic)实际存在的地方。

SRP Instance的最简单的形式仅仅包含一个Render函数。Render函数有两个参数:

一个ScriptableRenderContext类型的参数，相当于一个队列，其中的元素是command buffer，可以把将要完成的渲染操作入队(enqueue)。
一个相机数组Camera[]，表示已经启用的，用于渲染的相机列表。

A basic pipeline

下面这个BasicPipeInstance类就是上面的BasicAssetPipe的IRenderPipeline函数返回的SRP Instance。

public class BasicPipeInstance : RenderPipeline

{

    private Color m_ClearColor = Color.black;

    public BasicPipeInstance(Color clearColor)

    {

        m_ClearColor = clearColor;

    }

    public override void Render(ScriptableRenderContext context, Camera[] cameras)

    {

        // does not so much yet :()

        base.Render(context, cameras);

        // clear buffers to the configured color

        var cmd = new CommandBuffer();

        cmd.ClearRenderTarget(true, true, m_ClearColor);

        context.ExecuteCommandBuffer(cmd);

        cmd.Release();

        context.Submit();

    }

}

上面代码所表示的pipeline仅仅完成了简单地用给定的颜色(由SRP Asset指定)清除屏幕的操作。注意:

Unity现有的CommandBuffers被用来完成许多操作(此处用于完成ClearRenderTarget)。
CommandBuffers是根据于对应的context进行调试的(scheduled)。
“渲染”的最后一步是调用Submit，它将(引起)执行所有入队的command。

RenderPipeline的Render函数就是你输入渲染代码，来自定义renderer的地方。Culling, Filtering, Changing render targets和Drawing操作都是在这里完成的。这就是你构造渲染器的地方!

SRP使用延迟执行的方式进行渲染。作为用户，你的任务就是用ScriptableRenderContext构建一个命令队列，然后去执行它们。

Culling

Culling(剔出)是指明将要在屏幕上渲染什么的过程。

Unity的Culling过程包含两类：

Frustum culling: 视锥体剔出，计算在视锥体内的物体(这些物体会被渲染)。
Occlusion culling: 遮挡剔出，计算被别的物体遮挡的物体，这些物体将不会被渲染。

渲染开始时，首先要计算需要渲染哪些物体。这涉及到获取相机，然后完成剔出(cull)操作(从给定相机的角度)。Culling操作返回一个对于给定相机有效的物体(objects和lights)列表，这些物体用于该相机进行后面的渲染步骤。

Culling in SRP

在SRP，用户通常站在相机的视角来渲染对象。这和Unity built-in rendering一样。SRP提供了一些有用的Culling相关的API。通常流程如下：

// Create an structure to hold the culling paramaters

ScriptableCullingParameters cullingParams;

//Populate the culling paramaters from the camera

if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))

    continue;

// if you like you can modify the culling paramaters here

cullingParams.isOrthographic = true;

// Create a structure to hold the cull results

CullResults cullResults = new CullResults();

// Perform the culling operation

CullResults.Cull(ref cullingParams, context, ref cullResults);

cullResults被用来完成接下来的rendering。

SRP Drawing

经过上面的步骤，该剔出的物体已经被剔出了，现在可把cull results渲染到屏幕上了。

需要提前做一些决策(考虑到以下因素):

完成渲染的硬件
想要实现的具体样子(specific look)和风格/感觉(feel)，即要实现的效果
项目的类型

如，一个2D手游和一个PC上的第一人称游戏所使用的渲染管线肯定会差异特别大。可能要做下面这些抉择：

HDR vs LDR
Linear vs Gamma
MSAA vs Post Process AA
PBR Materials vs Simple Materials
Lighting vs No Lighting
Lighting Technique
Shadowing Technique

目前，我们将要展示一个简单的没有光照、可以渲染一些不透明物体的渲染器。

Filtering: Render Buckets and Layers

通常，渲染对象(rendering object)有一个具体的分类：透明的、不透明的、sub surface，或者别的类型。Unity使用队列表示什么时候一个对象将会被渲染，即相同分类的对象被放在同一个队列中，这些队列也被称为“桶”(bucket)。在SRP中，用户指定使用哪些桶进行渲染。

除了“桶”的概念，标准的Unity layers也可以被使用。

这提供了额外的过滤能力。

// Get the opaque rendering filter settings

var opaqueRange = new FilterRenderersSettings();

//Set the range to be the opaque queues

opaqueRange.renderQueueRange = new RenderQueueRange()

{

    min = 0,

    max = (int)UnityEngine.Rendering.RenderQueue.GeometryLast,

};

//Include all layers

opaqueRange.layerMask = ~0;

Draw Settings: How things should be drawn

上面的filtering和culling决定了将要渲染哪些对象。接下来，我们需要决定怎样渲染它们。SRP提供了许多可配置选项。用于配置的数据结构是DrawRenderSettings。它允许配置以下选项：

Sorting - 物体渲染的顺序，如：从前到后(front to back)或者从后到前(back to front)。
Per Renderer flags - Unity应该向shader传入什么'built in'设置，包括：per object light probes, per object light maps等。
Rendering flags - 使用哪种batching算法，instancing vs non-instancing。
Shader Pass - 当前draw call应该使用哪个shader pass

// Create the draw render settings

// note that it takes a shader pass name

var drs = new DrawRendererSettings(myCamera, new ShaderPassName("Opaque"));

// enable instancing for the draw call

drs.flags = DrawRendererFlags.EnableInstancing;

// pass light probe and lightmap data to each renderer

drs.rendererConfiguration = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps;

// sort the objects like normal opaque objects

drs.sorting.flags = SortFlags.CommonOpaque;

Drawing

现在我们已经有了发起一次draw call所需要的三样东西：

Culling results (剔出结果)
Filtering rules (过滤规则)
Drawing rules (绘制规则)

下面的代码发起了一次draw call。在SRP中，你一般不渲染单独的一个或几个网格(individual meshes)，而是发起一次draw call，一次渲染一大批网格。这能减少执行开销。

发起一次draw call，需要结合上面我们已经构建的参数。

// draw all of the renderers

context.DrawRenderers(cullResults.visibleRenderers, ref drs, opaqueRange);

// submit the context, this will execute all of the queued up commands.

context.Submit();

这段代码会把对象渲染到当前绑定的渲染目标上(render target)。也可以通过command buffer来切换不同的渲染目标。

参考:

第一次发表于我的知乎专栏:https://zhuanlan.zhihu.com/p/69046003