编写脚本电脑怎么编写界面_可编写脚本的渲染管道概述

最新推荐文章于 2024-04-29 09:16:18 发布

culiao6493

最新推荐文章于 2024-04-29 09:16:18 发布

阅读量223

点赞数

文章标签：游戏 python java 游戏开发 unity

原文链接：https://blogs.unity3d.com/2018/01/31/srp-overview/

版权

编写脚本电脑怎么编写界面

The Scriptable Render Pipeline (SRP), introduced in 2018.1 beta, is a way of configuring and performing rendering in Unity that is controlled from a C# script. Before writing a custom render pipeline it’s important to understand what exactly we mean when we say render pipeline.

2018.1 Beta中引入的可脚本渲染管道(SRP)是一种在Unity中配置和执行渲染的方法，该方法由C＃脚本控制。在编写自定义渲染管道之前，重要的是要理解我们所说的渲染管道的确切含义。

什么是渲染管线 (What is a Render Pipeline)

“Render Pipeline” is an umbrella term for a number of techniques used to get objects onto the screen. It encompasses, at a very high level:

“渲染管道”是用于将对象放置到屏幕上的多种技术的总称。它包括一个非常高的层次：

In addition to these high level concepts each responsibility can be broken down further depending on how you want to execute them. For example rendering objects could be performed using:

除了这些高级概念之外，还可以根据您要执行它们的方式进一步分解每个责任。例如，可以使用以下命令执行渲染对象：

Multi-pass rendering
多遍渲染
Single-pass
单程
Deferred
递延

When writing a custom SRP, these are the kind of decisions that you need to make. Each technique has a number of tradeoffs that you should consider.

在编写自定义SRP时，您需要做出这些决定。每种技术都有许多您应该考虑的权衡。

演示地址

示范项目 (Demo Project)

All the features discussed in this post are covered in a demo project located on GitHub

这篇文章中讨论的所有功能都位于GitHub上的演示项目中

渲染入口点 (The Rendering entry point)

When using SRP you need to define a class that controls rendering; this is the Render Pipeline you will be creating. The entry point is a call to “Render” which takes the render context (described below) and a list of cameras to render.

使用SRP时，您需要定义一个控制渲染的类。这是您将要创建的渲染管线。入口点是对“渲染”的调用，该调用获取渲染上下文(如下所述)和要渲染的摄像机列表。

public class BasicPipeInstance : RenderPipeline

{

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

}

public class BasicPipeInstance : RenderPipeline

{

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

}

渲染管道上下文 (The Render Pipeline Context)

SRP renders using the concept of delayed execution. As a user you build up a list of commands and then execute them. The object that you use to build up these commands is called the ‘ScriptableRenderContext’. When you have populated the context with operations, then you can call ‘Submit’ to submit all the queued up draw calls.

SRP使用延迟执行的概念进行渲染。以用户身份建立命令列表，然后执行它们。用于构建这些命令的对象称为'ScriptableRenderContext' 。用操作填充上下文后，可以调用“提交”以提交所有排队的绘制调用。

An example of this is clearing a render target using a command buffer that is executed by the render context:

一个示例是使用由渲染上下文执行的命令缓冲区清除渲染目标：

// Create a new command buffer that can be used

// to issue commands to the render context

var cmd = new CommandBuffer();

// issue a clear render target command

cmd.ClearRenderTarget(true, false, Color.green);

// queue the command buffer

context.ExecuteCommandBuffer(cmd);

// Create a new command buffer that can be used

// to issue commands to the render context

var cmd = new CommandBuffer ( ) ;

// issue a clear render target command

cmd . ClearRenderTarget ( true , false , Color . green ) ;

// queue the command buffer

context . ExecuteCommandBuffer ( cmd ) ;

A not very exciting example of a render pipeline :)

渲染管道的一个不太令人兴奋的示例:)

Here’s a complete render pipeline that simply clears the screen.

这是一个完整的渲染管道，可以简单地清除屏幕。

剔除 (Culling)

Culling is the process of figuring out what to render on the the screen.

剔除是弄清楚要在屏幕上渲染的内容的过程。

In Unity Culling encompasses:

在Unity中，Culling包括：

Occlusion culling: Calculating which objects are hidden behind other objects and excluding them from rendering. For more information see the Occlusion Culling docs.
遮挡剔除：计算哪些对象隐藏在其他对象后面，并将其从渲染中排除。有关更多信息，请参见遮挡剔除文档。

When rendering starts, the first thing that needs to be calculated is what to render. This involves taking the camera and performing a cull operation from the perspective of the camera. The cull operation returns a list of objects and lights that are valid to render for the camera. These object are then used later in the render pipeline.

渲染开始时，首先需要计算的是渲染内容。这涉及拿起相机并从相机的角度执行剔除操作。剔除操作将返回可用于摄像机渲染的对象和光源的列表。这些对象随后将在渲染管道中使用。

选择SRP (Culling in SRP)

In SRP, you generally perform object rendering from the perspective of a Camera. This is the same camera object that Unity uses for built-in rendering. SRP provides a number of API’s to begin culling with. Generally the flow looks as follows:

在SRP中，通常从“摄影机”的角度执行对象渲染。这是Unity用于内置渲染的相机对象。 SRP提供了许多开始使用的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);

// 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 ) ;

The cull results that get populated can now be used to perform rendering.

现在，可以使用填充的剔除结果执行渲染。

画画 (Drawing)

Now that we have a set of cull results, we can render them to the screen.

现在我们有了一组剔除结果，我们可以将它们渲染到屏幕上。

But there are so many ways that things can be configured, so a number of decisions need to be made up front. Many of these decisions will be driven by:

但是，可以通过多种方式配置事物，因此需要预先制定许多决策。其中许多决定将由以下因素驱动：

For example, think of a mobile 2D sidescroller game vs a PC high end first person game. These games have vastly different constraints so will have vastly different render pipelines. Some concrete examples of real decisions that may be made:

例如，考虑一下移动2D横屏游戏与PC高端第一人称游戏。这些游戏的约束条件差异很大，因此渲染管线也将差异很大。可能做出的实际决策的一些具体示例：

Making these decisions when writing a render pipeline will help you determine many of the constraints that are placed when authoring it.

在编写渲染管线时做出这些决定将有助于您确定创作管线时所施加的许多约束。

For now, we’re going to demonstrate a simple renderer with no lights that can render some of the objects opaque.

现在，我们将演示一个没有光源的简单渲染器，该渲染器可以使某些对象不透明。

过滤：渲染桶和图层 (Filtering: Render Buckets and Layers)

Generally, when rendering object has a specific classification, they are opaque, transparent, sub surface, or any number of other categories. Unity uses a concept of queues for representing when an object should be rendered, these queues form buckets that objects will be placed into (sourced from the material on the object). When rendering is called from SRP, you specify which range of buckets to use.

通常，当渲染对象具有特定的分类时，它们是不透明的，透明的，子表面或任意数量的其他类别。 Unity使用队列的概念来表示何时应渲染对象，这些队列形成了将要放置对象的存储桶(来自对象上的材料)。从SRP调用渲染时，您可以指定要使用的存储桶范围。

In addition to buckets, standard Unity layers can also be used for filtering.

除存储桶外，标准Unity层也可用于过滤。

This provides the ability for additional filtering when drawing objects via SRP.

通过SRP绘制对象时，这提供了附加过滤的功能。

// 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;

// 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)

Using filtering and culling determines what should be rendered, but then we need to determine how it should be rendered. SRP provides a variety of options to configure how your objects that pass filtering should be rendered. The structure used to configure this data is the ‘DrawRenderSettings’ structure. This structure allows for a number of things to be configured:

使用过滤和剔除可以确定应呈现的内容，但随后我们需要确定应如何呈现。 SRP提供了多种选项来配置应如何呈现通过过滤的对象。用于配置此数据的结构是“ DrawRenderSettings”结构。这种结构允许配置许多东西：

// Create the draw render settings

// note that it takes a shader pass name

var drs = new DrawRendererSettings(Camera.current, 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;

// Create the draw render settings

// note that it takes a shader pass name

var drs = new DrawRendererSettings ( Camera . current , 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)

Now we have the three things we need to issue a draw call:

现在，我们具有发出抽签所需的三件事：

We can issue a draw call! Like all things in SRP, a draw call is issued as a call into the context. In SRP you normally don’t render individual meshes, instead you issue a call that renders a large number of them in one go. This reduces script execution overhead as well as allows fast jobified execution on the CPU.

我们可以发出抽奖电话！像SRP中的所有内容一样，绘制调用作为对上下文的调用而发出。在SRP中，通常不渲染单个网格，而是发出一个可一次性渲染大量网格的调用。这样可以减少脚本执行的开销，并允许在CPU上快速执行作业。

To issue a draw call we combine the functions that we have been building up.

为了发出抽签通知，我们结合了已经建立的功能。