Scriptable Render Pipeline
阅读原文时间:2023年07月09日阅读:2

Scriptable Render Pipeline

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

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

  • Lights
  • Materials
  • Cameras
  • Command Buffers

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

什么是渲染管线?“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)需要考虑,没有一种技术是完美的。

如果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 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包含一个接口,用户用它配置渲染管线。当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

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

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

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

A basic pipeline

下面这个BasicPipeInstance类就是上面的BasicAssetPipeIRenderPipeline函数返回的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。

RenderPipelineRender函数就是你输入渲染代码,来自定义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来切换不同的渲染目标。

参考:

  1. Scriptable Render Pipeline Wiki
  2. Unity SRP Overview: Scriptable Render Pipeline

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

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器