一. scriptableRenderPass类
我认为此类是最重要的类， 它的生命周期函数不多，如下图所示：
重要的是图中每个函数的调用时机和位置。
如果调用时机和位置搞清除明白了，那么URP管线的宏观调用逻辑主线就把握住了！！
其实在源码中，ScriptableRenderPass类中已经有很详细的说明了
它的注释都是英文版的，但是说的很中肯（看不懂的词，用翻译工具翻一下（我用的有道词典）），这里拷贝的源码：
二.ScriptableRenderer类
在URP中，ForwardRenderer类继承 ScriptableRenderer， 同时在ScriptableRenderer的生命周期函数中“不同的时机和位置 调用ScriptableRenderPass中的生命周期函数”，从宏观来看scriptableRenderPass的生命周期函数调用请参考此处
Renderer中用到的数据
下面是两个基类的具体定义，copy from UPR管线
using System;
using System.Collections.Generic;
using UnityEngine.Scripting.APIUpdating;
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Input requirements for <c>ScriptableRenderPass</c>.
/// </summary>
/// <seealso cref="ConfigureInput"/>
[Flags]
public enum ScriptableRenderPassInput
{
None = 0,
Depth = 1 << 0,
Normal = 1 << 1,
Color = 1 << 2,
}
// Note: Spaced built-in events so we can add events in between them
// We need to leave room as we sort render passes based on event.
// Users can also inject render pass events in a specific point by doing RenderPassEvent + offset
/// <summary>
/// Controls when the render pass executes.
/// </summary>
[MovedFrom("UnityEngine.Rendering.LWRP")] public enum RenderPassEvent
{
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering any other passes in the pipeline.
/// Camera matrices and stereo rendering are not setup this point.
/// You can use this to draw to custom input textures used later in the pipeline, f.ex LUT textures.
/// </summary>
BeforeRendering = 0,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering shadowmaps.
/// Camera matrices and stereo rendering are not setup this point.
/// </summary>
BeforeRenderingShadows = 50,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering shadowmaps.
/// Camera matrices and stereo rendering are not setup this point.
/// </summary>
AfterRenderingShadows = 100,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering prepasses, f.ex, depth prepass.
/// Camera matrices and stereo rendering are already setup at this point.
/// </summary>
BeforeRenderingPrepasses = 150,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering prepasses, f.ex, depth prepass.
/// Camera matrices and stereo rendering are already setup at this point.
/// </summary>
AfterRenderingPrePasses = 200,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering opaque objects.
/// </summary>
BeforeRenderingOpaques = 250,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering opaque objects.
/// </summary>
AfterRenderingOpaques = 300,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering the sky.
/// </summary>
BeforeRenderingSkybox = 350,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering the sky.
/// </summary>
AfterRenderingSkybox = 400,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering transparent objects.
/// </summary>
BeforeRenderingTransparents = 450,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering transparent objects.
/// </summary>
AfterRenderingTransparents = 500,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> before rendering post-processing effects.
/// </summary>
BeforeRenderingPostProcessing = 550,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering post-processing effects but before final blit, post-processing AA effects and color grading.
/// </summary>
AfterRenderingPostProcessing = 600,
/// <summary>
/// Executes a <c>ScriptableRenderPass</c> after rendering all effects.
/// </summary>
AfterRendering = 1000,
}
/// <summary>
/// <c>ScriptableRenderPass</c> implements a logical rendering pass that can be used to extend Universal RP renderer.
/// </summary>
[MovedFrom("UnityEngine.Rendering.LWRP")] public abstract partial class ScriptableRenderPass
{
public RenderPassEvent renderPassEvent { get; set; }
public RenderTargetIdentifier[] colorAttachments
{
get => m_ColorAttachments;
}
public RenderTargetIdentifier colorAttachment
{
get => m_ColorAttachments[0];
}
public RenderTargetIdentifier depthAttachment
{
get => m_DepthAttachment;
}
internal RenderBufferStoreAction[] colorStoreActions
{
get => m_ColorStoreActions;
}
internal RenderBufferStoreAction depthStoreAction
{
get => m_DepthStoreAction;
}
/// <summary>
/// The input requirements for the <c>ScriptableRenderPass</c>, which has been set using <c>ConfigureInput</c>
/// </summary>
/// <seealso cref="ConfigureInput"/>
public ScriptableRenderPassInput input
{
get => m_Input;
}
public ClearFlag clearFlag
{
get => m_ClearFlag;
}
public Color clearColor
{
get => m_ClearColor;
}
RenderBufferStoreAction[] m_ColorStoreActions = new RenderBufferStoreAction[] { RenderBufferStoreAction.Store };
RenderBufferStoreAction m_DepthStoreAction = RenderBufferStoreAction.Store;
/// A ProfilingSampler for the entire pass. Used by higher level objects such as ScriptableRenderer etc.
protected internal ProfilingSampler profilingSampler { get; set; }
internal bool overrideCameraTarget { get; set; }
internal bool isBlitRenderPass { get; set; }
RenderTargetIdentifier[] m_ColorAttachments = new RenderTargetIdentifier[]{BuiltinRenderTextureType.CameraTarget};
RenderTargetIdentifier m_DepthAttachment = BuiltinRenderTextureType.CameraTarget;
ScriptableRenderPassInput m_Input = ScriptableRenderPassInput.None;
ClearFlag m_ClearFlag = ClearFlag.None;
Color m_ClearColor = Color.black;
public ScriptableRenderPass()
{
renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
m_ColorAttachments = new RenderTargetIdentifier[]{BuiltinRenderTextureType.CameraTarget, 0, 0, 0, 0, 0, 0, 0};
m_DepthAttachment = BuiltinRenderTextureType.CameraTarget;
m_ColorStoreActions = new RenderBufferStoreAction[] { RenderBufferStoreAction.Store, 0, 0, 0, 0, 0, 0, 0 };
m_DepthStoreAction = RenderBufferStoreAction.Store;
m_ClearFlag = ClearFlag.None;
m_ClearColor = Color.black;
overrideCameraTarget = false;
isBlitRenderPass = false;
profilingSampler = new ProfilingSampler(nameof(ScriptableRenderPass));
}
/// <summary>
/// Configures Input Requirements for this render pass.
/// This method should be called inside <c>ScriptableRendererFeature.AddRenderPasses</c>.
/// </summary>
/// <param name="passInput">ScriptableRenderPassInput containing information about what requirements the pass needs.</param>
/// <seealso cref="ScriptableRendererFeature.AddRenderPasses"/>
public void ConfigureInput(ScriptableRenderPassInput passInput)
{
m_Input = passInput;
}
internal void ConfigureColorStoreAction(RenderBufferStoreAction storeAction, uint attachmentIndex = 0)
{
m_ColorStoreActions[attachmentIndex] = storeAction;
}
internal void ConfigureColorStoreActions(RenderBufferStoreAction[] storeActions)
{
int count = Math.Min(storeActions.Length, m_ColorStoreActions.Length);
for (uint i = 0; i < count; ++i)
{
m_ColorStoreActions[i] = storeActions[i];
}
}
internal void ConfigureDepthStoreAction(RenderBufferStoreAction storeAction)
{
m_DepthStoreAction = storeAction;
}
/// <summary>
/// Configures render targets for this render pass. Call this instead of CommandBuffer.SetRenderTarget.
/// This method should be called inside Configure.
/// </summary>
/// <param name="colorAttachment">Color attachment identifier.</param>
/// <param name="depthAttachment">Depth attachment identifier.</param>
/// <seealso cref="Configure"/>
public void ConfigureTarget(RenderTargetIdentifier colorAttachment, RenderTargetIdentifier depthAttachment)
{
m_DepthAttachment = depthAttachment;
ConfigureTarget(colorAttachment);
}
/// <summary>
/// Configures render targets for this render pass. Call this instead of CommandBuffer.SetRenderTarget.
/// This method should be called inside Configure.
/// </summary>
/// <param name="colorAttachment">Color attachment identifier.</param>
/// <param name="depthAttachment">Depth attachment identifier.</param>
/// <seealso cref="Configure"/>
public void ConfigureTarget(RenderTargetIdentifier[] colorAttachments, RenderTargetIdentifier depthAttachment)
{
overrideCameraTarget = true;
uint nonNullColorBuffers = RenderingUtils.GetValidColorBufferCount(colorAttachments);
if( nonNullColorBuffers > SystemInfo.supportedRenderTargetCount)
Debug.LogError("Trying to set " + nonNullColorBuffers + " renderTargets, which is more than the maximum supported:" + SystemInfo.supportedRenderTargetCount);
m_ColorAttachments = colorAttachments;
m_DepthAttachment = depthAttachment;
}
/// <summary>
/// Configures render targets for this render pass. Call this instead of CommandBuffer.SetRenderTarget.
/// This method should be called inside Configure.
/// </summary>
/// <param name="colorAttachment">Color attachment identifier.</param>
/// <seealso cref="Configure"/>
public void ConfigureTarget(RenderTargetIdentifier colorAttachment)
{
overrideCameraTarget = true;
m_ColorAttachments[0] = colorAttachment;
for (int i = 1; i < m_ColorAttachments.Length; ++i)
m_ColorAttachments[i] = 0;
}
/// <summary>
/// Configures render targets for this render pass. Call this instead of CommandBuffer.SetRenderTarget.
/// This method should be called inside Configure.
/// </summary>
/// <param name="colorAttachment">Color attachment identifier.</param>
/// <seealso cref="Configure"/>
public void ConfigureTarget(RenderTargetIdentifier[] colorAttachments)
{
ConfigureTarget(colorAttachments, BuiltinRenderTextureType.CameraTarget);
}
/// <summary>
/// Configures clearing for the render targets for this render pass. Call this inside Configure.
/// </summary>
/// <param name="clearFlag">ClearFlag containing information about what targets to clear.</param>
/// <param name="clearColor">Clear color.</param>
/// <seealso cref="Configure"/>
public void ConfigureClear(ClearFlag clearFlag, Color clearColor)
{
m_ClearFlag = clearFlag;
m_ClearColor = clearColor;
}
/// <summary>
/// This method is called by the renderer before rendering a camera
/// Override this method if you need to to configure render targets and their clear state, and to create temporary render target textures.
/// If a render pass doesn't override this method, this render pass renders to the active Camera's render target.
/// You should never call CommandBuffer.SetRenderTarget. Instead call <c>ConfigureTarget</c> and <c>ConfigureClear</c>.
/// </summary>
/// <param name="cmd">CommandBuffer to enqueue rendering commands. This will be executed by the pipeline.</param>
/// <param name="renderingData">Current rendering state information</param>
/// <seealso cref="ConfigureTarget"/>
/// <seealso cref="ConfigureClear"/>
public virtual void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{}
/// <summary>
/// This method is called by the renderer before executing the render pass.
/// Override this method if you need to to configure render targets and their clear state, and to create temporary render target textures.
/// If a render pass doesn't override this method, this render pass renders to the active Camera's render target.
/// You should never call CommandBuffer.SetRenderTarget. Instead call <c>ConfigureTarget</c> and <c>ConfigureClear</c>.
/// </summary>
/// <param name="cmd">CommandBuffer to enqueue rendering commands. This will be executed by the pipeline.</param>
/// <param name="cameraTextureDescriptor">Render texture descriptor of the camera render target.</param>
/// <seealso cref="ConfigureTarget"/>
/// <seealso cref="ConfigureClear"/>
public virtual void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{}
/// <summary>
/// Called upon finish rendering a camera. You can use this callback to release any resources created
/// by this render
/// pass that need to be cleanup once camera has finished rendering.
/// This method be called for all cameras in a camera stack.
/// </summary>
/// <param name="cmd">Use this CommandBuffer to cleanup any generated data</param>
public virtual void OnCameraCleanup(CommandBuffer cmd)
{
}
/// <summary>
/// Called upon finish rendering a camera stack. You can use this callback to release any resources created
/// by this render pass that need to be cleanup once all cameras in the stack have finished rendering.
/// This method will be called once after rendering the last camera in the camera stack.
/// Cameras that don't have an explicit camera stack are also considered stacked rendering.
/// In that case the Base camera is the first and last camera in the stack.
/// </summary>
/// <param name="cmd">Use this CommandBuffer to cleanup any generated data</param>
public virtual void OnFinishCameraStackRendering(CommandBuffer cmd)
{}
/// <summary>
/// Execute the pass. This is where custom rendering occurs. Specific details are left to the implementation
/// </summary>
/// <param name="context">Use this render context to issue any draw commands during execution</param>
/// <param name="renderingData">Current rendering state information</param>
public abstract void Execute(ScriptableRenderContext context, ref RenderingData renderingData);
/// <summary>
/// Add a blit command to the context for execution. This changes the active render target in the ScriptableRenderer to
/// destination.
/// </summary>
/// <param name="cmd">Command buffer to record command for execution.</param>
/// <param name="source">Source texture or target identifier to blit from.</param>
/// <param name="destination">Destination texture or target identifier to blit into. This becomes the renderer active render target.</param>
/// <param name="material">Material to use.</param>
/// <param name="passIndex">Shader pass to use. Default is 0.</param>
/// <seealso cref="ScriptableRenderer"/>
public void Blit(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier destination, Material material = null, int passIndex = 0)
{
ScriptableRenderer.SetRenderTarget(cmd, destination, BuiltinRenderTextureType.CameraTarget, clearFlag, clearColor);
cmd.Blit(source, destination, material, passIndex);
}
/// <summary>
/// Creates <c>DrawingSettings</c> based on current the rendering state.
/// </summary>
/// <param name="shaderTagId">Shader pass tag to render.</param>
/// <param name="renderingData">Current rendering state.</param>
/// <param name="sortingCriteria">Criteria to sort objects being rendered.</param>
/// <returns></returns>
/// <seealso cref="DrawingSettings"/>
public DrawingSettings CreateDrawingSettings(ShaderTagId shaderTagId, ref RenderingData renderingData, SortingCriteria sortingCriteria)
{
Camera camera = renderingData.cameraData.camera;
SortingSettings sortingSettings = new SortingSettings(camera) { criteria = sortingCriteria };
DrawingSettings settings = new DrawingSettings(shaderTagId, sortingSettings)
{
perObjectData = renderingData.perObjectData,
mainLightIndex = renderingData.lightData.mainLightIndex,
enableDynamicBatching = renderingData.supportsDynamicBatching,
// Disable instancing for preview cameras. This is consistent with the built-in forward renderer. Also fixes case 1127324.
enableInstancing = camera.cameraType == CameraType.Preview ? false : true,
};
return settings;
}
/// <summary>
/// Creates <c>DrawingSettings</c> based on current rendering state.
/// </summary>
/// /// <param name="shaderTagIdList">List of shader pass tag to render.</param>
/// <param name="renderingData">Current rendering state.</param>
/// <param name="sortingCriteria">Criteria to sort objects being rendered.</param>
/// <returns></returns>
/// <seealso cref="DrawingSettings"/>
public DrawingSettings CreateDrawingSettings(List<ShaderTagId> shaderTagIdList,
ref RenderingData renderingData, SortingCriteria sortingCriteria)
{
if (shaderTagIdList == null || shaderTagIdList.Count == 0)
{
Debug.LogWarning("ShaderTagId list is invalid. DrawingSettings is created with default pipeline ShaderTagId");
return CreateDrawingSettings(new ShaderTagId("UniversalPipeline"), ref renderingData, sortingCriteria);
}
DrawingSettings settings = CreateDrawingSettings(shaderTagIdList[0], ref renderingData, sortingCriteria);
for (int i = 1; i < shaderTagIdList.Count; ++i)
settings.SetShaderPassName(i, shaderTagIdList[i]);
return settings;
}
public static bool operator <(ScriptableRenderPass lhs, ScriptableRenderPass rhs)
{
return lhs.renderPassEvent < rhs.renderPassEvent;
}
public static bool operator >(ScriptableRenderPass lhs, ScriptableRenderPass rhs)
{
return lhs.renderPassEvent > rhs.renderPassEvent;
}
}
}
using System;
using System.Diagnostics;
using System.Collections.Generic;
using Unity.Collections;
using UnityEngine.Profiling;
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Class <c>ScriptableRenderer</c> implements a rendering strategy. It describes how culling and lighting works and
/// the effects supported.
///
/// A renderer can be used for all cameras or be overridden on a per-camera basis. It will implement light culling and setup
/// and describe a list of <c>ScriptableRenderPass</c> to execute in a frame. The renderer can be extended to support more effect with additional
/// <c>ScriptableRendererFeature</c>. Resources for the renderer are serialized in <c>ScriptableRendererData</c>.
///
/// he renderer resources are serialized in <c>ScriptableRendererData</c>.
/// <seealso cref="ScriptableRendererData"/>
/// <seealso cref="ScriptableRendererFeature"/>
/// <seealso cref="ScriptableRenderPass"/>
/// </summary>
public abstract partial class ScriptableRenderer : IDisposable
{
private static class Profiling
{
private const string k_Name = nameof(ScriptableRenderer);
public static readonly ProfilingSampler setPerCameraShaderVariables = new ProfilingSampler($"{k_Name}.{nameof(SetPerCameraShaderVariables)}");
public static readonly ProfilingSampler sortRenderPasses = new ProfilingSampler($"Sort Render Passes");
public static readonly ProfilingSampler setupLights = new ProfilingSampler($"{k_Name}.{nameof(SetupLights)}");
public static readonly ProfilingSampler setupCamera = new ProfilingSampler($"Setup Camera Parameters");
public static readonly ProfilingSampler addRenderPasses = new ProfilingSampler($"{k_Name}.{nameof(AddRenderPasses)}");
public static readonly ProfilingSampler clearRenderingState = new ProfilingSampler($"{k_Name}.{nameof(ClearRenderingState)}");
public static readonly ProfilingSampler internalStartRendering = new ProfilingSampler($"{k_Name}.{nameof(InternalStartRendering)}");
public static readonly ProfilingSampler internalFinishRendering = new ProfilingSampler($"{k_Name}.{nameof(InternalFinishRendering)}");
public static class RenderBlock
{
private const string k_Name = nameof(RenderPassBlock);
public static readonly ProfilingSampler beforeRendering = new ProfilingSampler($"{k_Name}.{nameof(RenderPassBlock.BeforeRendering)}");
public static readonly ProfilingSampler mainRenderingOpaque = new ProfilingSampler($"{k_Name}.{nameof(RenderPassBlock.MainRenderingOpaque)}");
public static readonly ProfilingSampler mainRenderingTransparent = new ProfilingSampler($"{k_Name}.{nameof(RenderPassBlock.MainRenderingTransparent)}");
public static readonly ProfilingSampler afterRendering = new ProfilingSampler($"{k_Name}.{nameof(RenderPassBlock.AfterRendering)}");
}
public static class RenderPass
{
private const string k_Name = nameof(ScriptableRenderPass);
public static readonly ProfilingSampler configure = new ProfilingSampler($"{k_Name}.{nameof(ScriptableRenderPass.Configure)}");
}
}
/// <summary>
/// Override to provide a custom profiling name
/// </summary>
protected ProfilingSampler profilingExecute { get; set; }
/// <summary>
/// Configures the supported features for this renderer. When creating custom renderers
/// for Universal Render Pipeline you can choose to opt-in or out for specific features.
/// </summary>
public class RenderingFeatures
{
/// <summary>
/// This setting controls if the camera editor should display the camera stack category.
/// Renderers that don't support camera stacking will only render camera of type CameraRenderType.Base
/// <see cref="CameraRenderType"/>
/// <seealso cref="UniversalAdditionalCameraData.cameraStack"/>
/// </summary>
public bool cameraStacking { get; set; } = false;
/// <summary>
/// This setting controls if the Universal Render Pipeline asset should expose MSAA option.
/// </summary>
public bool msaa { get; set; } = true;
}
/// <summary>
/// The renderer we are currently rendering with, for low-level render control only.
/// <c>current</c> is null outside rendering scope.
/// Similar to https://docs.unity3d.com/ScriptReference/Camera-current.html
/// </summary>
internal static ScriptableRenderer current = null;
/// <summary>
/// Set camera matrices. This method will set <c>UNITY_MATRIX_V</c>, <c>UNITY_MATRIX_P</c>, <c>UNITY_MATRIX_VP</c> to camera matrices.
/// Additionally this will also set <c>unity_CameraProjection</c> and <c>unity_CameraProjection</c>.
/// If <c>setInverseMatrices</c> is set to true this function will also set <c>UNITY_MATRIX_I_V</c> and <c>UNITY_MATRIX_I_VP</c>.
/// This function has no effect when rendering in stereo. When in stereo rendering you cannot override camera matrices.
/// If you need to set general purpose view and projection matrices call <see cref="SetViewAndProjectionMatrices(CommandBuffer, Matrix4x4, Matrix4x4, bool)"/> instead.
/// </summary>
/// <param name="cmd">CommandBuffer to submit data to GPU.</param>
/// <param name="cameraData">CameraData containing camera matrices information.</param>
/// <param name="setInverseMatrices">Set this to true if you also need to set inverse camera matrices.</param>
public static void SetCameraMatrices(CommandBuffer cmd, ref CameraData cameraData, bool setInverseMatrices)
{
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, cameraData.xr.renderTargetIsRenderTexture);
return;
}
#endif
Matrix4x4 viewMatrix = cameraData.GetViewMatrix();
Matrix4x4 projectionMatrix = cameraData.GetProjectionMatrix();
// TODO: Investigate why SetViewAndProjectionMatrices is causing y-flip / winding order issue
// for now using cmd.SetViewProjecionMatrices
//SetViewAndProjectionMatrices(cmd, viewMatrix, cameraData.GetDeviceProjectionMatrix(), setInverseMatrices);
cmd.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
if (setInverseMatrices)
{
Matrix4x4 gpuProjectionMatrix = cameraData.GetGPUProjectionMatrix();
Matrix4x4 viewAndProjectionMatrix = gpuProjectionMatrix * viewMatrix;
Matrix4x4 inverseViewMatrix = Matrix4x4.Inverse(viewMatrix);
Matrix4x4 inverseProjectionMatrix = Matrix4x4.Inverse(gpuProjectionMatrix);
Matrix4x4 inverseViewProjection = inverseViewMatrix * inverseProjectionMatrix;
// There's an inconsistency in handedness between unity_matrixV and unity_WorldToCamera
// Unity changes the handedness of unity_WorldToCamera (see Camera::CalculateMatrixShaderProps)
// we will also change it here to avoid breaking existing shaders. (case 1257518)
Matrix4x4 worldToCameraMatrix = Matrix4x4.Scale(new Vector3(1.0f, 1.0f, -1.0f)) * viewMatrix;
Matrix4x4 cameraToWorldMatrix = worldToCameraMatrix.inverse;
cmd.SetGlobalMatrix(ShaderPropertyId.worldToCameraMatrix, worldToCameraMatrix);
cmd.SetGlobalMatrix(ShaderPropertyId.cameraToWorldMatrix, cameraToWorldMatrix);
cmd.SetGlobalMatrix(ShaderPropertyId.inverseViewMatrix, inverseViewMatrix);
cmd.SetGlobalMatrix(ShaderPropertyId.inverseProjectionMatrix, inverseProjectionMatrix);
cmd.SetGlobalMatrix(ShaderPropertyId.inverseViewAndProjectionMatrix, inverseViewProjection);
}
// TODO: missing unity_CameraWorldClipPlanes[6], currently set by context.SetupCameraProperties
}
/// <summary>
/// Set camera and screen shader variables as described in https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
/// </summary>
/// <param name="cmd">CommandBuffer to submit data to GPU.</param>
/// <param name="cameraData">CameraData containing camera matrices information.</param>
void SetPerCameraShaderVariables(CommandBuffer cmd, ref CameraData cameraData)
{
using var profScope = new ProfilingScope(cmd, Profiling.setPerCameraShaderVariables);
Camera camera = cameraData.camera;
Rect pixelRect = cameraData.pixelRect;
float renderScale = cameraData.isSceneViewCamera ? 1f : cameraData.renderScale;
float scaledCameraWidth = (float)pixelRect.width * renderScale;
float scaledCameraHeight = (float)pixelRect.height * renderScale;
float cameraWidth = (float)pixelRect.width;
float cameraHeight = (float)pixelRect.height;
// Use eye texture's width and height as screen params when XR is enabled
if(cameraData.xr.enabled)
{
scaledCameraWidth = (float)cameraData.cameraTargetDescriptor.width;
scaledCameraHeight = (float)cameraData.cameraTargetDescriptor.height;
cameraWidth = (float)cameraData.cameraTargetDescriptor.width;
cameraHeight = (float)cameraData.cameraTargetDescriptor.height;
}
if (camera.allowDynamicResolution)
{
scaledCameraWidth *= ScalableBufferManager.widthScaleFactor;
scaledCameraHeight *= ScalableBufferManager.heightScaleFactor;
}
float near = camera.nearClipPlane;
float far = camera.farClipPlane;
float invNear = Mathf.Approximately(near, 0.0f) ? 0.0f : 1.0f / near;
float invFar = Mathf.Approximately(far, 0.0f) ? 0.0f : 1.0f / far;
float isOrthographic = camera.orthographic ? 1.0f : 0.0f;
// From http://www.humus.name/temp/Linearize%20depth.txt
// But as depth component textures on OpenGL always return in 0..1 range (as in D3D), we have to use
// the same constants for both D3D and OpenGL here.
// OpenGL would be this:
// zc0 = (1.0 - far / near) / 2.0;
// zc1 = (1.0 + far / near) / 2.0;
// D3D is this:
float zc0 = 1.0f - far * invNear;
float zc1 = far * invNear;
Vector4 zBufferParams = new Vector4(zc0, zc1, zc0 * invFar, zc1 * invFar);
if (SystemInfo.usesReversedZBuffer)
{
zBufferParams.y += zBufferParams.x;
zBufferParams.x = -zBufferParams.x;
zBufferParams.w += zBufferParams.z;
zBufferParams.z = -zBufferParams.z;
}
// Projection flip sign logic is very deep in GfxDevice::SetInvertProjectionMatrix
// For now we don't deal with _ProjectionParams.x and let SetupCameraProperties handle it.
// We need to enable this when we remove SetupCameraProperties
// float projectionFlipSign = ???
// Vector4 projectionParams = new Vector4(projectionFlipSign, near, far, 1.0f * invFar);
// cmd.SetGlobalVector(ShaderPropertyId.projectionParams, projectionParams);
Vector4 orthoParams = new Vector4(camera.orthographicSize * cameraData.aspectRatio, camera.orthographicSize, 0.0f, isOrthographic);
// Camera and Screen variables as described in https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
cmd.SetGlobalVector(ShaderPropertyId.worldSpaceCameraPos, camera.transform.position);
cmd.SetGlobalVector(ShaderPropertyId.screenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
cmd.SetGlobalVector(ShaderPropertyId.scaledScreenParams, new Vector4(scaledCameraWidth, scaledCameraHeight, 1.0f + 1.0f / scaledCameraWidth, 1.0f + 1.0f / scaledCameraHeight));
cmd.SetGlobalVector(ShaderPropertyId.zBufferParams, zBufferParams);
cmd.SetGlobalVector(ShaderPropertyId.orthoParams, orthoParams);
}
/// <summary>
/// Set shader time variables as described in https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
/// </summary>
/// <param name="cmd">CommandBuffer to submit data to GPU.</param>
/// <param name="time">Time.</param>
/// <param name="deltaTime">Delta time.</param>
/// <param name="smoothDeltaTime">Smooth delta time.</param>
void SetShaderTimeValues(CommandBuffer cmd, float time, float deltaTime, float smoothDeltaTime)
{
float timeEights = time / 8f;
float timeFourth = time / 4f;
float timeHalf = time / 2f;
// Time values
Vector4 timeVector = time * new Vector4(1f / 20f, 1f, 2f, 3f);
Vector4 sinTimeVector = new Vector4(Mathf.Sin(timeEights), Mathf.Sin(timeFourth), Mathf.Sin(timeHalf), Mathf.Sin(time));
Vector4 cosTimeVector = new Vector4(Mathf.Cos(timeEights), Mathf.Cos(timeFourth), Mathf.Cos(timeHalf), Mathf.Cos(time));
Vector4 deltaTimeVector = new Vector4(deltaTime, 1f / deltaTime, smoothDeltaTime, 1f / smoothDeltaTime);
Vector4 timeParametersVector = new Vector4(time, Mathf.Sin(time), Mathf.Cos(time), 0.0f);
cmd.SetGlobalVector(ShaderPropertyId.time, timeVector);
cmd.SetGlobalVector(ShaderPropertyId.sinTime, sinTimeVector);
cmd.SetGlobalVector(ShaderPropertyId.cosTime, cosTimeVector);
cmd.SetGlobalVector(ShaderPropertyId.deltaTime, deltaTimeVector);
cmd.SetGlobalVector(ShaderPropertyId.timeParameters, timeParametersVector);
}
/// <summary>
/// Returns the camera color target for this renderer.
/// It's only valid to call cameraColorTarget in the scope of <c>ScriptableRenderPass</c>.
/// <seealso cref="ScriptableRenderPass"/>.
/// </summary>
public RenderTargetIdentifier cameraColorTarget
{
get
{
if (!(m_IsPipelineExecuting || isCameraColorTargetValid))
{
Debug.LogWarning("You can only call cameraColorTarget inside the scope of a ScriptableRenderPass. Otherwise the pipeline camera target texture might have not been created or might have already been disposed.");
// TODO: Ideally we should return an error texture (BuiltinRenderTextureType.None?)
// but this might break some existing content, so we return the pipeline texture in the hope it gives a "soft" upgrade to users.
}
return m_CameraColorTarget;
}
}
/// <summary>
/// Returns the camera depth target for this renderer.
/// It's only valid to call cameraDepthTarget in the scope of <c>ScriptableRenderPass</c>.
/// <seealso cref="ScriptableRenderPass"/>.
/// </summary>
public RenderTargetIdentifier cameraDepthTarget
{
get
{
if (!m_IsPipelineExecuting)
{
Debug.LogWarning("You can only call cameraDepthTarget inside the scope of a ScriptableRenderPass. Otherwise the pipeline camera target texture might have not been created or might have already been disposed.");
// TODO: Ideally we should return an error texture (BuiltinRenderTextureType.None?)
// but this might break some existing content, so we return the pipeline texture in the hope it gives a "soft" upgrade to users.
}
return m_CameraDepthTarget;
}
}
/// <summary>
/// Returns a list of renderer features added to this renderer.
/// <seealso cref="ScriptableRendererFeature"/>
/// </summary>
protected List<ScriptableRendererFeature> rendererFeatures
{
get => m_RendererFeatures;
}
/// <summary>
/// Returns a list of render passes scheduled to be executed by this renderer.
/// <seealso cref="ScriptableRenderPass"/>
/// </summary>
protected List<ScriptableRenderPass> activeRenderPassQueue
{
get => m_ActiveRenderPassQueue;
}
/// <summary>
/// Supported rendering features by this renderer.
/// <see cref="SupportedRenderingFeatures"/>
/// </summary>
public RenderingFeatures supportedRenderingFeatures { get; set; } = new RenderingFeatures();
/// <summary>
/// List of unsupported Graphics APIs for this renderer.
/// <see cref="unsupportedGraphicsDeviceTypes"/>
/// </summary>
public GraphicsDeviceType[] unsupportedGraphicsDeviceTypes { get; set; } = new GraphicsDeviceType[0];
static class RenderPassBlock
{
// Executes render passes that are inputs to the main rendering
// but don't depend on camera state. They all render in monoscopic mode. f.ex, shadow maps.
public static readonly int BeforeRendering = 0;
// Main bulk of render pass execution. They required camera state to be properly set
// and when enabled they will render in stereo.
public static readonly int MainRenderingOpaque = 1;
public static readonly int MainRenderingTransparent = 2;
// Execute after Post-processing.
public static readonly int AfterRendering = 3;
}
private StoreActionsOptimization m_StoreActionsOptimizationSetting = StoreActionsOptimization.Auto;
private static bool m_UseOptimizedStoreActions = false;
const int k_RenderPassBlockCount = 4;
List<ScriptableRenderPass> m_ActiveRenderPassQueue = new List<ScriptableRenderPass>(32);
List<ScriptableRendererFeature> m_RendererFeatures = new List<ScriptableRendererFeature>(10);
RenderTargetIdentifier m_CameraColorTarget;
RenderTargetIdentifier m_CameraDepthTarget;
bool m_FirstTimeCameraColorTargetIsBound = true; // flag used to track when m_CameraColorTarget should be cleared (if necessary), as well as other special actions only performed the first time m_CameraColorTarget is bound as a render target
bool m_FirstTimeCameraDepthTargetIsBound = true; // flag used to track when m_CameraDepthTarget should be cleared (if necessary), the first time m_CameraDepthTarget is bound as a render target
// The pipeline can only guarantee the camera target texture are valid when the pipeline is executing.
// Trying to access the camera target before or after might be that the pipeline texture have already been disposed.
bool m_IsPipelineExecuting = false;
// This should be removed when early camera color target assignment is removed.
internal bool isCameraColorTargetValid = false;
static RenderTargetIdentifier[] m_ActiveColorAttachments = new RenderTargetIdentifier[]{0, 0, 0, 0, 0, 0, 0, 0 };
static RenderTargetIdentifier m_ActiveDepthAttachment;
private static RenderBufferStoreAction[] m_ActiveColorStoreActions = new RenderBufferStoreAction[]
{
RenderBufferStoreAction.Store, RenderBufferStoreAction.Store, RenderBufferStoreAction.Store, RenderBufferStoreAction.Store,
RenderBufferStoreAction.Store, RenderBufferStoreAction.Store, RenderBufferStoreAction.Store, RenderBufferStoreAction.Store
};
private static RenderBufferStoreAction m_ActiveDepthStoreAction = RenderBufferStoreAction.Store;
// CommandBuffer.SetRenderTarget(RenderTargetIdentifier[] colors, RenderTargetIdentifier depth, int mipLevel, CubemapFace cubemapFace, int depthSlice);
// called from CoreUtils.SetRenderTarget will issue a warning assert from native c++ side if "colors" array contains some invalid RTIDs.
// To avoid that warning assert we trim the RenderTargetIdentifier[] arrays we pass to CoreUtils.SetRenderTarget.
// To avoid re-allocating a new array every time we do that, we re-use one of these arrays:
static RenderTargetIdentifier[][] m_TrimmedColorAttachmentCopies = new RenderTargetIdentifier[][]
{
new RenderTargetIdentifier[0], // m_TrimmedColorAttachmentCopies[0] is an array of 0 RenderTargetIdentifier - only used to make indexing code easier to read
new RenderTargetIdentifier[]{0}, // m_TrimmedColorAttachmentCopies[1] is an array of 1 RenderTargetIdentifier
new RenderTargetIdentifier[]{0, 0}, // m_TrimmedColorAttachmentCopies[2] is an array of 2 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0}, // m_TrimmedColorAttachmentCopies[3] is an array of 3 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0, 0}, // m_TrimmedColorAttachmentCopies[4] is an array of 4 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0, 0, 0}, // m_TrimmedColorAttachmentCopies[5] is an array of 5 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0, 0, 0, 0}, // m_TrimmedColorAttachmentCopies[6] is an array of 6 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0, 0, 0, 0, 0}, // m_TrimmedColorAttachmentCopies[7] is an array of 7 RenderTargetIdentifiers
new RenderTargetIdentifier[]{0, 0, 0, 0, 0, 0, 0, 0 }, // m_TrimmedColorAttachmentCopies[8] is an array of 8 RenderTargetIdentifiers
};
internal static void ConfigureActiveTarget(RenderTargetIdentifier colorAttachment,
RenderTargetIdentifier depthAttachment)
{
m_ActiveColorAttachments[0] = colorAttachment;
for (int i = 1; i < m_ActiveColorAttachments.Length; ++i)
m_ActiveColorAttachments[i] = 0;
m_ActiveDepthAttachment = depthAttachment;
}
public ScriptableRenderer(ScriptableRendererData data)
{
profilingExecute = new ProfilingSampler($"{nameof(ScriptableRenderer)}.{nameof(ScriptableRenderer.Execute)}: {data.name}");
foreach (var feature in data.rendererFeatures)
{
if (feature == null)
continue;
feature.Create();
m_RendererFeatures.Add(feature);
}
Clear(CameraRenderType.Base);
m_ActiveRenderPassQueue.Clear();
if (UniversalRenderPipeline.asset)
m_StoreActionsOptimizationSetting = UniversalRenderPipeline.asset.storeActionsOptimization;
m_UseOptimizedStoreActions = m_StoreActionsOptimizationSetting != StoreActionsOptimization.Store;
}
public void Dispose()
{
// Dispose all renderer features...
for (int i = 0; i < m_RendererFeatures.Count; ++i)
{
if (rendererFeatures[i] == null)
continue;
rendererFeatures[i].Dispose();
}
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
}
/// <summary>
/// Configures the camera target.
/// </summary>
/// <param name="colorTarget">Camera color target. Pass BuiltinRenderTextureType.CameraTarget if rendering to backbuffer.</param>
/// <param name="depthTarget">Camera depth target. Pass BuiltinRenderTextureType.CameraTarget if color has depth or rendering to backbuffer.</param>
public void ConfigureCameraTarget(RenderTargetIdentifier colorTarget, RenderTargetIdentifier depthTarget)
{
m_CameraColorTarget = colorTarget;
m_CameraDepthTarget = depthTarget;
}
// This should be removed when early camera color target assignment is removed.
internal void ConfigureCameraColorTarget(RenderTargetIdentifier colorTarget)
{
m_CameraColorTarget = colorTarget;
}
/// <summary>
/// Configures the render passes that will execute for this renderer.
/// This method is called per-camera every frame.
/// </summary>
/// <param name="context">Use this render context to issue any draw commands during execution.</param>
/// <param name="renderingData">Current render state information.</param>
/// <seealso cref="ScriptableRenderPass"/>
/// <seealso cref="ScriptableRendererFeature"/>
public abstract void Setup(ScriptableRenderContext context, ref RenderingData renderingData);
/// <summary>
/// Override this method to implement the lighting setup for the renderer. You can use this to
/// compute and upload light CBUFFER for example.
/// </summary>
/// <param name="context">Use this render context to issue any draw commands during execution.</param>
/// <param name="renderingData">Current render state information.</param>
public virtual void SetupLights(ScriptableRenderContext context, ref RenderingData renderingData)
{
}
/// <summary>
/// Override this method to configure the culling parameters for the renderer. You can use this to configure if
/// lights should be culled per-object or the maximum shadow distance for example.
/// </summary>
/// <param name="cullingParameters">Use this to change culling parameters used by the render pipeline.</param>
/// <param name="cameraData">Current render state information.</param>
public virtual void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters,
ref CameraData cameraData)
{
}
/// <summary>
/// Called upon finishing rendering the camera stack. You can release any resources created by the renderer here.
/// </summary>
/// <param name="cmd"></param>
public virtual void FinishRendering(CommandBuffer cmd)
{
}
/// <summary>
/// Execute the enqueued render passes. This automatically handles editor and stereo rendering.
/// </summary>
/// <param name="context">Use this render context to issue any draw commands during execution.</param>
/// <param name="renderingData">Current render state information.</param>
public void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
m_IsPipelineExecuting = true;
ref CameraData cameraData = ref renderingData.cameraData;
Camera camera = cameraData.camera;
CommandBuffer cmd = CommandBufferPool.Get();
// TODO: move skybox code from C++ to URP in order to remove the call to context.Submit() inside DrawSkyboxPass
// Until then, we can't use nested profiling scopes with XR multipass
CommandBuffer cmdScope = renderingData.cameraData.xr.enabled ? null : cmd;
using (new ProfilingScope(cmdScope, profilingExecute))
{
InternalStartRendering(context, ref renderingData);
// Cache the time for after the call to `SetupCameraProperties` and set the time variables in shader
// For now we set the time variables per camera, as we plan to remove `SetupCameraProperties`.
// Setting the time per frame would take API changes to pass the variable to each camera render.
// Once `SetupCameraProperties` is gone, the variable should be set higher in the call-stack.
#if UNITY_EDITOR
float time = Application.isPlaying ? Time.time : Time.realtimeSinceStartup;
#else
float time = Time.time;
#endif
float deltaTime = Time.deltaTime;
float smoothDeltaTime = Time.smoothDeltaTime;
// Initialize Camera Render State
ClearRenderingState(cmd);
SetPerCameraShaderVariables(cmd, ref cameraData);
SetShaderTimeValues(cmd, time, deltaTime, smoothDeltaTime);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
using (new ProfilingScope(cmd, Profiling.sortRenderPasses))
{
// Sort the render pass queue
SortStable(m_ActiveRenderPassQueue);
}
using var renderBlocks = new RenderBlocks(m_ActiveRenderPassQueue);
using (new ProfilingScope(cmd, Profiling.setupLights))
{
SetupLights(context, ref renderingData);
}
using (new ProfilingScope(cmd, Profiling.RenderBlock.beforeRendering))
{
// Before Render Block. This render blocks always execute in mono rendering.
// Camera is not setup. Lights are not setup.
// Used to render input textures like shadowmaps.
ExecuteBlock(RenderPassBlock.BeforeRendering, in renderBlocks, context, ref renderingData);
}
using (new ProfilingScope(cmd, Profiling.setupCamera))
{
// This is still required because of the following reasons:
// - Camera billboard properties.
// - Camera frustum planes: unity_CameraWorldClipPlanes[6]
// - _ProjectionParams.x logic is deep inside GfxDevice
// NOTE: The only reason we have to call this here and not at the beginning (before shadows)
// is because this need to be called for each eye in multi pass VR.
// The side effect is that this will override some shader properties we already setup and we will have to
// reset them.
context.SetupCameraProperties(camera);
SetCameraMatrices(cmd, ref cameraData, true);
// Reset shader time variables as they were overridden in SetupCameraProperties. If we don't do it we might have a mismatch between shadows and main rendering
SetShaderTimeValues(cmd, time, deltaTime, smoothDeltaTime);
#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
//Triggers dispatch per camera, all global parameters should have been setup at this stage.
VFX.VFXManager.ProcessCameraCommand(camera, cmd);
#endif
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
BeginXRRendering(cmd, context, ref renderingData.cameraData);
// In the opaque and transparent blocks the main rendering executes.
// Opaque blocks...
if (renderBlocks.GetLength(RenderPassBlock.MainRenderingOpaque) > 0)
{
using var profScope = new ProfilingScope(cmd, Profiling.RenderBlock.mainRenderingOpaque);
ExecuteBlock(RenderPassBlock.MainRenderingOpaque, in renderBlocks, context, ref renderingData);
}
// Transparent blocks...
if (renderBlocks.GetLength(RenderPassBlock.MainRenderingTransparent) > 0)
{
using var profScope = new ProfilingScope(cmd, Profiling.RenderBlock.mainRenderingTransparent);
ExecuteBlock(RenderPassBlock.MainRenderingTransparent, in renderBlocks, context, ref renderingData);
}
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
cameraData.xr.canMarkLateLatch = false;
#endif
// Draw Gizmos...
DrawGizmos(context, camera, GizmoSubset.PreImageEffects);
// In this block after rendering drawing happens, e.g, post processing, video player capture.
if (renderBlocks.GetLength(RenderPassBlock.AfterRendering) > 0)
{
using var profScope = new ProfilingScope(cmd, Profiling.RenderBlock.afterRendering);
ExecuteBlock(RenderPassBlock.AfterRendering, in renderBlocks, context, ref renderingData);
}
EndXRRendering(cmd, context, ref renderingData.cameraData);
DrawWireOverlay(context, camera);
DrawGizmos(context, camera, GizmoSubset.PostImageEffects);
InternalFinishRendering(context, cameraData.resolveFinalTarget);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <summary>
/// Enqueues a render pass for execution.
/// </summary>
/// <param name="pass">Render pass to be enqueued.</param>
public void EnqueuePass(ScriptableRenderPass pass)
{
m_ActiveRenderPassQueue.Add(pass);
}
/// <summary>
/// Returns a clear flag based on CameraClearFlags.
/// </summary>
/// <param name="cameraClearFlags">Camera clear flags.</param>
/// <returns>A clear flag that tells if color and/or depth should be cleared.</returns>
protected static ClearFlag GetCameraClearFlag(ref CameraData cameraData)
{
var cameraClearFlags = cameraData.camera.clearFlags;
// Universal RP doesn't support CameraClearFlags.DepthOnly and CameraClearFlags.Nothing.
// CameraClearFlags.DepthOnly has the same effect of CameraClearFlags.SolidColor
// CameraClearFlags.Nothing clears Depth on PC/Desktop and in mobile it clears both
// depth and color.
// CameraClearFlags.Skybox clears depth only.
// Implementation details:
// Camera clear flags are used to initialize the attachments on the first render pass.
// ClearFlag is used together with Tile Load action to figure out how to clear the camera render target.
// In Tile Based GPUs ClearFlag.Depth + RenderBufferLoadAction.DontCare becomes DontCare load action.
// While ClearFlag.All + RenderBufferLoadAction.DontCare become Clear load action.
// In mobile we force ClearFlag.All as DontCare doesn't have noticeable perf. difference from Clear
// and this avoid tile clearing issue when not rendering all pixels in some GPUs.
// In desktop/consoles there's actually performance difference between DontCare and Clear.
// RenderBufferLoadAction.DontCare in PC/Desktop behaves as not clearing screen
// RenderBufferLoadAction.DontCare in Vulkan/Metal behaves as DontCare load action
// RenderBufferLoadAction.DontCare in GLES behaves as glInvalidateBuffer
// Overlay cameras composite on top of previous ones. They don't clear color.
// For overlay cameras we check if depth should be cleared on not.
if (cameraData.renderType == CameraRenderType.Overlay)
return (cameraData.clearDepth) ? ClearFlag.Depth : ClearFlag.None;
// Always clear on first render pass in mobile as it's same perf of DontCare and avoid tile clearing issues.
if (Application.isMobilePlatform)
return ClearFlag.All;
if ((cameraClearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null) ||
cameraClearFlags == CameraClearFlags.Nothing)
return ClearFlag.Depth;
return ClearFlag.All;
}
/// <summary>
/// Calls <c>AddRenderPasses</c> for each feature added to this renderer.
/// <seealso cref="ScriptableRendererFeature.AddRenderPasses(ScriptableRenderer, ref RenderingData)"/>
/// </summary>
/// <param name="renderingData"></param>
protected void AddRenderPasses(ref RenderingData renderingData)
{
using var profScope = new ProfilingScope(null, Profiling.addRenderPasses);
// Add render passes from custom renderer features
for (int i = 0; i < rendererFeatures.Count; ++i)
{
if (!rendererFeatures[i].isActive)
{
continue;
}
rendererFeatures[i].AddRenderPasses(this, ref renderingData);
}
// Remove any null render pass that might have been added by user by mistake
int count = activeRenderPassQueue.Count;
for (int i = count - 1; i >= 0; i--)
{
if (activeRenderPassQueue[i] == null)
activeRenderPassQueue.RemoveAt(i);
}
// if any pass was injected, the "automatic" store optimization policy will disable the optimized load actions
if (count > 0 && m_StoreActionsOptimizationSetting == StoreActionsOptimization.Auto)
m_UseOptimizedStoreActions = false;
}
void ClearRenderingState(CommandBuffer cmd)
{
using var profScope = new ProfilingScope(cmd, Profiling.clearRenderingState);
// Reset per-camera shader keywords. They are enabled depending on which render passes are executed.
cmd.DisableShaderKeyword(ShaderKeywordStrings.MainLightShadows);
cmd.DisableShaderKeyword(ShaderKeywordStrings.MainLightShadowCascades);
cmd.DisableShaderKeyword(ShaderKeywordStrings.AdditionalLightsVertex);
cmd.DisableShaderKeyword(ShaderKeywordStrings.AdditionalLightsPixel);
cmd.DisableShaderKeyword(ShaderKeywordStrings.AdditionalLightShadows);
cmd.DisableShaderKeyword(ShaderKeywordStrings.SoftShadows);
cmd.DisableShaderKeyword(ShaderKeywordStrings.MixedLightingSubtractive); // Backward compatibility
cmd.DisableShaderKeyword(ShaderKeywordStrings.LightmapShadowMixing);
cmd.DisableShaderKeyword(ShaderKeywordStrings.ShadowsShadowMask);
cmd.DisableShaderKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
}
internal void Clear(CameraRenderType cameraType)
{
m_ActiveColorAttachments[0] = BuiltinRenderTextureType.CameraTarget;
for (int i = 1; i < m_ActiveColorAttachments.Length; ++i)
m_ActiveColorAttachments[i] = 0;
m_ActiveDepthAttachment = BuiltinRenderTextureType.CameraTarget;
m_FirstTimeCameraColorTargetIsBound = cameraType == CameraRenderType.Base;
m_FirstTimeCameraDepthTargetIsBound = true;
m_CameraColorTarget = BuiltinRenderTextureType.CameraTarget;
m_CameraDepthTarget = BuiltinRenderTextureType.CameraTarget;
}
void ExecuteBlock(int blockIndex, in RenderBlocks renderBlocks,
ScriptableRenderContext context, ref RenderingData renderingData, bool submit = false)
{
foreach (int currIndex in renderBlocks.GetRange(blockIndex))
{
var renderPass = m_ActiveRenderPassQueue[currIndex];
ExecuteRenderPass(context, renderPass, ref renderingData);
}
if (submit)
context.Submit();
}
void ExecuteRenderPass(ScriptableRenderContext context, ScriptableRenderPass renderPass, ref RenderingData renderingData)
{
using var profScope = new ProfilingScope(null, renderPass.profilingSampler);
ref CameraData cameraData = ref renderingData.cameraData;
CommandBuffer cmd = CommandBufferPool.Get();
// Track CPU only as GPU markers for this scope were "too noisy".
using (new ProfilingScope(cmd, Profiling.RenderPass.configure))
{
renderPass.Configure(cmd, cameraData.cameraTargetDescriptor);
SetRenderPassAttachments(cmd, renderPass, ref cameraData);
}
// Also, we execute the commands recorded at this point to ensure SetRenderTarget is called before RenderPass.Execute
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
renderPass.Execute(context, ref renderingData);
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled && cameraData.xr.hasMarkedLateLatch)
cameraData.xr.UnmarkLateLatchShaderProperties(cmd, ref cameraData);
#endif
}
void SetRenderPassAttachments(CommandBuffer cmd, ScriptableRenderPass renderPass, ref CameraData cameraData)
{
Camera camera = cameraData.camera;
ClearFlag cameraClearFlag = GetCameraClearFlag(ref cameraData);
// Invalid configuration - use current attachment setup
// Note: we only check color buffers. This is only technically correct because for shadowmaps and depth only passes
// we bind depth as color and Unity handles it underneath. so we never have a situation that all color buffers are null and depth is bound.
uint validColorBuffersCount = RenderingUtils.GetValidColorBufferCount(renderPass.colorAttachments);
if (validColorBuffersCount == 0)
return;
// We use a different code path for MRT since it calls a different version of API SetRenderTarget
if (RenderingUtils.IsMRT(renderPass.colorAttachments))
{
// In the MRT path we assume that all color attachments are REAL color attachments,
// and that the depth attachment is a REAL depth attachment too.
// Determine what attachments need to be cleared. ----------------
bool needCustomCameraColorClear = false;
bool needCustomCameraDepthClear = false;
int cameraColorTargetIndex = RenderingUtils.IndexOf(renderPass.colorAttachments, m_CameraColorTarget);
if (cameraColorTargetIndex != -1 && (m_FirstTimeCameraColorTargetIsBound))
{
m_FirstTimeCameraColorTargetIsBound = false; // register that we did clear the camera target the first time it was bound
// Overlay cameras composite on top of previous ones. They don't clear.
// MTT: Commented due to not implemented yet
// if (renderingData.cameraData.renderType == CameraRenderType.Overlay)
// clearFlag = ClearFlag.None;
// We need to specifically clear the camera color target.
// But there is still a chance we don't need to issue individual clear() on each render-targets if they all have the same clear parameters.
needCustomCameraColorClear = (cameraClearFlag & ClearFlag.Color) != (renderPass.clearFlag & ClearFlag.Color)
|| CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor) != renderPass.clearColor;
}
// Note: if we have to give up the assumption that no depthTarget can be included in the MRT colorAttachments, we might need something like this:
// int cameraTargetDepthIndex = IndexOf(renderPass.colorAttachments, m_CameraDepthTarget);
// if( !renderTargetAlreadySet && cameraTargetDepthIndex != -1 && m_FirstTimeCameraDepthTargetIsBound)
// { ...
// }
if (renderPass.depthAttachment == m_CameraDepthTarget && m_FirstTimeCameraDepthTargetIsBound)
{
m_FirstTimeCameraDepthTargetIsBound = false;
needCustomCameraDepthClear = (cameraClearFlag & ClearFlag.Depth) != (renderPass.clearFlag & ClearFlag.Depth);
}
// Perform all clear operations needed. ----------------
// We try to minimize calls to SetRenderTarget().
// We get here only if cameraColorTarget needs to be handled separately from the rest of the color attachments.
if (needCustomCameraColorClear)
{
// Clear camera color render-target separately from the rest of the render-targets.
if ((cameraClearFlag & ClearFlag.Color) != 0)
SetRenderTarget(cmd, renderPass.colorAttachments[cameraColorTargetIndex], renderPass.depthAttachment, ClearFlag.Color, CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor));
if ((renderPass.clearFlag & ClearFlag.Color) != 0)
{
uint otherTargetsCount = RenderingUtils.CountDistinct(renderPass.colorAttachments, m_CameraColorTarget);
var nonCameraAttachments = m_TrimmedColorAttachmentCopies[otherTargetsCount];
int writeIndex = 0;
for (int readIndex = 0; readIndex < renderPass.colorAttachments.Length; ++readIndex)
{
if (renderPass.colorAttachments[readIndex] != m_CameraColorTarget && renderPass.colorAttachments[readIndex] != 0)
{
nonCameraAttachments[writeIndex] = renderPass.colorAttachments[readIndex];
++writeIndex;
}
}
if (writeIndex != otherTargetsCount)
Debug.LogError("writeIndex and otherTargetsCount values differed. writeIndex:" + writeIndex + " otherTargetsCount:" + otherTargetsCount);
SetRenderTarget(cmd, nonCameraAttachments, m_CameraDepthTarget, ClearFlag.Color, renderPass.clearColor);
}
}
// Bind all attachments, clear color only if there was no custom behaviour for cameraColorTarget, clear depth as needed.
ClearFlag finalClearFlag = ClearFlag.None;
finalClearFlag |= needCustomCameraDepthClear ? (cameraClearFlag & ClearFlag.Depth) : (renderPass.clearFlag & ClearFlag.Depth);
finalClearFlag |= needCustomCameraColorClear ? 0 : (renderPass.clearFlag & ClearFlag.Color);
// Only setup render target if current render pass attachments are different from the active ones.
if (!RenderingUtils.SequenceEqual(renderPass.colorAttachments, m_ActiveColorAttachments) || renderPass.depthAttachment != m_ActiveDepthAttachment || finalClearFlag != ClearFlag.None)
{
int lastValidRTindex = RenderingUtils.LastValid(renderPass.colorAttachments);
if (lastValidRTindex >= 0)
{
int rtCount = lastValidRTindex + 1;
var trimmedAttachments = m_TrimmedColorAttachmentCopies[rtCount];
for (int i = 0; i < rtCount; ++i)
trimmedAttachments[i] = renderPass.colorAttachments[i];
SetRenderTarget(cmd, trimmedAttachments, renderPass.depthAttachment, finalClearFlag, renderPass.clearColor);
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
// SetRenderTarget might alter the internal device state(winding order).
// Non-stereo buffer is already updated internally when switching render target. We update stereo buffers here to keep the consistency.
int xrTargetIndex = RenderingUtils.IndexOf(renderPass.colorAttachments, cameraData.xr.renderTarget);
bool isRenderToBackBufferTarget = (xrTargetIndex != -1) && !cameraData.xr.renderTargetIsRenderTexture;
cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget);
}
#endif
}
}
}
else
{
// Currently in non-MRT case, color attachment can actually be a depth attachment.
RenderTargetIdentifier passColorAttachment = renderPass.colorAttachment;
RenderTargetIdentifier passDepthAttachment = renderPass.depthAttachment;
// When render pass doesn't call ConfigureTarget we assume it's expected to render to camera target
// which might be backbuffer or the framebuffer render textures.
if (!renderPass.overrideCameraTarget)
{
// Default render pass attachment for passes before main rendering is current active
// early return so we don't change current render target setup.
if (renderPass.renderPassEvent < RenderPassEvent.BeforeRenderingOpaques)
return;
// Otherwise default is the pipeline camera target.
passColorAttachment = m_CameraColorTarget;
passDepthAttachment = m_CameraDepthTarget;
}
ClearFlag finalClearFlag = ClearFlag.None;
Color finalClearColor;
if (passColorAttachment == m_CameraColorTarget && (m_FirstTimeCameraColorTargetIsBound))
{
m_FirstTimeCameraColorTargetIsBound = false; // register that we did clear the camera target the first time it was bound
finalClearFlag |= (cameraClearFlag & ClearFlag.Color);
finalClearColor = CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor);
if (m_FirstTimeCameraDepthTargetIsBound)
{
// m_CameraColorTarget can be an opaque pointer to a RenderTexture with depth-surface.
// We cannot infer this information here, so we must assume both camera color and depth are first-time bound here (this is the legacy behaviour).
m_FirstTimeCameraDepthTargetIsBound = false;
finalClearFlag |= (cameraClearFlag & ClearFlag.Depth);
}
}
else
{
finalClearFlag |= (renderPass.clearFlag & ClearFlag.Color);
finalClearColor = renderPass.clearColor;
}
// Condition (m_CameraDepthTarget!=BuiltinRenderTextureType.CameraTarget) below prevents m_FirstTimeCameraDepthTargetIsBound flag from being reset during non-camera passes (such as Color Grading LUT). This ensures that in those cases, cameraDepth will actually be cleared during the later camera pass.
if ((m_CameraDepthTarget != BuiltinRenderTextureType.CameraTarget) && (passDepthAttachment == m_CameraDepthTarget || passColorAttachment == m_CameraDepthTarget) && m_FirstTimeCameraDepthTargetIsBound)
{
m_FirstTimeCameraDepthTargetIsBound = false;
finalClearFlag |= (cameraClearFlag & ClearFlag.Depth);
// finalClearFlag |= (cameraClearFlag & ClearFlag.Color); // <- m_CameraDepthTarget is never a color-surface, so no need to add this here.
}
else
finalClearFlag |= (renderPass.clearFlag & ClearFlag.Depth);
// Only setup render target if current render pass attachments are different from the active ones
if (passColorAttachment != m_ActiveColorAttachments[0] || passDepthAttachment != m_ActiveDepthAttachment || finalClearFlag != ClearFlag.None ||
renderPass.colorStoreActions[0] != m_ActiveColorStoreActions[0] || renderPass.depthStoreAction != m_ActiveDepthStoreAction)
{
SetRenderTarget(cmd, passColorAttachment, passDepthAttachment, finalClearFlag, finalClearColor, renderPass.colorStoreActions[0], renderPass.depthStoreAction);
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
// SetRenderTarget might alter the internal device state(winding order).
// Non-stereo buffer is already updated internally when switching render target. We update stereo buffers here to keep the consistency.
bool isRenderToBackBufferTarget = (passColorAttachment == cameraData.xr.renderTarget) && !cameraData.xr.renderTargetIsRenderTexture;
cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget);
}
#endif
}
}
}
void BeginXRRendering(CommandBuffer cmd, ScriptableRenderContext context, ref CameraData cameraData)
{
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
if (cameraData.xr.isLateLatchEnabled)
cameraData.xr.canMarkLateLatch = true;
cameraData.xr.StartSinglePass(cmd);
cmd.EnableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
#endif
}
void EndXRRendering(CommandBuffer cmd, ScriptableRenderContext context, ref CameraData cameraData)
{
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
cameraData.xr.StopSinglePass(cmd);
cmd.DisableShaderKeyword(ShaderKeywordStrings.UseDrawProcedural);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
#endif
}
internal static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorAttachment, RenderTargetIdentifier depthAttachment, ClearFlag clearFlag, Color clearColor)
{
m_ActiveColorAttachments[0] = colorAttachment;
for (int i = 1; i < m_ActiveColorAttachments.Length; ++i)
m_ActiveColorAttachments[i] = 0;
m_ActiveColorStoreActions[0] = RenderBufferStoreAction.Store;
m_ActiveDepthStoreAction = RenderBufferStoreAction.Store;
for (int i = 1; i < m_ActiveColorStoreActions.Length; ++i)
m_ActiveColorStoreActions[i] = RenderBufferStoreAction.Store;
m_ActiveDepthAttachment = depthAttachment;
RenderBufferLoadAction colorLoadAction = ((uint)clearFlag & (uint)ClearFlag.Color) != 0 ?
RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
RenderBufferLoadAction depthLoadAction = ((uint)clearFlag & (uint)ClearFlag.Depth) != 0 ?
RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
SetRenderTarget(cmd, colorAttachment, colorLoadAction, RenderBufferStoreAction.Store,
depthAttachment, depthLoadAction, RenderBufferStoreAction.Store, clearFlag, clearColor);
}
internal static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorAttachment, RenderTargetIdentifier depthAttachment, ClearFlag clearFlag, Color clearColor, RenderBufferStoreAction colorStoreAction, RenderBufferStoreAction depthStoreAction)
{
m_ActiveColorAttachments[0] = colorAttachment;
for (int i = 1; i < m_ActiveColorAttachments.Length; ++i)
m_ActiveColorAttachments[i] = 0;
m_ActiveColorStoreActions[0] = colorStoreAction;
m_ActiveDepthStoreAction = depthStoreAction;
for (int i = 1; i < m_ActiveColorStoreActions.Length; ++i)
m_ActiveColorStoreActions[i] = RenderBufferStoreAction.Store;
m_ActiveDepthAttachment = depthAttachment;
RenderBufferLoadAction colorLoadAction = ((uint)clearFlag & (uint)ClearFlag.Color) != 0 ?
RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
RenderBufferLoadAction depthLoadAction = ((uint)clearFlag & (uint)ClearFlag.Depth) != 0 ?
RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
// if we shouldn't use optimized store actions then fall back to the conservative safe (un-optimal!) route and just store everything
if (!m_UseOptimizedStoreActions)
{
if (colorStoreAction != RenderBufferStoreAction.StoreAndResolve)
colorStoreAction = RenderBufferStoreAction.Store;
if (depthStoreAction != RenderBufferStoreAction.StoreAndResolve)
depthStoreAction = RenderBufferStoreAction.Store;
}
SetRenderTarget(cmd, colorAttachment, colorLoadAction, colorStoreAction,
depthAttachment, depthLoadAction, depthStoreAction, clearFlag, clearColor);
}
static void SetRenderTarget(CommandBuffer cmd,
RenderTargetIdentifier colorAttachment,
RenderBufferLoadAction colorLoadAction,
RenderBufferStoreAction colorStoreAction,
ClearFlag clearFlags,
Color clearColor)
{
CoreUtils.SetRenderTarget(cmd, colorAttachment, colorLoadAction, colorStoreAction, clearFlags, clearColor);
}
static void SetRenderTarget(
CommandBuffer cmd,
RenderTargetIdentifier colorAttachment,
RenderBufferLoadAction colorLoadAction,
RenderBufferStoreAction colorStoreAction,
RenderTargetIdentifier depthAttachment,
RenderBufferLoadAction depthLoadAction,
RenderBufferStoreAction depthStoreAction,
ClearFlag clearFlags,
Color clearColor)
{
// XRTODO: Revisit the logic. Why treat CameraTarget depth specially?
if (depthAttachment == BuiltinRenderTextureType.CameraTarget)
{
cmd.SetRenderTarget(colorAttachment, colorLoadAction, colorStoreAction, depthLoadAction, depthStoreAction);
CoreUtils.ClearRenderTarget(cmd, clearFlags, clearColor);
}
else
{
CoreUtils.SetRenderTarget(cmd, colorAttachment, colorLoadAction, colorStoreAction,
depthAttachment, depthLoadAction, depthStoreAction, clearFlags, clearColor);
}
}
static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier[] colorAttachments, RenderTargetIdentifier depthAttachment, ClearFlag clearFlag, Color clearColor)
{
m_ActiveColorAttachments = colorAttachments;
m_ActiveDepthAttachment = depthAttachment;
CoreUtils.SetRenderTarget(cmd, colorAttachments, depthAttachment, clearFlag, clearColor);
}
[Conditional("UNITY_EDITOR")]
void DrawGizmos(ScriptableRenderContext context, Camera camera, GizmoSubset gizmoSubset)
{
#if UNITY_EDITOR
if (UnityEditor.Handles.ShouldRenderGizmos())
context.DrawGizmos(camera, gizmoSubset);
#endif
}
[Conditional("UNITY_EDITOR")]
void DrawWireOverlay(ScriptableRenderContext context, Camera camera)
{
context.DrawWireOverlay(camera);
}
void InternalStartRendering(ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, Profiling.internalStartRendering))
{
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
{
m_ActiveRenderPassQueue[i].OnCameraSetup(cmd, ref renderingData);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
void InternalFinishRendering(ScriptableRenderContext context, bool resolveFinalTarget)
{
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, Profiling.internalFinishRendering))
{
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
m_ActiveRenderPassQueue[i].FrameCleanup(cmd);
// Happens when rendering the last camera in the camera stack.
if (resolveFinalTarget)
{
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
m_ActiveRenderPassQueue[i].OnFinishCameraStackRendering(cmd);
FinishRendering(cmd);
// We finished camera stacking and released all intermediate pipeline textures.
m_IsPipelineExecuting = false;
}
m_ActiveRenderPassQueue.Clear();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
internal static void SortStable(List<ScriptableRenderPass> list)
{
int j;
for (int i = 1; i < list.Count; ++i)
{
ScriptableRenderPass curr = list[i];
j = i - 1;
for (; j >= 0 && curr < list[j]; --j)
list[j + 1] = list[j];
list[j + 1] = curr;
}
}
internal struct RenderBlocks : IDisposable
{
private NativeArray<RenderPassEvent> m_BlockEventLimits;
private NativeArray<int> m_BlockRanges;
private NativeArray<int> m_BlockRangeLengths;
public RenderBlocks(List<ScriptableRenderPass> activeRenderPassQueue)
{
// Upper limits for each block. Each block will contains render passes with events below the limit.
m_BlockEventLimits = new NativeArray<RenderPassEvent>(k_RenderPassBlockCount, Allocator.Temp);
m_BlockRanges = new NativeArray<int>(m_BlockEventLimits.Length + 1, Allocator.Temp);
m_BlockRangeLengths = new NativeArray<int>(m_BlockRanges.Length, Allocator.Temp);
m_BlockEventLimits[RenderPassBlock.BeforeRendering] = RenderPassEvent.BeforeRenderingPrepasses;
m_BlockEventLimits[RenderPassBlock.MainRenderingOpaque] = RenderPassEvent.AfterRenderingOpaques;
m_BlockEventLimits[RenderPassBlock.MainRenderingTransparent] = RenderPassEvent.AfterRenderingPostProcessing;
m_BlockEventLimits[RenderPassBlock.AfterRendering] = (RenderPassEvent) Int32.MaxValue;
// blockRanges[0] is always 0
// blockRanges[i] is the index of the first RenderPass found in m_ActiveRenderPassQueue that has a ScriptableRenderPass.renderPassEvent higher than blockEventLimits[i] (i.e, should be executed after blockEventLimits[i])
// blockRanges[blockEventLimits.Length] is m_ActiveRenderPassQueue.Count
FillBlockRanges(activeRenderPassQueue);
m_BlockEventLimits.Dispose();
for (int i = 0; i < m_BlockRanges.Length - 1; i++)
{
m_BlockRangeLengths[i] = m_BlockRanges[i + 1] - m_BlockRanges[i];
}
}
// RAII like Dispose pattern implementation for 'using' keyword
public void Dispose()
{
m_BlockRangeLengths.Dispose();
m_BlockRanges.Dispose();
}
// Fill in render pass indices for each block. End index is startIndex + 1.
void FillBlockRanges(List<ScriptableRenderPass> activeRenderPassQueue)
{
int currRangeIndex = 0;
int currRenderPass = 0;
m_BlockRanges[currRangeIndex++] = 0;
// For each block, it finds the first render pass index that has an event
// higher than the block limit.
for (int i = 0; i < m_BlockEventLimits.Length - 1; ++i)
{
while (currRenderPass < activeRenderPassQueue.Count &&
activeRenderPassQueue[currRenderPass].renderPassEvent < m_BlockEventLimits[i])
currRenderPass++;
m_BlockRanges[currRangeIndex++] = currRenderPass;
}
m_BlockRanges[currRangeIndex] = activeRenderPassQueue.Count;
}
public int GetLength(int index)
{
return m_BlockRangeLengths[index];
}
// Minimal foreach support
public struct BlockRange : IDisposable
{
int m_Current;
int m_End;
public BlockRange(int begin, int end)
{
Assertions.Assert.IsTrue(begin <= end);
m_Current = begin < end ? begin : end;
m_End = end >= begin ? end : begin;
m_Current -= 1;
}
public BlockRange GetEnumerator() { return this; }
public bool MoveNext() { return ++m_Current < m_End; }
public int Current { get => m_Current; }
public void Dispose() {}
}
public BlockRange GetRange(int index)
{
return new BlockRange(m_BlockRanges[index], m_BlockRanges[index + 1]);
}
}
}
}
345
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
