Customize renderpipeline

如何自訂渲染管線?
廖峻漢

Outline
1. 什麼是SRP?
2. 渲染流程介紹
3. 手動渲染流程（不依賴SRP，自訂渲染流程架構的方法）
4. 如何實作自己的SRP?
5. 如何擴展URP?
6. 如何客製URP Renderer?
7. 如何設定SetRenderTarget與深度貼圖
8. URP光照性能測試
9. ShaderBatcher介紹及性能比較
10.其他相關

什麼是SRP?
讓使用者利用統一的C#腳本來跟底層繪圖API溝通，無需關心任何跨平台硬體的問
題，並減化了跟硬體API溝通的流程。
沒SRP：自動渲染
SRP：手動渲染

為什麼要SRP?
主要是讓研發者有更多的控制權，因為一種渲染流程沒辦法為所有的遊戲做最佳化，
他主要可以：
● 根據需求在指令級別上定義渲染流程
● 提供SRP batcher低階渲染循環（可在渲染過程CPU加速到1.2~4倍）● 精確控制渲染順序
● 兼顧性能及效果

Shader渲染流程-傳統認知的流程
單一物件的渲染流程，是面向GPU的，代碼是Shader

SRP渲染流程
管理複數物件渲染流程，面向是CPU，代碼是C#
設定Camera矩陣參數
設定畫布（Set Rendertarget）清除畫布（Clear Rendertarget）
畫物件們（DrawRenders）
視野剔除（Viewfrustum culling），過濾
畫面看得到的部份

SRP渲染流程 - 常見的渲染物件流程（畫物件們）
畫不透明物件們
畫透明物件們
畫天空盒（在不透明之後畫，可以避免over draw）
畫UI們

手動渲染流程（沒有SRP的狀況下）
蒐集場景物件建立畫布
剔除處理清除畫布畫不透明物件們
畫透明物件們
畫天空盒
將畫面Blit到屏幕
黑色：初始化流程
藍色：渲染物件流程
OnPostRender

蒐集場景物件-手動渲染
//利用FindObjectsOfTypeAll將物件蒐集到_objectInfos這個容器
MeshRenderer[] meshRenders =
Resources.FindObjectsOfTypeAll<MeshRenderer>();
_objectInfos = new ObjectInfo[meshRenders.Length];
for (int index = 0; index < meshRenders.Length; ++index)
{
MeshFilter meshFilter =
meshRenders[index].gameObject.GetComponent<MeshFilter>();
_objectInfos[index] = new ObjectInfo(
meshRenders[index].transform,
meshRenders[index].sharedMaterial,
meshFilter.sharedMesh);

建立畫布-手動渲染
//建立一個可以縮放尺吋的畫布，如果縮放比有改變，就重建這個畫布
int width = (int)(renderScale * _targetCamera.pixelWidth);
int height = (int)(renderScale * _targetCamera.pixelHeight);
if ((_width != width) || (_height != height)){
if (_canvas){
RenderTexture.ReleaseTemporary(_canvas);
_canvas = null;
}
_width = width;
_height = height;
_canvas = RenderTexture.GetTemporary(_width, _height, 32);
}

剔除處理-手動渲染
//1.取得ViewFrustum的六個Plane
_frustumPlanes = GeometryUtility.CalculateFrustumPlanes(_camera);
//2.針對蒐集好的_objectInfos進行碰撞檢測
for (int index = 0; index < _objectInfos.Length; ++index)
{
if (GeometryUtility.TestPlanesAABB(_cameraFrustumPlanes,
_objectInfos[index].bound))
{
//3.針對在視野範圍內的物件，進行物件整理…

視野範圍內的物件整理-手動渲染
if (GeometryUtility.TestPlanesAABB(_cameraFrustumPlanes,
_objectInfos[index].bound)){
//使用Shader名稱，來判斷要放到非透明或透明物件容器
shaderName = _objectInfos[index].material.shader.name;
//這裡沒有front to back，目前無法減少over draw, to do.
if (shaderName == "Unlit/OpaqueUnLight")
_opaqueCullResults.AddLast(_objectInfos[index]);
//這裡沒有做Back to front，當重疊時會造成顯示不正確, to do.
else if (shaderName == "Unlit/Transparent")
_alphaCullResults.AddLast(_objectInfos[index]);

畫不透明物件們-手動渲染
//使用DrawMeshNow來畫不透明物件
var element = _opaqueCullResults.GetEnumerator();
while (element.MoveNext())
{
element.Current.material.SetPass(0);
Graphics.DrawMeshNow(element.Current.mesh,
element.Current.transform.localToWorldMatrix);
}
element.Dispose();

畫天空盒-手動渲染
//接下來是畫天空盒，在opaque之後畫可以避免over drawing.
_skyBoxMaterial.SetPass(0);
Matrix4x4 matrix = Matrix4x4.identity;
matrix.SetTRS(Vector3.zero, Quaternion.identity, Vector3.one * 500.0f);
Graphics.DrawMeshNow(_skyBoxMesh, matrix);

畫透明物件們-手動渲染
//最後一樣是使用DrawMeshNow來畫透明物件
element = _alphaCullResults.GetEnumerator();
while (element.MoveNext())
{
element.Current.material.SetPass(0);
Graphics.DrawMeshNow(element.Current.mesh,
element.Current.transform.localToWorldMatrix);
}
element.Dispose();

動態調整Scale Ratio的畫面

如何實作自己的SRP?
1. 繼承RenderPipeline，並宣告及覆寫Render函式
2. 繼承RenderPipelineAsset，並實作CreatePipeline函式，並在其中New自己
的RenderPipeline。
3. 實作Render函式，其回傳值會有一個ScriptRenderContex介面及Camera陣
列
4. 利用Camera的資料及ScriptRenderContext實作自己的渲染流程函式

SRP基礎架構(採用資料驅動方式）- Custom SRP
RenderPipelineAsset
CreatePipeline ()
{
產生你的RenderPipeline
}
RenderPipeline
Render( ScriptableRenderContext
renderContext, Camera[] cameras)
{
實作你的繪圖處流程
}

建立及指定PipelineAsset - Custom SRP
利用CreateAsset的方式，來建立PipelineAsset

設定PipelineAsset
接下來就可以利用C#動態切換GraphicSetting.renderPipelineAsset或直接指定
Graphics的設定

Render實作 - Custom SRP
//覆寫Render函式，這邊會針對每個Camerav進行渲染，一般來說，至少有一個//
工具及一個GameView
protected override void Render(ScriptableRenderContext renderContext,
Camera[] cameras)
{
BeginFrameRendering(renderContext, cameras);
foreach (var camera in cameras)
RenderSingleCamera(renderContext, camera);
EndFrameRendering(renderContext, cameras);
}

RenderSingleCamera實作-Custom SRP
private void RenderSingleCamera(ScriptableRenderContext context, Camera
camera){
ScriptableCullingParameters cullingParameters;
//1.取得剔除參數
if (!camera.TryGetCullingParameters(false, out cullingParameters))
return;
…
//2.依照剔除參數取得剔除結果
CullingResults cullResults = context.Cull(ref cullingParameters);
...
}

RenderSingleCamera實作 - Custom SRP
//3.取得渲染貼圖（我們要作畫的畫布）
cameraBuffer.GetTemporaryRT(_cameraColorAttachment.id,
descriptor, FilterMode.Bilinear);
//4.指定畫布
cameraBuffer.SetRenderTarget(colorIdentifiy,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
//5.清除畫布
cameraBuffer.ClearRenderTarget(true, true, Color.clear);
//6.渲染物件處理
...
//7.釋放RenderTexture
cameraBuffer.ReleaseTemporaryRT(_cameraColorAttachment.id);

渲染非透明物件 - Custom SRP
//1.設定非透明物件參數
SortingSettings sortingSettings = new SortingSettings(camera){
criteria = SortingCriteria.CommonOpaque};
var drawSettings = new DrawingSettings(
new ShaderTagId("SRPDefaultUnlit"), sortingSettings);
var filterSettings = new FilteringSettings(RenderQueueRange.opaque);
//2.畫非透明物件
context.DrawRenderers(
cullResults, ref drawSettings, ref filterSettings);
//3.拷貝目前的渲染結果
_debugRTProcessor.Add(ref context, ref colorIdentifiy);

渲染天空盒 - Custom SRP
//1.畫天空盒
context.DrawSkybox(camera);

渲染透明物件 - Custom SRP
//1.設定透明物件的參數
sortingSettings.criteria = SortingCriteria.CommonTransparent;
filterSettings.renderQueueRange = RenderQueueRange.transparent;
//2.畫透明物件
context.DrawRenderers(
cullResults, ref drawSettings, ref filterSettings);

渲染回屏幕（最後的步驟） - Custom SRP
//將目前的RenderTextures的結果，畫回屏幕
//如果是GameView的話，用一個FullScreen Quad畫回FrameBuffer
if (camera.cameraType == CameraType.Game){
...
cameraBuffer.DrawMesh(fullscreenMesh, Matrix4x4.identity,
blitMaterial); }
else
{
//如果是EditorView的話，直接call Blit，因為工具的Camera是指向一個
//RenderTexture，不這麼做，會導致Gizmos畫不出來
cameraBuffer.Blit(colorIdentifiy,
BuiltinRenderTextureType.CameraTarget);
}

Editor Gizmos繪製與後置特效 - Custom SRP
//畫在後置特效之前的Gizmos
#if UNITY_EDITOR
if (UnityEditor.Handles.ShouldRenderGizmos())
context.DrawGizmos(camera, GizmoSubset.PreImageEffects);
#endif
//後置特效處理，在這裡做…
//畫在後置特效之後的Gizmos
#if UNITY_EDITOR
if (UnityEditor.Handles.ShouldRenderGizmos())
context.DrawGizmos(camera, GizmoSubset.PostImageEffects);
#endif

什麼是URP?
1. 之前叫LWRP（Light weight rendering pipeline），現在改名叫URP
（Universal rendering pipeline-通用渲染管線）
2. URP提供了一個少量多光源One Pass處理的架構，不會像之前預設的前向渲
染管線用AddPass來處理多光源，造成draw calls增加的問題。
3. 2019.3之後的版本，LWRP改成URP，目標是要讓URP成為預設管線流程
Unity 2019.3 beta is now available
4. URP對LWRP做了最大的更動部份，是將PostProcessing從外部集成到內部中，
統一用一個PostProcessPass來處理。

URP Light Limits
URP Feature comparison table
Main Direction Light 1
Per Object 8(4 for GLES2), support point and spot
Per Camera 256 ( 32 on mobile platforms)

如何擴展URP?
1. 只寫自己的Shader
2. 擴充RenderFeature
3. 寫自己的Renderer取代ForwardRenderer

寫URP認得的Shader-寫自己的Shader
Pass
{
…
//加了這一行，URP就認得你的Pass
Tags{"LightMode" = "UniversalForward"}
HLSLPROGRAM
#pragma prefer_hlslcc gles
#pragma exclude_renderers d3d11_9x
ENDHLSL
...
}

如何擴充RenderFeature（勾邊效果的例子）
//繼承ScriptableRendererFeature，並在AddRenderPasses這個地方來
//加入DrawOutLinePass
public class ExtendFeature : ScriptableRendererFeature{
public override void AddRenderPasses(ScriptableRenderer renderer,
ref RenderingData renderingData)
{
//添加勾邊效果Pass
_drawOutLinePass.Setup();
renderer.EnqueuePass(_drawOutLinePass);
}
}

RenderFeature-勾邊效果Pass
class DrawOutLinePass : ScriptableRenderPass{
public DrawOutLinePass()
{
//1.設定renderPassEvent參數（控制在opaque物件之前畫）
renderPassEvent =
RenderPassEvent.BeforeRenderingOpaques;
}
public void Setup()
{
//2.設定tagID（只針對Pass tag LightMode為OutLine的pass才
畫）
_shaderTagId = new ShaderTagId("OutLine");

RenderFeature-勾邊效果Shader pass
//畫的時候是以Pass為單位，不是物件
Pass
{
Name "Outline"
Tags{"LightMode" = "OutLine"}
…
}

RenderFeature-勾邊效果Pass
//針對_shaderTagId，在畫非透明物件之前進行渲染
public override void Execute(ScriptableRenderContext context,
ref RenderingData renderingData)
{
using (new ProfilingSample(command, _profilerTag)){
....
var drawSettings = CreateDrawingSettings(_shaderTagId,
ref renderingData, sortFlags);
context.DrawRenderers(renderingData.cullResults, ref
drawSettings,
ref _filteringSettings);
}
context.ExecuteCommandBuffer(command);
CommandBufferPool.Release(command);
}

添加RenderFeature到ForwardRenderData
只要繼承ScriptableRendererFeature，就會自動出現在RenderData介面

如何寫自己的URP Renderer?
例子：平滑消失在天空盒處理（使用深度貼圖，實作遠處物件可以平滑消失在視野
範之外）
目標：
1. 移除用不到的Passses
2. 直接使用深度貼圖，不拷貝深度貼圖及預渲染深度
3. 使用自製的DissolveSkyBoxPass流程，不走內建的DrawSkyboxPass

管線流程
畫非透明物件
畫平滑消失天空盒
FinalPass
（將結果繪製到veiwport）

URP所使用的passes
ColorGradingLutPass m_ColorGradingLutPass;
DepthOnlyPass m_DepthPrepass;
MainLightShadowCasterPass m_MainLightShadowCasterPass;
AdditionalLightsShadowCasterPass m_AdditionalLightsShadowCasterPass;
ScreenSpaceShadowResolvePass m_ScreenSpaceShadowResolvePass;
DrawObjectsPass m_RenderOpaqueForwardPass;//畫不透明的pass
DrawSkyboxPass m_DrawSkyboxPass;
CopyDepthPass m_CopyDepthPass;
CopyColorPass m_CopyColorPass;
DrawObjectsPass m_RenderTransparentForwardPass;
InvokeOnRenderObjectCallbackPass m_OnRenderObjectCallbackPass;
PostProcessPass m_PostProcessPass;
PostProcessPass m_FinalPostProcessPass;
FinalBlitPass m_FinalBlitPass;//畫回屏幕的pass
CapturePass m_CapturePass;

Passes流程設定相關代碼
//加入opaque object pass
EnqueuePass(m_opaqueObjectPass);
…
//加入dissolve skybox pass
EnqueuePass(m_drawSkyBoxPass);
…
//加入final pass(將結果繪製到veiwport)
EnqueuePass(m_finalBlitPass);
…

DissolveSkyBoxPass處理流程
生成拷貝目前畫面的渲染貼圖將目前結果Blit（bit-block-transfert）到渲染貼圖
指定RenderTarget，這裡只指定
ColorBuffer，不指定DepthBuffer，
這樣就可以直接使用深度貼圖而
不用cpoy
（Input != Output）
渲染天空盒
回復原本
RenderTarget設定-
Color及Depth Buffer

DissolveSkyBoxPass處理流程-相關代碼
…
//1.生成拷貝目前畫面的渲染貼圖
cmd.GetTemporaryRT(m_copyBackgroundRT.id, descriptor, FilterMode.Bilinear);
//2.將目前的結果Blit到渲染貼圖
cmd.Blit(m_colorTargetIdentifier, m_copyBackgroundRT.Identifier());
//3.只指定ColorBuffer，不指定DepthBuffer
//這樣就可以直接使用深度貼圖，而不用cpoy(Input不可以等於Output）
CoreUtils.SetRenderTarget(cmd, m_colorTargetIdentifier, ClearFlag.None,
Color.clear, 0, CubemapFace.Unknown, -1);
…

DissolveSkyBoxPass處理流程-相關代碼
//4.渲染天空盒
context.DrawSkybox(renderingData.cameraData.camera);
//5.還原預設指定的RenderTarget（Color及Depth Buffer）
if(isEnable){
CoreUtils.SetRenderTarget(cmd, m_colorTargetIdentifier,
m_depthTargetIdentifier, ClearFlag.None, Color.clear, 0,
CubemapFace.Unknown, -1);
}

Dissolve Skybox Shader
…
//原生的深度貼圖，不用拷貝，直接傳入
uniform sampler2D _CameraDepthAttachment;
//在畫天空盒之前，拷貝目前畫面的結果
uniform sampler2D _CopyBackgroundRT;
float depth = Linear01Depth(tex2D(_CameraDepthAttachment, screenUV).r);
if (depth >= _PassOffDepthRatio){
float depthLength = 1.0 - _PassOffDepthRatio;
float deltaLength = depthLength - (1.0 - depth);
//依照深度值相關參數，計算混色
result = lerp(result, skyColor, 1.0 - (depthLength - deltaLength) /
depthLength);
}
…

Scale render
● 就是把物件們渲染到一張比例比屏幕還要小的一張渲染貼圖，最後再用一個full
screen quad把結果畫到屏幕上，藉此減少所要處理的像素數量。
● 此種方式比較適合行動裝置，因為通常這類的裝置的DPI比較高，但是面板尺
吋比較小，會造成處理過多的像素，另外也可以依照機器的規格來決定縮方的
比例。
● 由於UI的顯示通常會想保持原生解析度（為了維持字的銳利度之類的），所以
通常會跟這張集成的渲染貼圖脫勾，最後直接畫到屏幕上。
● URP就是採用這樣的做法。

什麼是Camera Stacking?
● URP提供了另一套機制來處理多Camera疊合渲染，叫camera stacking，比
較常應用在為了UI及3D物件做排序處理的需求。
● URP原本就是將3D及UI的解析度拆開的設計（UI是用原生解析度），但只有
Overlay才不受影響。

預設 URP Camera Stacking的UI會糊掉

客製 URP Camera Stacking處理，UI糊

客製 URP Camera Stacking相關代碼
if (renderingData.cameraData.renderType == CameraRenderType.Overlay){
//直接指定ViewPort為RenderTarget.
ConfigureCameraTarget(BuiltinRenderTextureType.CameraTarget,
BuiltinRenderTextureType.CameraTarget);
//預設URP不會自動清ViewPort depth buffer, 所以加了一個pass來做清
除.
EnqueuePass(m_clearDepthWhenRenderCameraStackPass);
EnqueuePass(m_opaqueObjectPass);
EnqueuePass(m_transparentObjectPass);
//直接畫到view port，所以不用FinalBlitPass
return;
}

在URP下實現平面反射的流程
1. 注冊RenderPipelineManager.beginCameraRendering。
2. 建立反射RenderTexture。
3. 在beginCameraRendering處理反射。
4. 在渲染反射物件時，將反射RenderTexture帶入shader，並使用
ComputeScreenPos算出屏幕座標，算出uv來取出反射RenderTexture的像素
PS：整個過程是對場景渲染兩次（第一次是反射Camera，第二次是主Camera）

反射處理流程細節
//1.設定反射貼圖
SetupReflectionTexture(MainCamera);
//2.依據目前的主Camera更新反射Camera
UpdateReflectionCamera(MainCamera);
//3.呼叫URP的渲染Camera函式，並將反射Camera帶入
UniversalRenderPipeline.RenderSingleCamera(context, m_reflectionCamera);
//4.設定拍好的反射貼圖
Shader.SetGlobalTexture(m_planarReflectionTextureId, m_reflectionRT);

SetRenderTarget管理
TBDR（Tile
Base Deferred
Rendering
IR(Immediate
Rendering）
只有在畫完的時候，才會刷新到
Fragment processor（比方切換
RenderTarget的時候），所以如
何降低SetRenderTarget的次數，
變得非常重要，相關細節請參考：
针对移动端TBDR架构GPU特性的
渲染优化

Unity深度貼圖運作方式 - SetRenderTarget詳解
1. 預設渲染管線的做法：Camera.depthTextureMdoe =
DepthTextureMode.Depth or DepthTextureMode.DepthNormals
2. URP的做法：啟動Depth Texture的旗標
以上兩種方式都會經過PerDpthPass（造成draw call增加）及CopyDepthPass
（做了一次Blit操作，約1ms左右，看機型）。
有沒有使用原生NativeDepth的方式呢?其實有…就是直接指定一張深度紋理。

一般RenderTarget設定 - SetRenderTarget詳解
var descriptor = renderingData.cameraData.cameraTargetDescriptor;
//1.直接指定depthBufferBits（之後用在device ZBuffer檢查，在渲染過程中
//無法存取）
descriptor.depthBufferBits = 32;
//2.取得渲染貼圖
commandBuffer.GetTemporaryRT(m_copyBackgroundRT.id, descriptor,
FilterMode.Bilinear);
//3.指定渲染目標
CoreUtils.SetRenderTarget(cmd, m_colorTargetIdentifier, ClearFlag.None,
Color.clear, 0, CubemapFace.Unknown, -1);

自行指定深度貼圖的作法 - SetRenderTarget詳解
//1.建立深度渲染貼圖
var depthDescriptor = descriptor;
depthDescriptor.colorFormat = RenderTextureFormat.Depth;
depthDescriptor.depthBufferBits = 24;
cmd.GetTemporaryRT(m_cameraDepthAttachment.id, depthDescriptor,
FilterMode.Point);
//2.指定RenderTarget（含Color及Depth）
//m_depthTargetIdentifier，可在Shader渲染過程中直接存取
CoreUtils.SetRenderTarget(cmd, m_colorTargetIdentifier,
m_depthTargetIdentifier, ClearFlag.None, Color.clear, 0,

使用限制 - SetRenderTarget詳解
最重要的是輸入不可以等於輸出（input != output），以渲染溶解天空盒為例：
//原先的RenderTarget的設定
ConfigureCameraTarget(m_cameraColorAttachment.Identifier(),
m_cameraDepthAttachment.Identifier());
//1.將目前的結果Blit到渲染貼圖（因為input != output）
cmd.Blit(m_colorTargetIdentifier, m_copyBackgroundRT.Identifier());
//2.只指定colorBuffer，因為需要參考到深度貼圖（因為input != output）
CoreUtils.SetRenderTarget(cmd, m_colorTargetIdentifier, ClearFlag.None, Color.clear, 0,
//3.渲染天空盒
context.DrawSkybox(renderingData.cameraData.camera);

傳統Forward渲染管線有那些缺點?
1. 不支持OnePass處理多光源，透過AddPas來處理，會造成有多少光源就要做
多少次渲染。
2. 不支持SRP batcher，但目前這個不支持GLES3.0以下的硬體，詳情
SRP Batcher
3. 彈性差，只能透過Camera Event command buffer的方式來做客製化渲染，只
有一些特定的Event時機可以用。

URP光照性能測試
● 硬體：紅米Note3
● Shader：簡單的多光源Shader，沒有NormalMap，含Diffuse及Specular
● 物件數量：225個球體
● 方向光數量：1
● 點光源數量：4
● 其他：由於URP的光源資料有處理物理衰減，所以在光源表現上跟Default不太
一樣，目前Default light shader並沒有處理衰減的部份，但並不影響我們做性
能驗測。

什麼是Shader batcher?
簡單來說就是相同的Shader，可以將其mateiral的參數設定合批起來，以達到減少
跟GPU溝通的次數（提升性能），跟傳統的Mesh合批是不一樣的，所以並不能降
低draw call，而是這些draw call被合批起來做統一的material參數設定。

URP Shader Batcher性能分析（測試環境）
● 硬體：紅米Note3
● Shader：URP內建Lit Shader
● 物件數量：1600個方塊
● 方向光數量：1
● 點光源數量：4
● 其他：由於為了模擬不同material的運作，所以目前是把Dynamic batch關掉，
來驗證在無法dynamic batch（材質不同，shader相同），Shader batch還是
能在性能上提供一些優化

URP Shader Batcher性能分析（測試數據）

如何檢查Shader是否支持Shader batcher?

如何分析Shader Batcher?
Draw call數越高，代表合批效果越好

如何實作ShaderBatcher的代碼語法?
將參數包裹在CBUFFER block裡
CBUFFER_START(UnityPerMaterial)
float4 _BaseMap_ST;
half4 _BaseColor;
CBUFFER_END

為什麼要改成HLSL?
● NVIDIA停止開發CG
● HLSL Converter都有在維護，也是目前的主流
● Unity官方主推Core SRP，裡面都是hlsl，相關的HDRP及LWRP（Universal
Render Pipeline）都是基於Core SRP設計的，之後會減少維護UnityCG.cginc

什麼是HLSL語法最大的差異?
HLSLPROGRAM
#pragma prefer_hlslcc gles
#pragma exclude_renderers d3d11_9x
TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);
#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)
textureName.Sample(samplerName, coord2)
ENDHLSL
存取貼圖需要多帶一個Sampler

HLSL精度型態
不再支持fixed，多了一個real
fixed => half
half => real
float => float

HLSL精度型態（大Plane的fresnel計算精度問題）

Shader Texture參數大坑相關整理
● Blit時要將Input Texture Name改成”_MainTex”，並切記在Properties加上
_MainTex（”Albedo”，2D） = “white”{}，否則input會帶不進來。
● 用在非Blit，比方DrawMesh，切記不使用_MainTex，否則會造成texture參數
帶不進來，從LWRP的final pass的blit用的參數從”_BlitTex”，還有LWRP也把
相關的Shader參數從”_MainTex”改成”_BaseMap”就可以略知一二…

其他相關參考資料
● Custom Pipeline
● 我的MobileSRP
● UnitySRP之我見

Customize renderpipeline

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Customize renderpipeline

Similar to Customize renderpipeline (20)

Customize renderpipeline

Editor's Notes