目录
前言：
RenderTexture，渲染纹理贴图，这是Unity一张显示相机渲染画面的贴图，使用它可以做到许多效果，比如车辆的后视镜，穿越门内的其余场景，UI界面单独渲染的模型界面等等。但是，当你在MemoryProfiler去查看内存的时候，有时候就会发现，这些RenderTexture占据了许多资源，大大占用了带宽，下面我将会在我遇到的问题中，来给予一些优化方向的建议。
一、本地RT
在Unity中本身可以直接右键创建本地资源RenderTexture，当然我们也可以采用程序动态去创建RenderTexture，两者的区别无非是空间换时间，时间换空间的差别。
对于本地RT，主要可以用来调整的，就是大小，抗锯齿，ColorFormat,DepthFormat
一般来说，颜色格式设置为R8G8B8AB8_UNORM可以应对大部分情况，如果精度不够可以适当调整，也可以这样操作，降低颜色格式的精度，提高RT的大小，有时候这样的设置方式可以得到不错的效果，又能降低些许内存大小。而对于深度模板格式，如果不需要深度信息，完全可以关闭它，如是需要这张RT的深度信息，也可以尝试去减小精度。
二、动态生成的RT
像我之前Unity URP自定义后处理系统_unity urp 后处理-CSDN博客 就采用了程序生成RenderTexture，但是如果不能合理管理这些临时RT，很容易造成内存泄漏。所以在定义RT的时候，在不用的它们的的时候，一定要释放它们以确保不会造成内存叠加。
RT?.Release就是常用的函数方法。
三、合理管理摄像机
在Unity URP中，类似于OpaqueTexture，DepthTexture的生成取决与渲染摄像机会不会开启这些功能，在有需要它们的时候去开启，不需要的时候则去关闭它们，以避免多余的RT生成占用内存。
四、_CameraDepthAttachment
在FrameDebugger观察的时候，总能看见_CameraDepthAttachment和_CameraColorAttachment身影。它们是相机深度图副本和颜色副本，_CameraColorAttachment不必说，有两张，一张A，一张B，它们会互相交换渲染内容，由A输出最终颜色。而对于深度图副本来说，有的时候我们并不需要深度信息，这些数据就会占用许多内存。
当使用MemoryProfiler查看RT的时候，我发现_CameraDepthAttachment占用的内存很高，一个全屏的就会有15M左右，当我从未开启相机后处理的时候，它不会生成，只要我开启了一下，它就会生成6~7张，尽管我之后将后处理功能关闭，它依然会存在。所以我开始定位渲染管线处理后效的逻辑。
以下是我处理内置管线与内置后处理Pass的逻辑。
UniversalRender：
UniversalRender具体修改全部代码：
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine.Experimental.Rendering;
using UnityEngine.Rendering.Universal.Internal;
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Rendering modes for Universal renderer.
/// </summary>
public enum RenderingMode
{
/// <summary>Render all objects and lighting in one pass, with a hard limit on the number of lights that can be applied on an object.</summary>
Forward = 0,
/// <summary>Render all objects and lighting in one pass using a clustered data structure to access lighting data.</summary>
[InspectorName("Forward+")]
ForwardPlus = 2,
/// <summary>Render all objects first in a g-buffer pass, then apply all lighting in a separate pass using deferred shading.</summary>
Deferred = 1
};
/// <summary>
/// When the Universal Renderer should use Depth Priming in Forward mode.
/// </summary>
public enum DepthPrimingMode
{
/// <summary>Depth Priming will never be used.</summary>
Disabled,
/// <summary>Depth Priming will only be used if there is a depth prepass needed by any of the render passes.</summary>
Auto,
/// <summary>A depth prepass will be explicitly requested so Depth Priming can be used.</summary>
Forced,
}
/// <summary>
/// Default renderer for Universal RP.
/// This renderer is supported on all Universal RP supported platforms.
/// It uses a classic forward rendering strategy with per-object light culling.
/// </summary>
public sealed partial class UniversalRenderer : ScriptableRenderer
{
#if UNITY_SWITCH || UNITY_ANDROID
const GraphicsFormat k_DepthStencilFormat = GraphicsFormat.D24_UNorm_S8_UInt;
const int k_DepthBufferBits = 24;
#else
const GraphicsFormat k_DepthStencilFormat = GraphicsFormat.D32_SFloat_S8_UInt;
const int k_DepthBufferBits = 32;
#endif
const int k_FinalBlitPassQueueOffset = 1;
const int k_AfterFinalBlitPassQueueOffset = k_FinalBlitPassQueueOffset + 1;
static readonly List<ShaderTagId> k_DepthNormalsOnly = new List<ShaderTagId> { new ShaderTagId("DepthNormalsOnly") };
private static class Profiling
{
private const string k_Name = nameof(UniversalRenderer);
public static readonly ProfilingSampler createCameraRenderTarget = new ProfilingSampler($"{k_Name}.{nameof(CreateCameraRenderTarget)}");
}
/// <inheritdoc/>
public override int SupportedCameraStackingTypes()
{
switch (m_RenderingMode)
{
case RenderingMode.Forward:
case RenderingMode.ForwardPlus:
return 1 << (int)CameraRenderType.Base | 1 << (int)CameraRenderType.Overlay;
case RenderingMode.Deferred:
return 1 << (int)CameraRenderType.Base;
default:
return 0;
}
}
// Rendering mode setup from UI. The final rendering mode used can be different. See renderingModeActual.
internal RenderingMode renderingModeRequested => m_RenderingMode;
// Actual rendering mode, which may be different (ex: wireframe rendering, hardware not capable of deferred rendering).
internal RenderingMode renderingModeActual => renderingModeRequested == RenderingMode.Deferred && (GL.wireframe || (DebugHandler != null && DebugHandler.IsActiveModeUnsupportedForDeferred) || m_DeferredLights == null || !m_DeferredLights.IsRuntimeSupportedThisFrame() || m_DeferredLights.IsOverlay)
? RenderingMode.Forward
: this.renderingModeRequested;
bool m_Clustering;
internal bool accurateGbufferNormals => m_DeferredLights != null ? m_DeferredLights.AccurateGbufferNormals : false;
#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
internal bool needTransparencyPass { get { return !UniversalRenderPipeline.asset.useAdaptivePerformance || !AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects;; } }
#endif
/// <summary>Property to control the depth priming behavior of the forward rendering path.</summary>
public DepthPrimingMode depthPrimingMode { get { return m_DepthPrimingMode; } set { m_DepthPrimingMode = value; } }
DepthOnlyPass m_DepthPrepass;
DepthNormalOnlyPass m_DepthNormalPrepass;
CopyDepthPass m_PrimedDepthCopyPass;
MotionVectorRenderPass m_MotionVectorPass;
MainLightShadowCasterPass m_MainLightShadowCasterPass;
AdditionalLightsShadowCasterPass m_AdditionalLightsShadowCasterPass;
GBufferPass m_GBufferPass;
CopyDepthPass m_GBufferCopyDepthPass;
DeferredPass m_DeferredPass;
DrawObjectsPass m_RenderOpaqueForwardOnlyPass;
DrawObjectsPass m_RenderOpaqueForwardPass;
DrawObjectsWithRenderingLayersPass m_RenderOpaqueForwardWithRenderingLayersPass;
DrawSkyboxPass m_DrawSkyboxPass;
CopyDepthPass m_CopyDepthPass;
CopyColorPass m_CopyColorPass;
TransparentSettingsPass m_TransparentSettingsPass;
DrawObjectsPass m_RenderTransparentForwardPass;
InvokeOnRenderObjectCallbackPass m_OnRenderObjectCallbackPass;
FinalBlitPass m_FinalBlitPass;
CapturePass m_CapturePass;
#if ENABLE_VR && ENABLE_XR_MODULE
XROcclusionMeshPass m_XROcclusionMeshPass;
CopyDepthPass m_XRCopyDepthPass;
#endif
#if UNITY_EDITOR
CopyDepthPass m_FinalDepthCopyPass;
#endif
DrawScreenSpaceUIPass m_DrawOffscreenUIPass;
DrawScreenSpaceUIPass m_DrawOverlayUIPass;
internal RenderTargetBufferSystem m_ColorBufferSystem;
internal RTHandle m_ActiveCameraColorAttachment;
RTHandle m_ColorFrontBuffer;
internal RTHandle m_ActiveCameraDepthAttachment;
internal RTHandle m_CameraDepthAttachment;
RTHandle m_XRTargetHandleAlias;
internal RTHandle m_DepthTexture;
RTHandle m_NormalsTexture;
RTHandle m_DecalLayersTexture;
RTHandle m_OpaqueColor;
RTHandle m_MotionVectorColor;
RTHandle m_MotionVectorDepth;
ForwardLights m_ForwardLights;
DeferredLights m_DeferredLights;
RenderingMode m_RenderingMode;
DepthPrimingMode m_DepthPrimingMode;
CopyDepthMode m_CopyDepthMode;
bool m_DepthPrimingRecommended;
StencilState m_DefaultStencilState;
LightCookieManager m_LightCookieManager;
IntermediateTextureMode m_IntermediateTextureMode;
bool m_VulkanEnablePreTransform;
// Materials used in URP Scriptable Render Passes
Material m_BlitMaterial = null;
Material m_BlitHDRMaterial = null;
Material m_CopyDepthMaterial = null;
Material m_SamplingMaterial = null;
Material m_StencilDeferredMaterial = null;
Material m_CameraMotionVecMaterial = null;
Material m_ObjectMotionVecMaterial = null;
PostProcessPasses m_PostProcessPasses;
internal ColorGradingLutPass colorGradingLutPass { get => m_PostProcessPasses.colorGradingLutPass; }
internal PostProcessPass postProcessPass { get => m_PostProcessPasses.postProcessPass; }
internal PostProcessPass finalPostProcessPass { get => m_PostProcessPasses.finalPostProcessPass; }
internal RTHandle colorGradingLut { get => m_PostProcessPasses.colorGradingLut; }
internal DeferredLights deferredLights { get => m_DeferredLights; }
/// <summary>
/// Constructor for the Universal Renderer.
/// </summary>
/// <param name="data">The settings to create the renderer with.</param>
public UniversalRenderer(UniversalRendererData data) : base(data)
{
// Query and cache runtime platform info first before setting up URP.
PlatformAutoDetect.Initialize();
#if ENABLE_VR && ENABLE_XR_MODULE
Experimental.Rendering.XRSystem.Initialize(XRPassUniversal.Create, data.xrSystemData.shaders.xrOcclusionMeshPS, data.xrSystemData.shaders.xrMirrorViewPS);
#endif
m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.coreBlitPS);
m_BlitHDRMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitHDROverlay);
m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
m_StencilDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.stencilDeferredPS);
m_CameraMotionVecMaterial = CoreUtils.CreateEngineMaterial(data.shaders.cameraMotionVector);
m_ObjectMotionVecMaterial = CoreUtils.CreateEngineMaterial(data.shaders.objectMotionVector);
StencilStateData stencilData = data.defaultStencilState;
m_DefaultStencilState = StencilState.defaultValue;
m_DefaultStencilState.enabled = stencilData.overrideStencilState;
m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
m_IntermediateTextureMode = data.intermediateTextureMode;
if (UniversalRenderPipeline.asset?.supportsLightCookies ?? false)
{
var settings = LightCookieManager.Settings.Create();
var asset = UniversalRenderPipeline.asset;
if (asset)
{
settings.atlas.format = asset.additionalLightsCookieFormat;
settings.atlas.resolution = asset.additionalLightsCookieResolution;
}
m_LightCookieManager = new LightCookieManager(ref settings);
}
this.stripShadowsOffVariants = true;
this.stripAdditionalLightOffVariants = true;
#if ENABLE_VR && ENABLE_VR_MODULE
#if PLATFORM_WINRT || PLATFORM_ANDROID
// AdditionalLightOff variant is available on HL&Quest platform due to performance consideration.
this.stripAdditionalLightOffVariants = !PlatformAutoDetect.isXRMobile;
#endif
#endif
ForwardLights.InitParams forwardInitParams;
forwardInitParams.lightCookieManager = m_LightCookieManager;
forwardInitParams.forwardPlus = data.renderingMode == RenderingMode.ForwardPlus;
m_Clustering = data.renderingMode == RenderingMode.ForwardPlus;
m_ForwardLights = new ForwardLights(forwardInitParams);
//m_DeferredLights.LightCulling = data.lightCulling;
this.m_RenderingMode = data.renderingMode;
this.m_DepthPrimingMode = data.depthPrimingMode;
this.m_CopyDepthMode = data.copyDepthMode;
#if UNITY_ANDROID || UNITY_IOS || UNITY_TVOS
this.m_DepthPrimingRecommended = false;
#else
this.m_DepthPrimingRecommended = true;
#endif
// Note: Since all custom render passes inject first and we have stable sort,
// we inject the builtin passes in the before events.
m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
#if ENABLE_VR && ENABLE_XR_MODULE
m_XROcclusionMeshPass = new XROcclusionMeshPass(RenderPassEvent.BeforeRenderingOpaques);
// Schedule XR copydepth right after m_FinalBlitPass
m_XRCopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRendering + k_AfterFinalBlitPassQueueOffset, m_CopyDepthMaterial);
#endif
m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrePasses, RenderQueueRange.opaque, data.opaqueLayerMask);
m_DepthNormalPrepass = new DepthNormalOnlyPass(RenderPassEvent.BeforeRenderingPrePasses, RenderQueueRange.opaque, data.opaqueLayerMask);
if (renderingModeRequested == RenderingMode.Forward || renderingModeRequested == RenderingMode.ForwardPlus)
{
m_PrimedDepthCopyPass = new CopyDepthPass(RenderPassEvent.AfterRenderingPrePasses, m_CopyDepthMaterial, true);
}
if (this.renderingModeRequested == RenderingMode.Deferred)
{
var deferredInitParams = new DeferredLights.InitParams();
deferredInitParams.stencilDeferredMaterial = m_StencilDeferredMaterial;
deferredInitParams.lightCookieManager = m_LightCookieManager;
m_DeferredLights = new DeferredLights(deferredInitParams, useRenderPassEnabled);
m_DeferredLights.AccurateGbufferNormals = data.accurateGbufferNormals;
m_GBufferPass = new GBufferPass(RenderPassEvent.BeforeRenderingGbuffer, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference, m_DeferredLights);
// Forward-only pass only runs if deferred renderer is enabled.
// It allows specific materials to be rendered in a forward-like pass.
// We render both gbuffer pass and forward-only pass before the deferred lighting pass so we can minimize copies of depth buffer and
// benefits from some depth rejection.
// - If a material can be rendered either forward or deferred, then it should declare a UniversalForward and a UniversalGBuffer pass.
// - If a material cannot be lit in deferred (unlit, bakedLit, special material such as hair, skin shader), then it should declare UniversalForwardOnly pass
// - Legacy materials have unamed pass, which is implicitely renamed as SRPDefaultUnlit. In that case, they are considered forward-only too.
// TO declare a material with unnamed pass and UniversalForward/UniversalForwardOnly pass is an ERROR, as the material will be rendered twice.
StencilState forwardOnlyStencilState = DeferredLights.OverwriteStencil(m_DefaultStencilState, (int)StencilUsage.MaterialMask);
ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[]
{
new ShaderTagId("UniversalForwardOnly"),
new ShaderTagId("SRPDefaultUnlit"), // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
new ShaderTagId("LightweightForward") // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
};
int forwardOnlyStencilRef = stencilData.stencilReference | (int)StencilUsage.MaterialUnlit;
m_GBufferCopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingGbuffer + 1, m_CopyDepthMaterial, true);
m_DeferredPass = new DeferredPass(RenderPassEvent.BeforeRenderingDeferredLights, m_DeferredLights);
m_RenderOpaqueForwardOnlyPass = new DrawObjectsPass("Render Opaques Forward Only", forwardOnlyShaderTagIds, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, forwardOnlyStencilState, forwardOnlyStencilRef);
}
// Always create this pass even in deferred because we use it for wireframe rendering in the Editor or offscreen depth texture rendering.
m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
m_RenderOpaqueForwardWithRenderingLayersPass = new DrawObjectsWithRenderingLayersPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
bool copyDepthAfterTransparents = m_CopyDepthMode == CopyDepthMode.AfterTransparents;
RenderPassEvent copyDepthEvent = copyDepthAfterTransparents ? RenderPassEvent.AfterRenderingTransparents : RenderPassEvent.AfterRenderingSkybox;
m_CopyDepthPass = new CopyDepthPass(
copyDepthEvent,
m_CopyDepthMaterial,
shouldClear: true,
copyResolvedDepth: RenderingUtils.MultisampleDepthResolveSupported() && SystemInfo.supportsMultisampleAutoResolve && copyDepthAfterTransparents);
// Motion vectors depend on the (copy) depth texture. Depth is reprojected to calculate motion vectors.
m_MotionVectorPass = new MotionVectorRenderPass(copyDepthEvent + 1, m_CameraMotionVecMaterial, m_ObjectMotionVecMaterial, data.opaqueLayerMask);
m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial);
#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
if (needTransparencyPass)
#endif
{
m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive);
m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
}
m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing);
m_DrawOffscreenUIPass = new DrawScreenSpaceUIPass(RenderPassEvent.BeforeRenderingPostProcessing, true);
m_DrawOverlayUIPass = new DrawScreenSpaceUIPass(RenderPassEvent.AfterRendering + k_AfterFinalBlitPassQueueOffset, false); // after m_FinalBlitPass
{
var postProcessParams = PostProcessParams.Create();
postProcessParams.blitMaterial = m_BlitMaterial;
postProcessParams.requestHDRFormat = GraphicsFormat.B10G11R11_UFloatPack32;
var asset = UniversalRenderPipeline.asset;
if (asset)
postProcessParams.requestHDRFormat = UniversalRenderPipeline.MakeRenderTextureGraphicsFormat(asset.supportsHDR, asset.hdrColorBufferPrecision, false);
m_PostProcessPasses = new PostProcessPasses(data.postProcessData, ref postProcessParams);
}
m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + k_FinalBlitPassQueueOffset, m_BlitMaterial, m_BlitHDRMaterial);
#if UNITY_EDITOR
m_FinalDepthCopyPass = new CopyDepthPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial);
#endif
// RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
// Samples (MSAA) depend on camera and pipeline
m_ColorBufferSystem = new RenderTargetBufferSystem("_CameraColorAttachment");
supportedRenderingFeatures = new RenderingFeatures();
if (this.renderingModeRequested == RenderingMode.Deferred)
{
// Deferred rendering does not support MSAA.
this.supportedRenderingFeatures.msaa = false;
// Avoid legacy platforms: use vulkan instead.
unsupportedGraphicsDeviceTypes = new GraphicsDeviceType[]
{
GraphicsDeviceType.OpenGLCore,
GraphicsDeviceType.OpenGLES2,
GraphicsDeviceType.OpenGLES3
};
}
LensFlareCommonSRP.mergeNeeded = 0;
LensFlareCommonSRP.maxLensFlareWithOcclusionTemporalSample = 1;
LensFlareCommonSRP.Initialize();
m_VulkanEnablePreTransform = GraphicsSettings.HasShaderDefine(BuiltinShaderDefine.UNITY_PRETRANSFORM_TO_DISPLAY_ORIENTATION);
}
/// <inheritdoc />
protected override void Dispose(bool disposing)
{
m_ForwardLights.Cleanup();
m_GBufferPass?.Dispose();
m_PostProcessPasses.Dispose();
m_FinalBlitPass?.Dispose();
m_DrawOffscreenUIPass?.Dispose();
m_DrawOverlayUIPass?.Dispose();
m_XRTargetHandleAlias?.Release();
ReleaseRenderTargets();
base.Dispose(disposing);
CoreUtils.Destroy(m_BlitMaterial);
CoreUtils.Destroy(m_BlitHDRMaterial);
CoreUtils.Destroy(m_CopyDepthMaterial);
CoreUtils.Destroy(m_SamplingMaterial);
CoreUtils.Destroy(m_StencilDeferredMaterial);
CoreUtils.Destroy(m_CameraMotionVecMaterial);
CoreUtils.Destroy(m_ObjectMotionVecMaterial);
CleanupRenderGraphResources();
LensFlareCommonSRP.Dispose();
}
internal override void ReleaseRenderTargets()
{
m_ColorBufferSystem.Dispose();
if (m_DeferredLights != null && !m_DeferredLights.UseRenderPass)
m_GBufferPass?.Dispose();
m_PostProcessPasses.ReleaseRenderTargets();
m_MainLightShadowCasterPass?.Dispose();
m_AdditionalLightsShadowCasterPass?.Dispose();
m_CameraDepthAttachment?.Release();
m_DepthTexture?.Release();
m_NormalsTexture?.Release();
m_DecalLayersTexture?.Release();
m_OpaqueColor?.Release();
m_MotionVectorColor?.Release();
m_MotionVectorDepth?.Release();
hasReleasedRTs = true;
}
private void SetupFinalPassDebug(ref CameraData cameraData)
{
if ((DebugHandler != null) && DebugHandler.IsActiveForCamera(ref cameraData))
{
if (DebugHandler.TryGetFullscreenDebugMode(out DebugFullScreenMode fullScreenDebugMode, out int textureHeightPercent) &&
(fullScreenDebugMode != DebugFullScreenMode.ReflectionProbeAtlas || m_Clustering))
{
Camera camera = cameraData.camera;
float screenWidth = camera.pixelWidth;
float screenHeight = camera.pixelHeight;
var relativeSize = Mathf.Clamp01(textureHeightPercent / 100f);
var height = relativeSize * screenHeight;
var width = relativeSize * screenWidth;
if (fullScreenDebugMode == DebugFullScreenMode.ReflectionProbeAtlas)
{
// Ensure that atlas is not stretched, but doesn't take up more than the percentage in any dimension.
var texture = m_ForwardLights.reflectionProbeManager.atlasRT;
var targetWidth = height * texture.width / texture.height;
if (targetWidth > width)
{
height = width * texture.height / texture.width;
}
else
{
width = targetWidth;
}
}
float normalizedSizeX = width / screenWidth;
float normalizedSizeY = height / screenHeight;
Rect normalizedRect = new Rect(1 - normalizedSizeX, 1 - normalizedSizeY, normalizedSizeX, normalizedSizeY);
switch (fullScreenDebugMode)
{
case DebugFullScreenMode.Depth:
{
DebugHandler.SetDebugRenderTarget(m_DepthTexture.nameID, normalizedRect, true);
break;
}
case DebugFullScreenMode.AdditionalLightsShadowMap:
{
DebugHandler.SetDebugRenderTarget(m_AdditionalLightsShadowCasterPass.m_AdditionalLightsShadowmapHandle, normalizedRect, false);
break;
}
case DebugFullScreenMode.MainLightShadowMap:
{
DebugHandler.SetDebugRenderTarget(m_MainLightShadowCasterPass.m_MainLightShadowmapTexture, normalizedRect, false);
break;
}
case DebugFullScreenMode.ReflectionProbeAtlas:
{
DebugHandler.SetDebugRenderTarget(m_ForwardLights.reflectionProbeManager.atlasRT, normalizedRect, false);
break;
}
default:
{
break;
}
}
}
else
{
DebugHandler.ResetDebugRenderTarget();
}
}
}
/// <summary>
/// Returns if the camera renders to a offscreen depth texture.
/// </summary>
/// <param name="cameraData">The camera data for the camera being rendered.</param>
/// <returns>Returns true if the camera renders to depth without any color buffer. It will return false otherwise.</returns>
public static bool IsOffscreenDepthTexture(in CameraData cameraData) => cameraData.targetTexture != null && cameraData.targetTexture.format == RenderTextureFormat.Depth;
bool IsDepthPrimingEnabled(ref CameraData cameraData)
{
// depth priming requires an extra depth copy, disable it on platforms not supporting it (like GLES when MSAA is on)
if (!CanCopyDepth(ref cameraData))
return false;
// Depth Priming causes rendering errors with WebGL on Apple Arm64 GPUs.
bool isNotWebGL = !IsWebGL();
bool depthPrimingRequested = (m_DepthPrimingRecommended && m_DepthPrimingMode == DepthPrimingMode.Auto) || m_DepthPrimingMode == DepthPrimingMode.Forced;
bool isForwardRenderingMode = m_RenderingMode == RenderingMode.Forward || m_RenderingMode == RenderingMode.ForwardPlus;
bool isFirstCameraToWriteDepth = cameraData.renderType == CameraRenderType.Base || cameraData.clearDepth;
// Enabled Depth priming when baking Reflection Probes causes artefacts (UUM-12397)
bool isNotReflectionCamera = cameraData.cameraType != CameraType.Reflection;
// Depth is not rendered in a depth-only camera setup with depth priming (UUM-38158)
bool isNotOffscreenDepthTexture = !IsOffscreenDepthTexture(cameraData);
return depthPrimingRequested && isForwardRenderingMode && isFirstCameraToWriteDepth && isNotReflectionCamera && isNotOffscreenDepthTexture && isNotWebGL;
}
bool IsWebGL()
{
#if PLATFORM_WEBGL
return IsGLESDevice();
#else
return false;
#endif
}
bool IsGLESDevice()
{
return SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES3;
}
bool IsGLDevice()
{
return IsGLESDevice() || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLCore;
}
/// <inheritdoc />
public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
{
m_ForwardLights.PreSetup(ref renderingData);
ref CameraData cameraData = ref renderingData.cameraData;
Camera camera = cameraData.camera;
RenderTextureDescriptor cameraTargetDescriptor = cameraData.cameraTargetDescriptor;
var cmd = renderingData.commandBuffer;
if (DebugHandler != null)
{
DebugHandler.Setup(context, ref renderingData);
if (DebugHandler.IsActiveForCamera(ref cameraData))
{
if (DebugHandler.WriteToDebugScreenTexture(ref cameraData))
{
RenderTextureDescriptor colorDesc = cameraData.cameraTargetDescriptor;
DebugHandler.ConfigureColorDescriptorForDebugScreen(ref colorDesc, cameraData.pixelWidth, cameraData.pixelHeight);
RenderingUtils.ReAllocateIfNeeded(ref DebugHandler.DebugScreenColorHandle, colorDesc, name: "_DebugScreenColor");
RenderTextureDescriptor depthDesc = cameraData.cameraTargetDescriptor;
DebugHandler.ConfigureDepthDescriptorForDebugScreen(ref depthDesc, k_DepthBufferBits, cameraData.pixelWidth, cameraData.pixelHeight);
RenderingUtils.ReAllocateIfNeeded(ref DebugHandler.DebugScreenDepthHandle, depthDesc, name: "_DebugScreenDepth");
}
if (DebugHandler.HDRDebugViewIsActive(ref cameraData))
{
DebugHandler.hdrDebugViewPass.Setup(ref cameraData, DebugHandler.DebugDisplaySettings.lightingSettings.hdrDebugMode);
EnqueuePass(DebugHandler.hdrDebugViewPass);
}
}
}
if (cameraData.cameraType != CameraType.Game)
useRenderPassEnabled = false;
// Because of the shortcutting done by depth only offscreen cameras, useDepthPriming must be computed early
useDepthPriming = IsDepthPrimingEnabled(ref cameraData);
// Special path for depth only offscreen cameras. Only write opaques + transparents.
if (IsOffscreenDepthTexture(in cameraData))
{
ConfigureCameraTarget(k_CameraTarget, k_CameraTarget);
SetupRenderPasses(in renderingData);
EnqueuePass(m_RenderOpaqueForwardPass);
#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
if (!needTransparencyPass)
return;
#endif
EnqueuePass(m_RenderTransparentForwardPass);
return;
}
// Assign the camera color target early in case it is needed during AddRenderPasses.
bool isPreviewCamera = cameraData.isPreviewCamera;
var createColorTexture = ((rendererFeatures.Count != 0 && m_IntermediateTextureMode == IntermediateTextureMode.Always) && !isPreviewCamera) ||
(Application.isEditor && m_Clustering);
// Gather render passe input requirements
RenderPassInputSummary renderPassInputs = GetRenderPassInputs(ref renderingData);
// Gather render pass require rendering layers event and mask size
bool requiresRenderingLayer = RenderingLayerUtils.RequireRenderingLayers(this, rendererFeatures,
cameraTargetDescriptor.msaaSamples,
out var renderingLayersEvent, out var renderingLayerMaskSize);
// All passes that use write to rendering layers are excluded from gl
// So we disable it to avoid setting multiple render targets
if (IsGLDevice())
requiresRenderingLayer = false;
bool renderingLayerProvidesByDepthNormalPass = false;
bool renderingLayerProvidesRenderObjectPass = false;
if (requiresRenderingLayer && renderingModeActual != RenderingMode.Deferred)
{
switch (renderingLayersEvent)
{
case RenderingLayerUtils.Event.DepthNormalPrePass:
renderingLayerProvidesByDepthNormalPass = true;
break;
case RenderingLayerUtils.Event.Opaque:
renderingLayerProvidesRenderObjectPass = true;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
// Enable depth normal prepass
if (renderingLayerProvidesByDepthNormalPass)
renderPassInputs.requiresNormalsTexture = true;
// TODO: investigate the order of call, had to change because of requiresRenderingLayer
if (m_DeferredLights != null)
{
m_DeferredLights.RenderingLayerMaskSize = renderingLayerMaskSize;
m_DeferredLights.UseDecalLayers = requiresRenderingLayer;
// TODO: This needs to be setup early, otherwise gbuffer attachments will be allocated with wrong size
m_DeferredLights.HasNormalPrepass = renderPassInputs.requiresNormalsTexture;
m_DeferredLights.ResolveMixedLightingMode(ref renderingData);
m_DeferredLights.IsOverlay = cameraData.renderType == CameraRenderType.Overlay;
if (m_DeferredLights.UseRenderPass)
{
// At this point we only have injected renderer features in the queue and can do assumptions on whether we'll need Framebuffer Fetch
foreach (var pass in activeRenderPassQueue)
{
if (pass.renderPassEvent >= RenderPassEvent.AfterRenderingGbuffer &&
pass.renderPassEvent <= RenderPassEvent.BeforeRenderingDeferredLights)
{
m_DeferredLights.DisableFramebufferFetchInput();
break;
}
}
}
}
// Should apply post-processing after rendering this camera?
bool applyPostProcessing = cameraData.postProcessEnabled && m_PostProcessPasses.isCreated;
// There's at least a camera in the camera stack that applies post-processing
bool anyPostProcessing = renderingData.postProcessingEnabled && m_PostProcessPasses.isCreated;
// If Camera's PostProcessing is enabled and if there any enabled PostProcessing requires depth texture as shader read resource (Motion Blur/DoF)
bool cameraHasPostProcessingWithDepth = applyPostProcessing && cameraData.postProcessingRequiresDepthTexture;
// TODO: We could cache and generate the LUT before rendering the stack
bool generateColorGradingLUT = cameraData.postProcessEnabled && m_PostProcessPasses.isCreated;
bool isSceneViewOrPreviewCamera = cameraData.isSceneViewCamera || cameraData.isPreviewCamera;
// This indicates whether the renderer will output a depth texture.
bool requiresDepthTexture = cameraData.requiresDepthTexture || renderPassInputs.requiresDepthTexture || m_DepthPrimingMode == DepthPrimingMode.Forced;
#if UNITY_EDITOR
bool isGizmosEnabled = UnityEditor.Handles.ShouldRenderGizmos();
#else
bool isGizmosEnabled = false;
#endif
bool mainLightShadows = m_MainLightShadowCasterPass.Setup(ref renderingData);
bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(ref renderingData);
bool transparentsNeedSettingsPass = m_TransparentSettingsPass.Setup();
bool forcePrepass = (m_CopyDepthMode == CopyDepthMode.ForcePrepass);
// Depth prepass is generated in the following cases:
// - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead.
// - Scene or preview cameras always require a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor.
// - Render passes require it
bool requiresDepthPrepass = (requiresDepthTexture || cameraHasPostProcessingWithDepth) && (!CanCopyDepth(ref renderingData.cameraData) || forcePrepass);
requiresDepthPrepass |= isSceneViewOrPreviewCamera;
requiresDepthPrepass |= isGizmosEnabled;
requiresDepthPrepass |= isPreviewCamera;
requiresDepthPrepass |= renderPassInputs.requiresDepthPrepass;
requiresDepthPrepass |= renderPassInputs.requiresNormalsTexture;
// Current aim of depth prepass is to generate a copy of depth buffer, it is NOT to prime depth buffer and reduce overdraw on non-mobile platforms.
// When deferred renderer is enabled, depth buffer is already accessible so depth prepass is not needed.
// The only exception is for generating depth-normal textures: SSAO pass needs it and it must run before forward-only geometry.
// DepthNormal prepass will render:
// - forward-only geometry when deferred renderer is enabled
// - all geometry when forward renderer is enabled
if (requiresDepthPrepass && this.renderingModeActual == RenderingMode.Deferred && !renderPassInputs.requiresNormalsTexture)
requiresDepthPrepass = false;
requiresDepthPrepass |= useDepthPriming;
// If possible try to merge the opaque and skybox passes instead of splitting them when "Depth Texture" is required.
// The copying of depth should normally happen after rendering opaques.
// But if we only require it for post processing or the scene camera then we do it after rendering transparent objects
// Aim to have the most optimized render pass event for Depth Copy (The aim is to minimize the number of render passes)
if (requiresDepthTexture)
{
bool copyDepthAfterTransparents = m_CopyDepthMode == CopyDepthMode.AfterTransparents;
RenderPassEvent copyDepthPassEvent = copyDepthAfterTransparents ? RenderPassEvent.AfterRenderingTransparents : RenderPassEvent.AfterRenderingOpaques;
// RenderPassInputs's requiresDepthTexture is configured through ScriptableRenderPass's ConfigureInput function
if (renderPassInputs.requiresDepthTexture)
{
// Do depth copy before the render pass that requires depth texture as shader read resource
copyDepthPassEvent = (RenderPassEvent)Mathf.Min((int)RenderPassEvent.AfterRenderingTransparents, ((int)renderPassInputs.requiresDepthTextureEarliestEvent) - 1);
}
m_CopyDepthPass.renderPassEvent = copyDepthPassEvent;
}
else if (cameraHasPostProcessingWithDepth || isSceneViewOrPreviewCamera || isGizmosEnabled)
{
// If only post process requires depth texture, we can re-use depth buffer from main geometry pass instead of enqueuing a depth copy pass, but no proper API to do that for now, so resort to depth copy pass for now
m_CopyDepthPass.renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
}
createColorTexture |= RequiresIntermediateColorTexture(ref cameraData);
createColorTexture |= renderPassInputs.requiresColorTexture;
createColorTexture |= renderPassInputs.requiresColorTextureCreated;
createColorTexture &= !isPreviewCamera;
// If camera requires depth and there's no depth pre-pass we create a depth texture that can be read later by effect requiring it.
// When deferred renderer is enabled, we must always create a depth texture and CANNOT use BuiltinRenderTextureType.CameraTarget. This is to get
// around a bug where during gbuffer pass (MRT pass), the camera depth attachment is correctly bound, but during
// deferred pass ("camera color" + "camera depth"), the implicit depth surface of "camera color" is used instead of "camera depth",
// because BuiltinRenderTextureType.CameraTarget for depth means there is no explicit depth attachment...
bool createDepthTexture = (requiresDepthTexture || cameraHasPostProcessingWithDepth) && !requiresDepthPrepass;
createDepthTexture |= !cameraData.resolveFinalTarget;
// Deferred renderer always need to access depth buffer.
createDepthTexture |= (this.renderingModeActual == RenderingMode.Deferred && !useRenderPassEnabled);
// Some render cases (e.g. Material previews) have shown we need to create a depth texture when we're forcing a prepass.
createDepthTexture |= useDepthPriming;
// Todo seems like with mrt depth is not taken from first target
createDepthTexture |= (renderingLayerProvidesRenderObjectPass);
#if ENABLE_VR && ENABLE_XR_MODULE
// URP can't handle msaa/size mismatch between depth RT and color RT(for now we create intermediate textures to ensure they match)
if (cameraData.xr.enabled)
createColorTexture |= createDepthTexture;
#endif
#if UNITY_ANDROID || UNITY_WEBGL
// GLES can not use render texture's depth buffer with the color buffer of the backbuffer
// in such case we create a color texture for it too.
// If Vulkan PreTransform is enabled we can't mix backbuffer and intermediate render target due to screen orientation mismatch
if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Vulkan || m_VulkanEnablePreTransform)
createColorTexture |= createDepthTexture;
#endif
// If there is any scaling, the color and depth need to be the same resolution and the target texture
// will not be the proper size in this case. Same happens with GameView.
// This introduces the final blit pass.
if (RTHandles.rtHandleProperties.rtHandleScale.x != 1.0f || RTHandles.rtHandleProperties.rtHandleScale.y != 1.0f)
createColorTexture |= createDepthTexture;
if (useRenderPassEnabled || useDepthPriming)
createColorTexture |= createDepthTexture;
//Set rt descriptors so preview camera's have access should it be needed
var colorDescriptor = cameraTargetDescriptor;
colorDescriptor.useMipMap = false;
colorDescriptor.autoGenerateMips = false;
colorDescriptor.depthBufferBits = (int)DepthBits.None;
m_ColorBufferSystem.SetCameraSettings(colorDescriptor, FilterMode.Bilinear);
bool clearInPostProcess = false;
// Configure all settings require to start a new camera stack (base camera only)
if (cameraData.renderType == CameraRenderType.Base)
{
// Scene filtering redraws the objects on top of the resulting frame. It has to draw directly to the sceneview buffer.
bool sceneViewFilterEnabled = camera.sceneViewFilterMode == Camera.SceneViewFilterMode.ShowFiltered;
bool intermediateRenderTexture = (createColorTexture || createDepthTexture) && !sceneViewFilterEnabled;
// RTHandles do not support combining color and depth in the same texture so we create them separately
// Should be independent from filtered scene view
//清除开关逻辑
if (cameraData.targetTexture != null)
createDepthTexture |= createColorTexture;
else
{
if (VolumeManager.instance.GetVolumes(renderingData.cameraData.volumeLayerMask).Length <= 0)
clearInPostProcess = true;
else
{
Volume currentVolume = VolumeManager.instance.GetVolumes(renderingData.cameraData.volumeLayerMask)[0];
if (currentVolume == null || !currentVolume.isActiveAndEnabled || !currentVolume.isGlobal || !currentVolume.gameObject.activeInHierarchy)
clearInPostProcess = true;
else
{
var stack = VolumeManager.instance.stack;
var components = VolumeManager.instance.baseComponentTypeArray
.Where(t => t.GetInterface(nameof(IPostProcessComponent)) != null && stack.GetComponent(t) != null)
.Select(t => stack.GetComponent(t) as IPostProcessComponent)
.ToList();
if (components == null || components.Count == 0)
clearInPostProcess = true;
else
{
var active_components = new List<IPostProcessComponent>();
foreach (var item in components)
{
if (item.IsActive())
active_components.Add(item);
}
if (active_components.Count == 0)
clearInPostProcess = true;
else
{
if (renderingData.cameraData.requiresDepthTexture || renderingData.cameraData.postProcessingRequiresDepthTexture)
createDepthTexture |= createColorTexture;
}
}
}
}
}
RenderTargetIdentifier targetId = BuiltinRenderTextureType.CameraTarget;
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
targetId = cameraData.xr.renderTarget;
#endif
if (m_XRTargetHandleAlias == null)
{
m_XRTargetHandleAlias = RTHandles.Alloc(targetId);
}
else if (m_XRTargetHandleAlias.nameID != targetId)
{
RTHandleStaticHelpers.SetRTHandleUserManagedWrapper(ref m_XRTargetHandleAlias, targetId);
}
// Doesn't create texture for Overlay cameras as they are already overlaying on top of created textures.
if (intermediateRenderTexture)
CreateCameraRenderTarget(context, ref cameraTargetDescriptor, useDepthPriming, cmd, ref cameraData);
m_RenderOpaqueForwardPass.m_IsActiveTargetBackBuffer = !intermediateRenderTexture;
m_RenderTransparentForwardPass.m_IsActiveTargetBackBuffer = !intermediateRenderTexture;
m_DrawSkyboxPass.m_IsActiveTargetBackBuffer = !intermediateRenderTexture;
#if ENABLE_VR && ENABLE_XR_MODULE
m_XROcclusionMeshPass.m_IsActiveTargetBackBuffer = !intermediateRenderTexture;
#endif
m_ActiveCameraColorAttachment = createColorTexture ? m_ColorBufferSystem.PeekBackBuffer() : m_XRTargetHandleAlias;
m_ActiveCameraDepthAttachment = createDepthTexture ? m_CameraDepthAttachment : m_XRTargetHandleAlias;
}
else
{
cameraData.baseCamera.TryGetComponent<UniversalAdditionalCameraData>(out var baseCameraData);
var baseRenderer = (UniversalRenderer)baseCameraData.scriptableRenderer;
if (m_ColorBufferSystem != baseRenderer.m_ColorBufferSystem)
{
m_ColorBufferSystem.Dispose();
m_ColorBufferSystem = baseRenderer.m_ColorBufferSystem;
}
m_ActiveCameraColorAttachment = m_ColorBufferSystem.PeekBackBuffer();
m_ActiveCameraDepthAttachment = baseRenderer.m_ActiveCameraDepthAttachment;
m_XRTargetHandleAlias = baseRenderer.m_XRTargetHandleAlias;
}
if (rendererFeatures.Count != 0 && !isPreviewCamera)
ConfigureCameraColorTarget(m_ColorBufferSystem.PeekBackBuffer());
bool copyColorPass = renderingData.cameraData.requiresOpaqueTexture || renderPassInputs.requiresColorTexture;
// Check the createColorTexture logic above: intermediate color texture is not available for preview cameras.
// Because intermediate color is not available and copyColor pass requires it, we disable CopyColor pass here.
copyColorPass &= !isPreviewCamera;
// Assign camera targets (color and depth)
ConfigureCameraTarget(m_ActiveCameraColorAttachment, m_ActiveCameraDepthAttachment);
bool hasPassesAfterPostProcessing = activeRenderPassQueue.Find(x => x.renderPassEvent == RenderPassEvent.AfterRenderingPostProcessing) != null;
if (mainLightShadows)
EnqueuePass(m_MainLightShadowCasterPass);
if (additionalLightShadows)
EnqueuePass(m_AdditionalLightsShadowCasterPass);
bool requiresDepthCopyPass = !requiresDepthPrepass
&& (renderingData.cameraData.requiresDepthTexture || cameraHasPostProcessingWithDepth || renderPassInputs.requiresDepthTexture)
&& createDepthTexture;
//清除临时RT
if (!requiresDepthTexture && !createDepthTexture && !requiresDepthCopyPass && !requiresDepthPrepass)
{
m_CameraDepthAttachment?.Release();
m_ActiveCameraDepthAttachment?.Release();
m_DepthTexture?.Release();
}
if (!createColorTexture)
{
m_ActiveCameraColorAttachment?.Release();
m_ColorBufferSystem.Dispose();
}
if (!copyColorPass)
{
m_OpaqueColor?.Release();
}
if ((DebugHandler != null) && DebugHandler.IsActiveForCamera(ref cameraData))
{
DebugHandler.TryGetFullscreenDebugMode(out var fullScreenMode);
if (fullScreenMode == DebugFullScreenMode.Depth)
{
requiresDepthPrepass = true;
}
if (!DebugHandler.IsLightingActive)
{
mainLightShadows = false;
additionalLightShadows = false;
if (!isSceneViewOrPreviewCamera)
{
requiresDepthPrepass = false;
useDepthPriming = false;
generateColorGradingLUT = false;
copyColorPass = false;
requiresDepthCopyPass = false;
}
}
if (useRenderPassEnabled)
useRenderPassEnabled = DebugHandler.IsRenderPassSupported;
}
cameraData.renderer.useDepthPriming = useDepthPriming;
if (this.renderingModeActual == RenderingMode.Deferred)
{
if (m_DeferredLights.UseRenderPass && (RenderPassEvent.AfterRenderingGbuffer == renderPassInputs.requiresDepthNormalAtEvent || !useRenderPassEnabled))
m_DeferredLights.DisableFramebufferFetchInput();
}
// Allocate m_DepthTexture if used
if ((this.renderingModeActual == RenderingMode.Deferred && !this.useRenderPassEnabled) || requiresDepthPrepass || requiresDepthCopyPass)
{
var depthDescriptor = cameraTargetDescriptor;
if ((requiresDepthPrepass && this.renderingModeActual != RenderingMode.Deferred) || !RenderingUtils.SupportsGraphicsFormat(GraphicsFormat.R32_SFloat, FormatUsage.Render))
{
depthDescriptor.graphicsFormat = GraphicsFormat.None;
depthDescriptor.depthStencilFormat = k_DepthStencilFormat;
depthDescriptor.depthBufferBits = k_DepthBufferBits;
}
else
{
depthDescriptor.graphicsFormat = GraphicsFormat.R32_SFloat;
depthDescriptor.depthStencilFormat = GraphicsFormat.None;
depthDescriptor.depthBufferBits = 0;
}
depthDescriptor.msaaSamples = 1;// Depth-Only pass don't use MSAA
RenderingUtils.ReAllocateIfNeeded(ref m_DepthTexture, depthDescriptor, FilterMode.Point, wrapMode: TextureWrapMode.Clamp, name: "_CameraDepthTexture");
cmd.SetGlobalTexture(m_DepthTexture.name, m_DepthTexture.nameID);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
if (requiresRenderingLayer || (renderingModeActual == RenderingMode.Deferred && m_DeferredLights.UseRenderingLayers))
{
ref var renderingLayersTexture = ref m_DecalLayersTexture;
string renderingLayersTextureName = "_CameraRenderingLayersTexture";
if (this.renderingModeActual == RenderingMode.Deferred && m_DeferredLights.UseRenderingLayers)
{
renderingLayersTexture = ref m_DeferredLights.GbufferAttachments[(int)m_DeferredLights.GBufferRenderingLayers];
renderingLayersTextureName = renderingLayersTexture.name;
}
var renderingLayersDescriptor = cameraTargetDescriptor;
renderingLayersDescriptor.depthBufferBits = 0;
// Never have MSAA on this depth texture. When doing MSAA depth priming this is the texture that is resolved to and used for post-processing.
if (!renderingLayerProvidesRenderObjectPass)
renderingLayersDescriptor.msaaSamples = 1;// Depth-Only pass don't use MSAA
// Find compatible render-target format for storing normals.
// Shader code outputs normals in signed format to be compatible with deferred gbuffer layout.
// Deferred gbuffer format is signed so that normals can be blended for terrain geometry.
if (this.renderingModeActual == RenderingMode.Deferred && m_DeferredLights.UseRenderingLayers)
renderingLayersDescriptor.graphicsFormat = m_DeferredLights.GetGBufferFormat(m_DeferredLights.GBufferRenderingLayers); // the one used by the gbuffer.
else
renderingLayersDescriptor.graphicsFormat = RenderingLayerUtils.GetFormat(renderingLayerMaskSize);
if (renderingModeActual == RenderingMode.Deferred && m_DeferredLights.UseRenderingLayers)
{
m_DeferredLights.ReAllocateGBufferIfNeeded(renderingLayersDescriptor, (int)m_DeferredLights.GBufferRenderingLayers);
}
else
{
RenderingUtils.ReAllocateIfNeeded(ref renderingLayersTexture, renderingLayersDescriptor, FilterMode.Point, TextureWrapMode.Clamp, name: renderingLayersTextureName);
}
cmd.SetGlobalTexture(renderingLayersTexture.name, renderingLayersTexture.nameID);
RenderingLayerUtils.SetupProperties(cmd, renderingLayerMaskSize);
if (this.renderingModeActual == RenderingMode.Deferred) // As this is requested by render pass we still want to set it
cmd.SetGlobalTexture("_CameraRenderingLayersTexture", renderingLayersTexture.nameID);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
// Allocate normal texture if used
if (requiresDepthPrepass && renderPassInputs.requiresNormalsTexture)
{
ref var normalsTexture = ref m_NormalsTexture;
string normalsTextureName = "_CameraNormalsTexture";
if (this.renderingModeActual == RenderingMode.Deferred)
{
normalsTexture = ref m_DeferredLights.GbufferAttachments[(int)m_DeferredLights.GBufferNormalSmoothnessIndex];
normalsTextureName = normalsTexture.name;
}
var normalDescriptor = cameraTargetDescriptor;
normalDescriptor.depthBufferBits = 0;
// Never have MSAA on this depth texture. When doing MSAA depth priming this is the texture that is resolved to and used for post-processing.
normalDescriptor.msaaSamples = useDepthPriming ? cameraTargetDescriptor.msaaSamples : 1;// Depth-Only passes don't use MSAA, unless depth priming is enabled
// Find compatible render-target format for storing normals.
// Shader code outputs normals in signed format to be compatible with deferred gbuffer layout.
// Deferred gbuffer format is signed so that normals can be blended for terrain geometry.
if (this.renderingModeActual == RenderingMode.Deferred)
normalDescriptor.graphicsFormat = m_DeferredLights.GetGBufferFormat(m_DeferredLights.GBufferNormalSmoothnessIndex); // the one used by the gbuffer.
else
normalDescriptor.graphicsFormat = DepthNormalOnlyPass.GetGraphicsFormat();
if (this.renderingModeActual == RenderingMode.Deferred)
{
m_DeferredLights.ReAllocateGBufferIfNeeded(normalDescriptor, (int)m_DeferredLights.GBufferNormalSmoothnessIndex);
}
else
{
RenderingUtils.ReAllocateIfNeeded(ref normalsTexture, normalDescriptor, FilterMode.Point, TextureWrapMode.Clamp, name: normalsTextureName);
}
cmd.SetGlobalTexture(normalsTexture.name, normalsTexture.nameID);
if (this.renderingModeActual == RenderingMode.Deferred) // As this is requested by render pass we still want to set it
cmd.SetGlobalTexture("_CameraNormalsTexture", normalsTexture.nameID);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
if (requiresDepthPrepass)
{
if (renderPassInputs.requiresNormalsTexture)
{
if (this.renderingModeActual == RenderingMode.Deferred)
{
// In deferred mode, depth-normal prepass does really primes the depth and normal buffers, instead of creating a copy.
// It is necessary because we need to render depth&normal for forward-only geometry and it is the only way
// to get them before the SSAO pass.
int gbufferNormalIndex = m_DeferredLights.GBufferNormalSmoothnessIndex;
if (m_DeferredLights.UseRenderingLayers)
m_DepthNormalPrepass.Setup(m_ActiveCameraDepthAttachment, m_DeferredLights.GbufferAttachments[gbufferNormalIndex], m_DeferredLights.GbufferAttachments[m_DeferredLights.GBufferRenderingLayers]);
else if (renderingLayerProvidesByDepthNormalPass)
m_DepthNormalPrepass.Setup(m_ActiveCameraDepthAttachment, m_DeferredLights.GbufferAttachments[gbufferNormalIndex], m_DecalLayersTexture);
else
m_DepthNormalPrepass.Setup(m_ActiveCameraDepthAttachment, m_DeferredLights.GbufferAttachments[gbufferNormalIndex]);
// Only render forward-only geometry, as standard geometry will be rendered as normal into the gbuffer.
if (RenderPassEvent.AfterRenderingGbuffer <= renderPassInputs.requiresDepthNormalAtEvent &&
renderPassInputs.requiresDepthNormalAtEvent <= RenderPassEvent.BeforeRenderingOpaques)
m_DepthNormalPrepass.shaderTagIds = k_DepthNormalsOnly;
}
else
{
if (renderingLayerProvidesByDepthNormalPass)
m_DepthNormalPrepass.Setup(m_DepthTexture, m_NormalsTexture, m_DecalLayersTexture);
else
m_DepthNormalPrepass.Setup(m_DepthTexture, m_NormalsTexture);
}
EnqueuePass(m_DepthNormalPrepass);
}
else
{
// Deferred renderer does not require a depth-prepass to generate samplable depth texture.
if (this.renderingModeActual != RenderingMode.Deferred)
{
m_DepthPrepass.Setup(cameraTargetDescriptor, m_DepthTexture);
EnqueuePass(m_DepthPrepass);
}
}
}
// depth priming still needs to copy depth because the prepass doesn't target anymore CameraDepthTexture
// TODO: this is unoptimal, investigate optimizations
if (useDepthPriming)
{
m_PrimedDepthCopyPass.Setup(m_ActiveCameraDepthAttachment, m_DepthTexture);
EnqueuePass(m_PrimedDepthCopyPass);
}
if (generateColorGradingLUT)
{
colorGradingLutPass.ConfigureDescriptor(in renderingData.postProcessingData, out var desc, out var filterMode);
RenderingUtils.ReAllocateIfNeeded(ref m_PostProcessPasses.m_ColorGradingLut, desc, filterMode, TextureWrapMode.Clamp, anisoLevel: 0, name: "_InternalGradingLut");
colorGradingLutPass.Setup(colorGradingLut);
EnqueuePass(colorGradingLutPass);
}
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.hasValidOcclusionMesh)
EnqueuePass(m_XROcclusionMeshPass);
#endif
bool lastCameraInTheStack = cameraData.resolveFinalTarget;
if (this.renderingModeActual == RenderingMode.Deferred)
{
if (m_DeferredLights.UseRenderPass && (RenderPassEvent.AfterRenderingGbuffer == renderPassInputs.requiresDepthNormalAtEvent || !useRenderPassEnabled))
m_DeferredLights.DisableFramebufferFetchInput();
EnqueueDeferred(ref renderingData, requiresDepthPrepass, renderPassInputs.requiresNormalsTexture, renderingLayerProvidesByDepthNormalPass, mainLightShadows, additionalLightShadows);
}
else
{
// Optimized store actions are very important on tile based GPUs and have a great impact on performance.
// if MSAA is enabled and any of the following passes need a copy of the color or depth target, make sure the MSAA'd surface is stored
// if following passes won't use it then just resolve (the Resolve action will still store the resolved surface, but discard the MSAA'd surface, which is very expensive to store).
RenderBufferStoreAction opaquePassColorStoreAction = RenderBufferStoreAction.Store;
if (cameraTargetDescriptor.msaaSamples > 1)
opaquePassColorStoreAction = copyColorPass ? RenderBufferStoreAction.StoreAndResolve : RenderBufferStoreAction.Store;
// make sure we store the depth only if following passes need it.
RenderBufferStoreAction opaquePassDepthStoreAction = (copyColorPass || requiresDepthCopyPass || !lastCameraInTheStack) ? RenderBufferStoreAction.Store : RenderBufferStoreAction.DontCare;
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled && cameraData.xr.copyDepth)
{
opaquePassDepthStoreAction = RenderBufferStoreAction.Store;
}
#endif
// handle multisample depth resolve by setting the appropriate store actions if supported
if (requiresDepthCopyPass && cameraTargetDescriptor.msaaSamples > 1 && RenderingUtils.MultisampleDepthResolveSupported())
{
bool isCopyDepthAfterTransparent = m_CopyDepthPass.renderPassEvent == RenderPassEvent.AfterRenderingTransparents;
// we could StoreAndResolve when the depth copy is after opaque, but performance wise doing StoreAndResolve of depth targets is more expensive than a simple Store + following depth copy pass on Apple GPUs,
// because of the extra resolve step. So, unless we are copying the depth after the transparent pass, just Store the depth target.
if (isCopyDepthAfterTransparent && !copyColorPass)
{
if (opaquePassDepthStoreAction == RenderBufferStoreAction.Store)
opaquePassDepthStoreAction = RenderBufferStoreAction.StoreAndResolve;
else if (opaquePassDepthStoreAction == RenderBufferStoreAction.DontCare)
opaquePassDepthStoreAction = RenderBufferStoreAction.Resolve;
}
}
DrawObjectsPass renderOpaqueForwardPass = null;
if (renderingLayerProvidesRenderObjectPass)
{
renderOpaqueForwardPass = m_RenderOpaqueForwardWithRenderingLayersPass;
m_RenderOpaqueForwardWithRenderingLayersPass.Setup(m_ActiveCameraColorAttachment, m_DecalLayersTexture, m_ActiveCameraDepthAttachment);
}
else
renderOpaqueForwardPass = m_RenderOpaqueForwardPass;
renderOpaqueForwardPass.ConfigureColorStoreAction(opaquePassColorStoreAction);
renderOpaqueForwardPass.ConfigureDepthStoreAction(opaquePassDepthStoreAction);
// If there is any custom render pass renders to opaque pass' target before opaque pass,
// we can't clear color as it contains the valid rendering output.
bool hasPassesBeforeOpaque = activeRenderPassQueue.Find(x => (x.renderPassEvent <= RenderPassEvent.BeforeRenderingOpaques) && !x.overrideCameraTarget) != null;
ClearFlag opaqueForwardPassClearFlag = (hasPassesBeforeOpaque || cameraData.renderType != CameraRenderType.Base)
? ClearFlag.None
: ClearFlag.Color;
#if ENABLE_VR && ENABLE_XR_MODULE
// workaround for DX11 and DX12 XR test failures.
// XRTODO: investigate DX XR clear issues.
if (SystemInfo.usesLoadStoreActions)
#endif
renderOpaqueForwardPass.ConfigureClear(opaqueForwardPassClearFlag, Color.black);
EnqueuePass(renderOpaqueForwardPass);
}
if (camera.clearFlags == CameraClearFlags.Skybox && cameraData.renderType != CameraRenderType.Overlay)
{
if (RenderSettings.skybox != null || (camera.TryGetComponent(out Skybox cameraSkybox) && cameraSkybox.material != null))
EnqueuePass(m_DrawSkyboxPass);
}
// If a depth texture was created we necessarily need to copy it, otherwise we could have render it to a renderbuffer.
// Also skip if Deferred+RenderPass as CameraDepthTexture is used and filled by the GBufferPass
// however we might need the depth texture with Forward-only pass rendered to it, so enable the copy depth in that case
if (requiresDepthCopyPass && !(this.renderingModeActual == RenderingMode.Deferred && useRenderPassEnabled && !renderPassInputs.requiresDepthTexture))
{
m_CopyDepthPass.Setup(m_ActiveCameraDepthAttachment, m_DepthTexture);
EnqueuePass(m_CopyDepthPass);
}
// Set the depth texture to the far Z if we do not have a depth prepass or copy depth
// Don't do this for Overlay cameras to not lose depth data in between cameras (as Base is guaranteed to be first)
if (cameraData.renderType == CameraRenderType.Base && !requiresDepthPrepass && !requiresDepthCopyPass)
Shader.SetGlobalTexture("_CameraDepthTexture", SystemInfo.usesReversedZBuffer ? Texture2D.blackTexture : Texture2D.whiteTexture);
if (copyColorPass)
{
// TODO: Downsampling method should be stored in the renderer instead of in the asset.
// We need to migrate this data to renderer. For now, we query the method in the active asset.
Downsampling downsamplingMethod = UniversalRenderPipeline.asset.opaqueDownsampling;
var descriptor = cameraTargetDescriptor;
CopyColorPass.ConfigureDescriptor(downsamplingMethod, ref descriptor, out var filterMode);
RenderingUtils.ReAllocateIfNeeded(ref m_OpaqueColor, descriptor, filterMode, TextureWrapMode.Clamp, name: "_CameraOpaqueTexture");
m_CopyColorPass.Setup(m_ActiveCameraColorAttachment, m_OpaqueColor, downsamplingMethod);
EnqueuePass(m_CopyColorPass);
}
// Motion vectors
if (renderPassInputs.requiresMotionVectors)
{
var colorDesc = cameraTargetDescriptor;
colorDesc.graphicsFormat = MotionVectorRenderPass.k_TargetFormat;
colorDesc.depthBufferBits = (int)DepthBits.None;
colorDesc.msaaSamples = 1; // Disable MSAA, consider a pixel resolve for half left velocity and half right velocity --> no velocity, which is untrue.
RenderingUtils.ReAllocateIfNeeded(ref m_MotionVectorColor, colorDesc, FilterMode.Point, TextureWrapMode.Clamp, name: "_MotionVectorTexture");
var depthDescriptor = cameraTargetDescriptor;
depthDescriptor.graphicsFormat = GraphicsFormat.None;
depthDescriptor.msaaSamples = 1;
RenderingUtils.ReAllocateIfNeeded(ref m_MotionVectorDepth, depthDescriptor, FilterMode.Point, TextureWrapMode.Clamp, name: "_MotionVectorDepthTexture");
m_MotionVectorPass.Setup(m_MotionVectorColor, m_MotionVectorDepth);
EnqueuePass(m_MotionVectorPass);
}
#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
if (needTransparencyPass)
#endif
{
if (transparentsNeedSettingsPass)
{
EnqueuePass(m_TransparentSettingsPass);
}
// if this is not lastCameraInTheStack we still need to Store, since the MSAA buffer might be needed by the Overlay cameras
RenderBufferStoreAction transparentPassColorStoreAction = cameraTargetDescriptor.msaaSamples > 1 && lastCameraInTheStack ? RenderBufferStoreAction.Resolve : RenderBufferStoreAction.Store;
RenderBufferStoreAction transparentPassDepthStoreAction = lastCameraInTheStack ? RenderBufferStoreAction.DontCare : RenderBufferStoreAction.Store;
// If CopyDepthPass pass event is scheduled on or after AfterRenderingTransparent, we will need to store the depth buffer or resolve (store for now until latest trunk has depth resolve support) it for MSAA case
if (requiresDepthCopyPass && m_CopyDepthPass.renderPassEvent >= RenderPassEvent.AfterRenderingTransparents)
{
transparentPassDepthStoreAction = RenderBufferStoreAction.Store;
// handle depth resolve on platforms supporting it
if (cameraTargetDescriptor.msaaSamples > 1 && RenderingUtils.MultisampleDepthResolveSupported())
transparentPassDepthStoreAction = RenderBufferStoreAction.Resolve;
}
m_RenderTransparentForwardPass.ConfigureColorStoreAction(transparentPassColorStoreAction);
m_RenderTransparentForwardPass.ConfigureDepthStoreAction(transparentPassDepthStoreAction);
EnqueuePass(m_RenderTransparentForwardPass);
}
EnqueuePass(m_OnRenderObjectCallbackPass);
bool shouldRenderUI = cameraData.rendersOverlayUI;
bool outputToHDR = cameraData.isHDROutputActive;
if (shouldRenderUI && outputToHDR)
{
m_DrawOffscreenUIPass.Setup(ref cameraData, k_DepthBufferBits);
EnqueuePass(m_DrawOffscreenUIPass);
}
bool hasCaptureActions = renderingData.cameraData.captureActions != null && lastCameraInTheStack;
// When FXAA or scaling is active, we must perform an additional pass at the end of the frame for the following reasons:
// 1. FXAA expects to be the last shader running on the image before it's presented to the screen. Since users are allowed
// to add additional render passes after post processing occurs, we can't run FXAA until all of those passes complete as well.
// The FinalPost pass is guaranteed to execute after user authored passes so FXAA is always run inside of it.
// 2. UberPost can only handle upscaling with linear filtering. All other filtering methods require the FinalPost pass.
// 3. TAA sharpening using standalone RCAS pass is required. (When upscaling is not enabled).
bool applyFinalPostProcessing = anyPostProcessing && lastCameraInTheStack &&
((renderingData.cameraData.antialiasing == AntialiasingMode.FastApproximateAntialiasing) ||
((renderingData.cameraData.imageScalingMode == ImageScalingMode.Upscaling) && (renderingData.cameraData.upscalingFilter != ImageUpscalingFilter.Linear)) ||
(renderingData.cameraData.IsTemporalAAEnabled() && renderingData.cameraData.taaSettings.contrastAdaptiveSharpening > 0.0f));
// When post-processing is enabled we can use the stack to resolve rendering to camera target (screen or RT).
// However when there are render passes executing after post we avoid resolving to screen so rendering continues (before sRGBConversion etc)
bool resolvePostProcessingToCameraTarget = !hasCaptureActions && !hasPassesAfterPostProcessing && !applyFinalPostProcessing;
bool needsColorEncoding = DebugHandler == null || !DebugHandler.HDRDebugViewIsActive(ref cameraData);
//处理后处理渲染没有组件临时RT释放
if (applyPostProcessing)
{
if (clearInPostProcess)
{
m_PostProcessPasses.m_AfterPostProcessColor?.Release();
postProcessPass?.Dispose();
}
else
{
var desc = PostProcessPass.GetCompatibleDescriptor(cameraTargetDescriptor, cameraTargetDescriptor.width, cameraTargetDescriptor.height, cameraTargetDescriptor.graphicsFormat, DepthBits.None);
RenderingUtils.ReAllocateIfNeeded(ref m_PostProcessPasses.m_AfterPostProcessColor, desc, FilterMode.Point, TextureWrapMode.Clamp, name: "_AfterPostProcessTexture");
}
}
else
{
m_PostProcessPasses.m_AfterPostProcessColor?.Release();
postProcessPass?.Dispose();
}
if (lastCameraInTheStack)
{
SetupFinalPassDebug(ref cameraData);
// Post-processing will resolve to final target. No need for final blit pass.
if (applyPostProcessing)
{
// if resolving to screen we need to be able to perform sRGBConversion in post-processing if necessary
bool doSRGBEncoding = resolvePostProcessingToCameraTarget && needsColorEncoding;
postProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, resolvePostProcessingToCameraTarget, m_ActiveCameraDepthAttachment, colorGradingLut, m_MotionVectorColor, applyFinalPostProcessing, doSRGBEncoding);
EnqueuePass(postProcessPass);
}
var sourceForFinalPass = m_ActiveCameraColorAttachment;
// Do FXAA or any other final post-processing effect that might need to run after AA.
if (applyFinalPostProcessing)
{
finalPostProcessPass.SetupFinalPass(sourceForFinalPass, true, needsColorEncoding);
EnqueuePass(finalPostProcessPass);
}
if (renderingData.cameraData.captureActions != null)
{
EnqueuePass(m_CapturePass);
}
// if post-processing then we already resolved to camera target while doing post.
// Also only do final blit if camera is not rendering to RT.
bool cameraTargetResolved =
// final PP always blit to camera target
applyFinalPostProcessing ||
// no final PP but we have PP stack. In that case it blit unless there are render pass after PP
(applyPostProcessing && !hasPassesAfterPostProcessing && !hasCaptureActions) ||
// offscreen camera rendering to a texture, we don't need a blit pass to resolve to screen
m_ActiveCameraColorAttachment.nameID == m_XRTargetHandleAlias.nameID;
// We need final blit to resolve to screen
if (!cameraTargetResolved)
{
m_FinalBlitPass.Setup(cameraTargetDescriptor, sourceForFinalPass);
EnqueuePass(m_FinalBlitPass);
}
if (shouldRenderUI && !outputToHDR)
{
EnqueuePass(m_DrawOverlayUIPass);
}
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
// active depth is depth target, we don't need a blit pass to resolve
bool depthTargetResolved = m_ActiveCameraDepthAttachment.nameID == cameraData.xr.renderTarget;
if (!depthTargetResolved && cameraData.xr.copyDepth)
{
m_XRCopyDepthPass.Setup(m_ActiveCameraDepthAttachment, m_XRTargetHandleAlias);
m_XRCopyDepthPass.CopyToDepth = true;
EnqueuePass(m_XRCopyDepthPass);
}
}
#endif
}
// stay in RT so we resume rendering on stack after post-processing
else if (applyPostProcessing)
{
postProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, false, m_ActiveCameraDepthAttachment, colorGradingLut, m_MotionVectorColor, false, false);
EnqueuePass(postProcessPass);
}
#if UNITY_EDITOR
if (isSceneViewOrPreviewCamera || (isGizmosEnabled && lastCameraInTheStack))
{
// Scene view camera should always resolve target (not stacked)
m_FinalDepthCopyPass.Setup(m_DepthTexture, k_CameraTarget);
m_FinalDepthCopyPass.CopyToDepth = true;
m_FinalDepthCopyPass.MssaSamples = 0;
// Turning off unnecessary NRP in Editor because of MSAA mistmatch between CameraTargetDescriptor vs camera backbuffer
// NRP layer considers this being a pass with MSAA samples by checking CameraTargetDescriptor taken from RP asset
// while the camera backbuffer has a single sample
m_FinalDepthCopyPass.useNativeRenderPass = false;
EnqueuePass(m_FinalDepthCopyPass);
}
#endif
}
/// <inheritdoc />
public override void SetupLights(ScriptableRenderContext context, ref RenderingData renderingData)
{
m_ForwardLights.Setup(context, ref renderingData);
if (this.renderingModeActual == RenderingMode.Deferred)
m_DeferredLights.SetupLights(context, ref renderingData);
}
/// <inheritdoc />
public override void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters,
ref CameraData cameraData)
{
// TODO: PerObjectCulling also affect reflection probes. Enabling it for now.
// if (asset.additionalLightsRenderingMode == LightRenderingMode.Disabled ||
// asset.maxAdditionalLightsCount == 0)
if (renderingModeActual == RenderingMode.ForwardPlus)
{
cullingParameters.cullingOptions |= CullingOptions.DisablePerObjectCulling;
}
// We disable shadow casters if both shadow casting modes are turned off
// or the shadow distance has been turned down to zero
bool isShadowCastingDisabled = !UniversalRenderPipeline.asset.supportsMainLightShadows && !UniversalRenderPipeline.asset.supportsAdditionalLightShadows;
bool isShadowDistanceZero = Mathf.Approximately(cameraData.maxShadowDistance, 0.0f);
if (isShadowCastingDisabled || isShadowDistanceZero)
{
cullingParameters.cullingOptions &= ~CullingOptions.ShadowCasters;
}
if (this.renderingModeActual == RenderingMode.Deferred)
cullingParameters.maximumVisibleLights = 0xFFFF;
else if (this.renderingModeActual == RenderingMode.ForwardPlus)
{
// We don't add one to the maximum light because mainlight is treated as any other light.
cullingParameters.maximumVisibleLights = UniversalRenderPipeline.maxVisibleAdditionalLights;
// Do not sort reflection probe from engine it will come in reverse order from what we need.
cullingParameters.reflectionProbeSortingCriteria = ReflectionProbeSortingCriteria.None;
}
else
{
// We set the number of maximum visible lights allowed and we add one for the mainlight...
//
// Note: However ScriptableRenderContext.Cull() does not differentiate between light types.
// If there is no active main light in the scene, ScriptableRenderContext.Cull() might return ( cullingParameters.maximumVisibleLights ) visible additional lights.
// i.e ScriptableRenderContext.Cull() might return ( UniversalRenderPipeline.maxVisibleAdditionalLights + 1 ) visible additional lights !
cullingParameters.maximumVisibleLights = UniversalRenderPipeline.maxVisibleAdditionalLights + 1;
}
cullingParameters.shadowDistance = cameraData.maxShadowDistance;
cullingParameters.conservativeEnclosingSphere = UniversalRenderPipeline.asset.conservativeEnclosingSphere;
cullingParameters.numIterationsEnclosingSphere = UniversalRenderPipeline.asset.numIterationsEnclosingSphere;
}
/// <inheritdoc />
public override void FinishRendering(CommandBuffer cmd)
{
m_ColorBufferSystem.Clear();
m_ActiveCameraColorAttachment = null;
m_ActiveCameraDepthAttachment = null;
}
void EnqueueDeferred(ref RenderingData renderingData, bool hasDepthPrepass, bool hasNormalPrepass, bool hasRenderingLayerPrepass, bool applyMainShadow, bool applyAdditionalShadow)
{
m_DeferredLights.Setup(
ref renderingData,
applyAdditionalShadow ? m_AdditionalLightsShadowCasterPass : null,
hasDepthPrepass,
hasNormalPrepass,
hasRenderingLayerPrepass,
m_DepthTexture,
m_ActiveCameraDepthAttachment,
m_ActiveCameraColorAttachment
);
// Need to call Configure for both of these passes to setup input attachments as first frame otherwise will raise errors
if (useRenderPassEnabled && m_DeferredLights.UseRenderPass)
{
m_GBufferPass.Configure(null, renderingData.cameraData.cameraTargetDescriptor);
m_DeferredPass.Configure(null, renderingData.cameraData.cameraTargetDescriptor);
}
EnqueuePass(m_GBufferPass);
//Must copy depth for deferred shading: TODO wait for API fix to bind depth texture as read-only resource.
if (!useRenderPassEnabled || !m_DeferredLights.UseRenderPass)
{
m_GBufferCopyDepthPass.Setup(m_CameraDepthAttachment, m_DepthTexture);
EnqueuePass(m_GBufferCopyDepthPass);
}
EnqueuePass(m_DeferredPass);
EnqueuePass(m_RenderOpaqueForwardOnlyPass);
}
private struct RenderPassInputSummary
{
internal bool requiresDepthTexture;
internal bool requiresDepthPrepass;
internal bool requiresNormalsTexture;
internal bool requiresColorTexture;
internal bool requiresColorTextureCreated;
internal bool requiresMotionVectors;
internal RenderPassEvent requiresDepthNormalAtEvent;
internal RenderPassEvent requiresDepthTextureEarliestEvent;
}
private RenderPassInputSummary GetRenderPassInputs(ref RenderingData renderingData)
{
RenderPassEvent beforeMainRenderingEvent = m_RenderingMode == RenderingMode.Deferred ? RenderPassEvent.BeforeRenderingGbuffer : RenderPassEvent.BeforeRenderingOpaques;
RenderPassInputSummary inputSummary = new RenderPassInputSummary();
inputSummary.requiresDepthNormalAtEvent = RenderPassEvent.BeforeRenderingOpaques;
inputSummary.requiresDepthTextureEarliestEvent = RenderPassEvent.BeforeRenderingPostProcessing;
for (int i = 0; i < activeRenderPassQueue.Count; ++i)
{
ScriptableRenderPass pass = activeRenderPassQueue[i];
bool needsDepth = (pass.input & ScriptableRenderPassInput.Depth) != ScriptableRenderPassInput.None;
bool needsNormals = (pass.input & ScriptableRenderPassInput.Normal) != ScriptableRenderPassInput.None;
bool needsColor = (pass.input & ScriptableRenderPassInput.Color) != ScriptableRenderPassInput.None;
bool needsMotion = (pass.input & ScriptableRenderPassInput.Motion) != ScriptableRenderPassInput.None;
bool eventBeforeMainRendering = pass.renderPassEvent <= beforeMainRenderingEvent;
// TODO: Need a better way to handle this, probably worth to recheck after render graph
// DBuffer requires color texture created as it does not handle y flip correctly
if (pass is DBufferRenderPass dBufferRenderPass)
{
inputSummary.requiresColorTextureCreated = true;
}
inputSummary.requiresDepthTexture |= needsDepth;
inputSummary.requiresDepthPrepass |= needsNormals || needsDepth && eventBeforeMainRendering;
inputSummary.requiresNormalsTexture |= needsNormals;
inputSummary.requiresColorTexture |= needsColor;
inputSummary.requiresMotionVectors |= needsMotion;
if (needsDepth)
inputSummary.requiresDepthTextureEarliestEvent = (RenderPassEvent)Mathf.Min((int)pass.renderPassEvent, (int)inputSummary.requiresDepthTextureEarliestEvent);
if (needsNormals || needsDepth)
inputSummary.requiresDepthNormalAtEvent = (RenderPassEvent)Mathf.Min((int)pass.renderPassEvent, (int)inputSummary.requiresDepthNormalAtEvent);
}
// NOTE: TAA and motion vector dependencies added here to share between Execute and Render (Graph) paths.
// TAA in postprocess requires motion to function.
if (renderingData.cameraData.IsTemporalAAEnabled())
inputSummary.requiresMotionVectors = true;
// Motion vectors imply depth
if (inputSummary.requiresMotionVectors)
{
inputSummary.requiresDepthTexture = true;
inputSummary.requiresDepthTextureEarliestEvent = (RenderPassEvent)Mathf.Min((int)m_MotionVectorPass.renderPassEvent, (int)inputSummary.requiresDepthTextureEarliestEvent);
}
return inputSummary;
}
void CreateCameraRenderTarget(ScriptableRenderContext context, ref RenderTextureDescriptor descriptor, bool primedDepth, CommandBuffer cmd, ref CameraData cameraData)
{
using (new ProfilingScope(null, Profiling.createCameraRenderTarget))
{
if (m_ColorBufferSystem.PeekBackBuffer() == null || m_ColorBufferSystem.PeekBackBuffer().nameID != BuiltinRenderTextureType.CameraTarget)
{
m_ActiveCameraColorAttachment = m_ColorBufferSystem.GetBackBuffer(cmd);
ConfigureCameraColorTarget(m_ActiveCameraColorAttachment);
cmd.SetGlobalTexture("_CameraColorTexture", m_ActiveCameraColorAttachment.nameID);
//Set _AfterPostProcessTexture, users might still rely on this although it is now always the cameratarget due to swapbuffer
cmd.SetGlobalTexture("_AfterPostProcessTexture", m_ActiveCameraColorAttachment.nameID);
}
if (m_CameraDepthAttachment == null || m_CameraDepthAttachment.nameID != BuiltinRenderTextureType.CameraTarget)
{
var depthDescriptor = descriptor;
depthDescriptor.useMipMap = false;
depthDescriptor.autoGenerateMips = false;
depthDescriptor.bindMS = false;
bool hasMSAA = depthDescriptor.msaaSamples > 1 && (SystemInfo.supportsMultisampledTextures != 0);
// if MSAA is enabled and we are not resolving depth, which we only do if the CopyDepthPass is AfterTransparents,
// then we want to bind the multisampled surface.
if (hasMSAA)
{
// if depth priming is enabled the copy depth primed pass is meant to do the MSAA resolve, so we want to bind the MS surface
if (IsDepthPrimingEnabled(ref cameraData))
depthDescriptor.bindMS = true;
else
depthDescriptor.bindMS = !(RenderingUtils.MultisampleDepthResolveSupported() &&
SystemInfo.supportsMultisampleAutoResolve &&
m_CopyDepthMode == CopyDepthMode.AfterTransparents);
}
// binding MS surfaces is not supported by the GLES backend, and it won't be fixed after investigating
// the high performance impact of potential fixes, which would make it more expensive than depth prepass (fogbugz 1339401 for more info)
if (IsGLESDevice())
depthDescriptor.bindMS = false;
depthDescriptor.graphicsFormat = GraphicsFormat.None;
depthDescriptor.depthStencilFormat = k_DepthStencilFormat;
RenderingUtils.ReAllocateIfNeeded(ref m_CameraDepthAttachment, depthDescriptor, FilterMode.Point, TextureWrapMode.Clamp, name: "_CameraDepthAttachment");
cmd.SetGlobalTexture(m_CameraDepthAttachment.name, m_CameraDepthAttachment.nameID);
// update the descriptor to match the depth attachment
descriptor.depthStencilFormat = depthDescriptor.depthStencilFormat;
descriptor.depthBufferBits = depthDescriptor.depthBufferBits;
}
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
bool PlatformRequiresExplicitMsaaResolve()
{
#if UNITY_EDITOR
// In the editor play-mode we use a Game View Render Texture, with
// samples count forced to 1 so we always need to do an explicit MSAA resolve.
return true;
#else
// On Metal/iOS the MSAA resolve is done implicitly as part of the renderpass, so we do not need an extra intermediate pass for the explicit autoresolve.
// Note: On Vulkan Standalone, despite SystemInfo.supportsMultisampleAutoResolve being true, the backbuffer has only 1 sample, so we still require
// the explicit resolve on non-mobile platforms with supportsMultisampleAutoResolve.
return !(SystemInfo.supportsMultisampleAutoResolve && Application.isMobilePlatform)
&& SystemInfo.graphicsDeviceType != GraphicsDeviceType.Metal;
#endif
}
/// <summary>
/// Checks if the pipeline needs to create a intermediate render texture.
/// </summary>
/// <param name="cameraData">CameraData contains all relevant render target information for the camera.</param>
/// <seealso cref="CameraData"/>
/// <returns>Return true if pipeline needs to render to a intermediate render texture.</returns>
bool RequiresIntermediateColorTexture(ref CameraData cameraData)
{
// When rendering a camera stack we always create an intermediate render texture to composite camera results.
// We create it upon rendering the Base camera.
if (cameraData.renderType == CameraRenderType.Base && !cameraData.resolveFinalTarget)
return true;
// Always force rendering into intermediate color texture if deferred rendering mode is selected.
// Reason: without intermediate color texture, the target camera texture is y-flipped.
// However, the target camera texture is bound during gbuffer pass and deferred pass.
// Gbuffer pass will not be y-flipped because it is MRT (see ScriptableRenderContext implementation),
// while deferred pass will be y-flipped, which breaks rendering.
// This incurs an extra blit into at the end of rendering.
if (this.renderingModeActual == RenderingMode.Deferred)
return true;
bool isSceneViewCamera = cameraData.isSceneViewCamera;
var cameraTargetDescriptor = cameraData.cameraTargetDescriptor;
int msaaSamples = cameraTargetDescriptor.msaaSamples;
bool isScaledRender = cameraData.imageScalingMode != ImageScalingMode.None;
bool isCompatibleBackbufferTextureDimension = cameraTargetDescriptor.dimension == TextureDimension.Tex2D;
bool requiresExplicitMsaaResolve = msaaSamples > 1 && PlatformRequiresExplicitMsaaResolve();
bool isOffscreenRender = cameraData.targetTexture != null && !isSceneViewCamera;
bool isCapturing = cameraData.captureActions != null;
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
{
isScaledRender = false;
isCompatibleBackbufferTextureDimension = cameraData.xr.renderTargetDesc.dimension == cameraTargetDescriptor.dimension;
}
#endif
bool postProcessEnabled = cameraData.postProcessEnabled && m_PostProcessPasses.isCreated;
bool requiresBlitForOffscreenCamera = postProcessEnabled || cameraData.requiresOpaqueTexture || requiresExplicitMsaaResolve || !cameraData.isDefaultViewport;
if (isOffscreenRender)
return requiresBlitForOffscreenCamera;
return requiresBlitForOffscreenCamera || isSceneViewCamera || isScaledRender || cameraData.isHdrEnabled ||
!isCompatibleBackbufferTextureDimension || isCapturing || cameraData.requireSrgbConversion;
}
bool CanCopyDepth(ref CameraData cameraData)
{
bool msaaEnabledForCamera = cameraData.cameraTargetDescriptor.msaaSamples > 1;
bool supportsTextureCopy = SystemInfo.copyTextureSupport != CopyTextureSupport.None;
bool supportsDepthTarget = RenderingUtils.SupportsRenderTextureFormat(RenderTextureFormat.Depth);
bool supportsDepthCopy = !msaaEnabledForCamera && (supportsDepthTarget || supportsTextureCopy);
bool msaaDepthResolve = msaaEnabledForCamera && SystemInfo.supportsMultisampledTextures != 0;
// copying MSAA depth on GLES3 is giving invalid results. This won't be fixed by the driver team because it would introduce performance issues (more info in the Fogbugz issue 1339401 comments)
if (IsGLESDevice() && msaaDepthResolve)
return false;
return supportsDepthCopy || msaaDepthResolve;
}
internal override void SwapColorBuffer(CommandBuffer cmd)
{
m_ColorBufferSystem.Swap();
//Check if we are using the depth that is attached to color buffer
if (m_ActiveCameraDepthAttachment.nameID != BuiltinRenderTextureType.CameraTarget)
ConfigureCameraTarget(m_ColorBufferSystem.GetBackBuffer(cmd), m_ActiveCameraDepthAttachment);
else
ConfigureCameraColorTarget(m_ColorBufferSystem.GetBackBuffer(cmd));
m_ActiveCameraColorAttachment = m_ColorBufferSystem.GetBackBuffer(cmd);
cmd.SetGlobalTexture("_CameraColorTexture", m_ActiveCameraColorAttachment.nameID);
//Set _AfterPostProcessTexture, users might still rely on this although it is now always the cameratarget due to swapbuffer
cmd.SetGlobalTexture("_AfterPostProcessTexture", m_ActiveCameraColorAttachment.nameID);
}
internal override RTHandle GetCameraColorFrontBuffer(CommandBuffer cmd)
{
return m_ColorBufferSystem.GetFrontBuffer(cmd);
}
internal override RTHandle GetCameraColorBackBuffer(CommandBuffer cmd)
{
return m_ColorBufferSystem.GetBackBuffer(cmd);
}
internal override void EnableSwapBufferMSAA(bool enable)
{
m_ColorBufferSystem.EnableMSAA(enable);
}
}
}
PostProcessPass：
这里修改的太过散乱，我就不细说了，讲一下方法。后处理脚本都有一个叫做Dispose的函数，此函数就是为了释放临时生成的内容，找到它，去查看这些临时内容被定义和使用的地方，查看上下逻辑，然后对其进行条件判定，在不需要的情况下去释放它们就可以。
举两个例子：
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using UnityEngine.Experimental.Rendering;
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Implement this interface on every post process volumes
/// </summary>
public interface IPostProcessComponent
{
/// <summary>
/// Tells if the post process needs to be rendered or not.
/// </summary>
/// <returns>True if the component is active, otherwise false.</returns>
bool IsActive();
/// <summary>
/// Tells if the post process can run the effect on-tile or if it needs a full pass.
/// </summary>
/// <returns>True if it can run on-tile, otherwise false.</returns>
bool IsTileCompatible();
}
}
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Renders the post-processing effect stack.
/// </summary>
internal class PostProcessPass : ScriptableRenderPass
{
RenderTextureDescriptor m_Descriptor;
RTHandle m_Source;
RTHandle m_Destination;
RTHandle m_Depth;
RTHandle m_InternalLut;
RTHandle m_MotionVectors;
RTHandle m_FullCoCTexture;
RTHandle m_HalfCoCTexture;
RTHandle m_PingTexture;
RTHandle m_PongTexture;
RTHandle[] m_BloomMipDown;
RTHandle[] m_BloomMipUp;
RTHandle m_BlendTexture;
RTHandle m_EdgeColorTexture;
RTHandle m_EdgeStencilTexture;
RTHandle m_TempTarget;
RTHandle m_TempTarget2;
const string k_RenderPostProcessingTag = "Render PostProcessing Effects";
const string k_RenderFinalPostProcessingTag = "Render Final PostProcessing Pass";
private static readonly ProfilingSampler m_ProfilingRenderPostProcessing = new ProfilingSampler(k_RenderPostProcessingTag);
private static readonly ProfilingSampler m_ProfilingRenderFinalPostProcessing = new ProfilingSampler(k_RenderFinalPostProcessingTag);
MaterialLibrary m_Materials;
PostProcessData m_Data;
// Builtin effects settings
DepthOfField m_DepthOfField;
MotionBlur m_MotionBlur;
PaniniProjection m_PaniniProjection;
Bloom m_Bloom;
LensDistortion m_LensDistortion;
ChromaticAberration m_ChromaticAberration;
Vignette m_Vignette;
ColorLookup m_ColorLookup;
ColorAdjustments m_ColorAdjustments;
Tonemapping m_Tonemapping;
FilmGrain m_FilmGrain;
// Misc
const int k_MaxPyramidSize = 16;
readonly GraphicsFormat m_DefaultHDRFormat;
bool m_UseRGBM;
readonly GraphicsFormat m_SMAAEdgeFormat;
readonly GraphicsFormat m_GaussianCoCFormat;
int m_DitheringTextureIndex;
RenderTargetIdentifier[] m_MRT2;
Vector4[] m_BokehKernel;
int m_BokehHash;
// Needed if the device changes its render target width/height (ex, Mobile platform allows change of orientation)
float m_BokehMaxRadius;
float m_BokehRCPAspect;
// True when this is the very last pass in the pipeline
bool m_IsFinalPass;
// If there's a final post process pass after this pass.
// If yes, Film Grain and Dithering are setup in the final pass, otherwise they are setup in this pass.
bool m_HasFinalPass;
// Some Android devices do not support sRGB backbuffer
// We need to do the conversion manually on those
// Also if HDR output is active
bool m_EnableColorEncodingIfNeeded;
// Use Fast conversions between SRGB and Linear
bool m_UseFastSRGBLinearConversion;
// Support Data Driven Lens Flare post process effect
bool m_SupportDataDrivenLensFlare;
// Blit to screen or color frontbuffer at the end
bool m_ResolveToScreen;
// Renderer is using swapbuffer system
bool m_UseSwapBuffer;
// RTHandle used as a temporary target when operations need to be performed before image scaling
RTHandle m_ScalingSetupTarget;
// RTHandle used as a temporary target when operations need to be performed after upscaling
RTHandle m_UpscaledTarget;
Material m_BlitMaterial;
/// <summary>
/// Creates a new <c>PostProcessPass</c> instance.
/// </summary>
/// <param name="evt">The <c>RenderPassEvent</c> to use.</param>
/// <param name="data">The <c>PostProcessData</c> resources to use.</param>
/// <param name="postProcessParams">The <c>PostProcessParams</c> run-time params to use.</param>
/// <seealso cref="RenderPassEvent"/>
/// <seealso cref="PostProcessData"/>
/// <seealso cref="PostProcessParams"/>
public PostProcessPass(RenderPassEvent evt, PostProcessData data, ref PostProcessParams postProcessParams)
{
base.profilingSampler = new ProfilingSampler(nameof(PostProcessPass));
renderPassEvent = evt;
m_Data = data;
m_Materials = new MaterialLibrary(data);
// Only two components are needed for edge render texture, but on some vendors four components may be faster.
if (SystemInfo.IsFormatSupported(GraphicsFormat.R8G8_UNorm, FormatUsage.Render) && SystemInfo.graphicsDeviceVendor.ToLowerInvariant().Contains("arm"))
m_SMAAEdgeFormat = GraphicsFormat.R8G8_UNorm;
else
m_SMAAEdgeFormat = GraphicsFormat.R8G8B8A8_UNorm;
if (SystemInfo.IsFormatSupported(GraphicsFormat.R16_UNorm, FormatUsage.Linear | FormatUsage.Render))
m_GaussianCoCFormat = GraphicsFormat.R16_UNorm;
else if (SystemInfo.IsFormatSupported(GraphicsFormat.R16_SFloat, FormatUsage.Linear | FormatUsage.Render))
m_GaussianCoCFormat = GraphicsFormat.R16_SFloat;
else // Expect CoC banding
m_GaussianCoCFormat = GraphicsFormat.R8_UNorm;
// Bloom pyramid shader ids - can't use a simple stackalloc in the bloom function as we
// unfortunately need to allocate strings
ShaderConstants._BloomMipUp = new int[k_MaxPyramidSize];
ShaderConstants._BloomMipDown = new int[k_MaxPyramidSize];
m_BloomMipUp = new RTHandle[k_MaxPyramidSize];
m_BloomMipDown = new RTHandle[k_MaxPyramidSize];
for (int i = 0; i < k_MaxPyramidSize; i++)
{
ShaderConstants._BloomMipUp[i] = Shader.PropertyToID("_BloomMipUp" + i);
ShaderConstants._BloomMipDown[i] = Shader.PropertyToID("_BloomMipDown" + i);
// Get name, will get Allocated with descriptor later
m_BloomMipUp[i] = RTHandles.Alloc(ShaderConstants._BloomMipUp[i], name: "_BloomMipUp" + i);
m_BloomMipDown[i] = RTHandles.Alloc(ShaderConstants._BloomMipDown[i], name: "_BloomMipDown" + i);
}
m_MRT2 = new RenderTargetIdentifier[2];
base.useNativeRenderPass = false;
m_BlitMaterial = postProcessParams.blitMaterial;
// Texture format pre-lookup
const FormatUsage usage = FormatUsage.Linear | FormatUsage.Render;
if (SystemInfo.IsFormatSupported(postProcessParams.requestHDRFormat, usage))
{
m_DefaultHDRFormat = postProcessParams.requestHDRFormat;
m_UseRGBM = false;
}
else if (SystemInfo.IsFormatSupported(GraphicsFormat.B10G11R11_UFloatPack32, usage)) // HDR fallback
{
m_DefaultHDRFormat = GraphicsFormat.B10G11R11_UFloatPack32;
m_UseRGBM = false;
}
else
{
m_DefaultHDRFormat = QualitySettings.activeColorSpace == ColorSpace.Linear
? GraphicsFormat.R8G8B8A8_SRGB
: GraphicsFormat.R8G8B8A8_UNorm;
m_UseRGBM = true;
}
}
/// <summary>
/// Cleans up the Material Library used in the passes.
/// </summary>
public void Cleanup() => m_Materials.Cleanup();
/// <summary>
/// Disposes used resources.
/// </summary>
public void Dispose()
{
foreach (var handle in m_BloomMipDown)
handle?.Release();
foreach (var handle in m_BloomMipUp)
handle?.Release();
m_ScalingSetupTarget?.Release();
m_UpscaledTarget?.Release();
m_FullCoCTexture?.Release();
m_HalfCoCTexture?.Release();
m_PingTexture?.Release();
m_PongTexture?.Release();
m_BlendTexture?.Release();
m_EdgeColorTexture?.Release();
m_EdgeStencilTexture?.Release();
m_TempTarget?.Release();
m_TempTarget2?.Release();
}
/// <summary>
/// Configures the pass.
/// </summary>
/// <param name="baseDescriptor"></param>
/// <param name="source"></param>
/// <param name="resolveToScreen"></param>
/// <param name="depth"></param>
/// <param name="internalLut"></param>
/// <param name="hasFinalPass"></param>
/// <param name="enableColorEncoding"></param>
public void Setup(in RenderTextureDescriptor baseDescriptor, in RTHandle source, bool resolveToScreen, in RTHandle depth, in RTHandle internalLut, in RTHandle motionVectors, bool hasFinalPass, bool enableColorEncoding)
{
m_Descriptor = baseDescriptor;
m_Descriptor.useMipMap = false;
m_Descriptor.autoGenerateMips = false;
m_Source = source;
m_Depth = depth;
m_InternalLut = internalLut;
m_MotionVectors = motionVectors;
m_IsFinalPass = false;
m_HasFinalPass = hasFinalPass;
m_EnableColorEncodingIfNeeded = enableColorEncoding;
m_ResolveToScreen = resolveToScreen;
m_Destination = k_CameraTarget;
m_UseSwapBuffer = true;
}
/// <summary>
/// Configures the pass.
/// </summary>
/// <param name="baseDescriptor"></param>
/// <param name="source"></param>
/// <param name="destination"></param>
/// <param name="depth"></param>
/// <param name="internalLut"></param>
/// <param name="hasFinalPass"></param>
/// <param name="enableColorEncoding"></param>
public void Setup(in RenderTextureDescriptor baseDescriptor, in RTHandle source, RTHandle destination, in RTHandle depth, in RTHandle internalLut, bool hasFinalPass, bool enableColorEncoding)
{
m_Descriptor = baseDescriptor;
m_Descriptor.useMipMap = false;
m_Descriptor.autoGenerateMips = false;
m_Source = source;
m_Destination = destination;
m_Depth = depth;
m_InternalLut = internalLut;
m_IsFinalPass = false;
m_HasFinalPass = hasFinalPass;
m_EnableColorEncodingIfNeeded = enableColorEncoding;
m_UseSwapBuffer = true;
}
/// <summary>
/// Configures the Final pass.
/// </summary>
/// <param name="source"></param>
/// <param name="useSwapBuffer"></param>
/// <param name="enableColorEncoding"></param>
public void SetupFinalPass(in RTHandle source, bool useSwapBuffer = false, bool enableColorEncoding = true)
{
m_Source = source;
m_Destination = k_CameraTarget;
m_IsFinalPass = true;
m_HasFinalPass = false;
m_EnableColorEncodingIfNeeded = enableColorEncoding;
m_UseSwapBuffer = useSwapBuffer;
}
/// <inheritdoc/>
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{
overrideCameraTarget = true;
}
public bool CanRunOnTile()
{
// Check builtin & user effects here
return false;
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// Start by pre-fetching all builtin effect settings we need
// Some of the color-grading settings are only used in the color grading lut pass
var stack = VolumeManager.instance.stack;
m_DepthOfField = stack.GetComponent<DepthOfField>();
m_MotionBlur = stack.GetComponent<MotionBlur>();
m_PaniniProjection = stack.GetComponent<PaniniProjection>();
m_Bloom = stack.GetComponent<Bloom>();
m_LensDistortion = stack.GetComponent<LensDistortion>();
m_ChromaticAberration = stack.GetComponent<ChromaticAberration>();
m_Vignette = stack.GetComponent<Vignette>();
m_ColorLookup = stack.GetComponent<ColorLookup>();
m_ColorAdjustments = stack.GetComponent<ColorAdjustments>();
m_Tonemapping = stack.GetComponent<Tonemapping>();
m_FilmGrain = stack.GetComponent<FilmGrain>();
m_UseFastSRGBLinearConversion = renderingData.postProcessingData.useFastSRGBLinearConversion;
m_SupportDataDrivenLensFlare = renderingData.postProcessingData.supportDataDrivenLensFlare;
var cmd = renderingData.commandBuffer;
if (m_IsFinalPass)
{
using (new ProfilingScope(cmd, m_ProfilingRenderFinalPostProcessing))
{
RenderFinalPass(cmd, ref renderingData);
}
}
else if (CanRunOnTile())
{
// TODO: Add a fast render path if only on-tile compatible effects are used and we're actually running on a platform that supports it
// Note: we can still work on-tile if FXAA is enabled, it'd be part of the final pass
}
else
{
// Regular render path (not on-tile) - we do everything in a single command buffer as it
// makes it easier to manage temporary targets' lifetime
using (new ProfilingScope(cmd, m_ProfilingRenderPostProcessing))
{
Render(cmd, ref renderingData);
}
}
}
RenderTextureDescriptor GetCompatibleDescriptor()
=> GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, m_Descriptor.graphicsFormat);
RenderTextureDescriptor GetCompatibleDescriptor(int width, int height, GraphicsFormat format, DepthBits depthBufferBits = DepthBits.None)
=> GetCompatibleDescriptor(m_Descriptor, width, height, format, depthBufferBits);
internal static RenderTextureDescriptor GetCompatibleDescriptor(RenderTextureDescriptor desc, int width, int height, GraphicsFormat format, DepthBits depthBufferBits = DepthBits.None)
{
desc.depthBufferBits = (int)depthBufferBits;
desc.msaaSamples = 1;
desc.width = width;
desc.height = height;
desc.graphicsFormat = format;
return desc;
}
bool RequireSRGBConversionBlitToBackBuffer(ref CameraData cameraData)
{
return cameraData.requireSrgbConversion && m_EnableColorEncodingIfNeeded;
}
bool RequireHDROutput(ref CameraData cameraData)
{
// If capturing, don't convert to HDR.
// If not last in the stack, don't convert to HDR.
return cameraData.isHDROutputActive && cameraData.captureActions == null;
}
void Render(CommandBuffer cmd, ref RenderingData renderingData)
{
ref CameraData cameraData = ref renderingData.cameraData;
ref ScriptableRenderer renderer = ref cameraData.renderer;
bool isSceneViewCamera = cameraData.isSceneViewCamera;
//Check amount of swaps we have to do
//We blit back and forth without msaa until the last blit.
bool useStopNan = cameraData.isStopNaNEnabled && m_Materials.stopNaN != null;
bool useSubPixeMorpAA = cameraData.antialiasing == AntialiasingMode.SubpixelMorphologicalAntiAliasing && SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
var dofMaterial = m_DepthOfField.mode.value == DepthOfFieldMode.Gaussian ? m_Materials.gaussianDepthOfField : m_Materials.bokehDepthOfField;
bool useDepthOfField = m_DepthOfField.IsActive() && !isSceneViewCamera && dofMaterial != null;
bool useLensFlare = !LensFlareCommonSRP.Instance.IsEmpty() && m_SupportDataDrivenLensFlare;
bool useMotionBlur = m_MotionBlur.IsActive() && !isSceneViewCamera;
bool usePaniniProjection = m_PaniniProjection.IsActive() && !isSceneViewCamera;
// Disable MotionBlur in EditMode, so that editing remains clear and readable.
// NOTE: HDRP does the same via CoreUtils::AreAnimatedMaterialsEnabled().
useMotionBlur = useMotionBlur && Application.isPlaying;
// Note that enabling jitters uses the same CameraData::IsTemporalAAEnabled(). So if we add any other kind of overrides (like
// disable useTemporalAA if another feature is disabled) then we need to put it in CameraData::IsTemporalAAEnabled() as opposed
// to tweaking the value here.
bool useTemporalAA = cameraData.IsTemporalAAEnabled();
if (cameraData.antialiasing == AntialiasingMode.TemporalAntiAliasing && !useTemporalAA)
TemporalAA.ValidateAndWarn(ref cameraData);
int amountOfPassesRemaining = (useStopNan ? 1 : 0) + (useSubPixeMorpAA ? 1 : 0) + (useDepthOfField ? 1 : 0) + (useLensFlare ? 1 : 0) + (useTemporalAA ? 1 : 0) + (useMotionBlur ? 1 : 0) + (usePaniniProjection ? 1 : 0);
if (m_UseSwapBuffer && amountOfPassesRemaining > 0)
{
renderer.EnableSwapBufferMSAA(false);
}
// Don't use these directly unless you have a good reason to, use GetSource() and
// GetDestination() instead
RTHandle source = m_UseSwapBuffer ? renderer.cameraColorTargetHandle : m_Source;
RTHandle destination = m_UseSwapBuffer ? renderer.GetCameraColorFrontBuffer(cmd) : null;
RTHandle GetSource() => source;
RTHandle GetDestination()
{
if (destination == null)
{
RenderingUtils.ReAllocateIfNeeded(ref m_TempTarget, GetCompatibleDescriptor(), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_TempTarget");
destination = m_TempTarget;
}
else if (destination == m_Source && m_Descriptor.msaaSamples > 1)
{
// Avoid using m_Source.id as new destination, it may come with a depth buffer that we don't want, may have MSAA that we don't want etc
RenderingUtils.ReAllocateIfNeeded(ref m_TempTarget2, GetCompatibleDescriptor(), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_TempTarget2");
destination = m_TempTarget2;
}
return destination;
}
void Swap(ref ScriptableRenderer r)
{
--amountOfPassesRemaining;
if (m_UseSwapBuffer)
{
r.SwapColorBuffer(cmd);
source = r.cameraColorTargetHandle;
//we want the last blit to be to MSAA
if (amountOfPassesRemaining == 0 && !m_HasFinalPass)
r.EnableSwapBufferMSAA(true);
destination = r.GetCameraColorFrontBuffer(cmd);
}
else
{
CoreUtils.Swap(ref source, ref destination);
}
}
// Setup projection matrix for cmd.DrawMesh()
cmd.SetGlobalMatrix(ShaderConstants._FullscreenProjMat, GL.GetGPUProjectionMatrix(Matrix4x4.identity, true));
// Optional NaN killer before post-processing kicks in
// stopNaN may be null on Adreno 3xx. It doesn't support full shader level 3.5, but SystemInfo.graphicsShaderLevel is 35.
if (useStopNan)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.StopNaNs)))
{
Blitter.BlitCameraTexture(cmd, GetSource(), GetDestination(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, m_Materials.stopNaN, 0);
Swap(ref renderer);
}
}
// Anti-aliasing
if (useSubPixeMorpAA)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.SMAA)))
{
DoSubpixelMorphologicalAntialiasing(ref cameraData, cmd, GetSource(), GetDestination());
Swap(ref renderer);
}
}
else
{
m_EdgeColorTexture?.Release();
m_BlendTexture?.Release();
m_EdgeStencilTexture?.Release();
}
// Depth of Field
// Adreno 3xx SystemInfo.graphicsShaderLevel is 35, but instancing support is disabled due to buggy drivers.
// DOF shader uses #pragma target 3.5 which adds requirement for instancing support, thus marking the shader unsupported on those devices.
if (useDepthOfField)
{
var markerName = m_DepthOfField.mode.value == DepthOfFieldMode.Gaussian
? URPProfileId.GaussianDepthOfField
: URPProfileId.BokehDepthOfField;
using (new ProfilingScope(cmd, ProfilingSampler.Get(markerName)))
{
DoDepthOfField(cameraData.camera, cmd, GetSource(), GetDestination(), cameraData.pixelRect);
Swap(ref renderer);
}
}
else
{
m_FullCoCTexture?.Release();
m_HalfCoCTexture?.Release();
m_PingTexture?.Release();
m_PongTexture?.Release();
}
// Temporal Anti Aliasing
if (useTemporalAA)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.TemporalAA)))
{
TemporalAA.ExecutePass(cmd, m_Materials.temporalAntialiasing, ref cameraData, source, destination, m_MotionVectors.rt);
Swap(ref renderer);
}
}
// Motion blur
if (useMotionBlur)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.MotionBlur)))
{
DoMotionBlur(cmd, GetSource(), GetDestination(), ref cameraData);
Swap(ref renderer);
}
}
// Panini projection is done as a fullscreen pass after all depth-based effects are done
// and before bloom kicks in
if (usePaniniProjection)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.PaniniProjection)))
{
DoPaniniProjection(cameraData.camera, cmd, GetSource(), GetDestination());
Swap(ref renderer);
}
}
// Combined post-processing stack
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.UberPostProcess)))
{
// Reset uber keywords
m_Materials.uber.shaderKeywords = null;
// Bloom goes first
bool bloomActive = m_Bloom.IsActive();
if (bloomActive)
{
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.Bloom)))
SetupBloom(cmd, GetSource(), m_Materials.uber);
}
else
{
foreach (var handle in m_BloomMipDown)
handle?.Release();
foreach (var handle in m_BloomMipUp)
handle?.Release();
}
// Lens Flare
if (useLensFlare)
{
bool usePanini;
float paniniDistance;
float paniniCropToFit;
if (m_PaniniProjection.IsActive())
{
usePanini = true;
paniniDistance = m_PaniniProjection.distance.value;
paniniCropToFit = m_PaniniProjection.cropToFit.value;
}
else
{
usePanini = false;
paniniDistance = 1.0f;
paniniCropToFit = 1.0f;
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.LensFlareDataDrivenComputeOcclusion)))
{
LensFlareDataDrivenComputeOcclusion(cameraData.camera, cmd, GetSource(), usePanini, paniniDistance, paniniCropToFit);
}
using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.LensFlareDataDriven)))
{
LensFlareDataDriven(cameraData.camera, cmd, GetSource(), usePanini, paniniDistance, paniniCropToFit);
}
}
// Setup other effects constants
SetupLensDistortion(m_Materials.uber, isSceneViewCamera);
SetupChromaticAberration(m_Materials.uber);
SetupVignette(m_Materials.uber, cameraData.xr);
SetupColorGrading(cmd, ref renderingData, m_Materials.uber);
// Only apply dithering & grain if there isn't a final pass.
SetupGrain(ref cameraData, m_Materials.uber);
SetupDithering(ref cameraData, m_Materials.uber);
if (RequireSRGBConversionBlitToBackBuffer(ref cameraData))
m_Materials.uber.EnableKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
bool requireHDROutput = RequireHDROutput(ref cameraData);
if (requireHDROutput)
{
// Color space conversion is already applied through color grading, do encoding if uber post is the last pass
// Otherwise encoding will happen in the final post process pass or the final blit pass
HDROutputUtils.Operation hdrOperation = !m_HasFinalPass && m_EnableColorEncodingIfNeeded ? HDROutputUtils.Operation.ColorEncoding : HDROutputUtils.Operation.None;
SetupHDROutput(cameraData.hdrDisplayInformation, cameraData.hdrDisplayColorGamut, m_Materials.uber, hdrOperation);
}
if (m_UseFastSRGBLinearConversion)
{
m_Materials.uber.EnableKeyword(ShaderKeywordStrings.UseFastSRGBLinearConversion);
}
DebugHandler debugHandler = GetActiveDebugHandler(ref renderingData);
bool resolveToDebugScreen = debugHandler != null && debugHandler.WriteToDebugScreenTexture(ref cameraData);
debugHandler?.UpdateShaderGlobalPropertiesForFinalValidationPass(cmd, ref cameraData, !m_HasFinalPass && !resolveToDebugScreen);
// Done with Uber, blit it
var colorLoadAction = RenderBufferLoadAction.DontCare;
if (m_Destination == k_CameraTarget && !cameraData.isDefaultViewport)
colorLoadAction = RenderBufferLoadAction.Load;
// Note: We rendering to "camera target" we need to get the cameraData.targetTexture as this will get the targetTexture of the camera stack.
// Overlay cameras need to output to the target described in the base camera while doing camera stack.
RenderTargetIdentifier cameraTargetID = BuiltinRenderTextureType.CameraTarget;
#if ENABLE_VR && ENABLE_XR_MODULE
if (cameraData.xr.enabled)
cameraTargetID = cameraData.xr.renderTarget;
#endif
if (!m_UseSwapBuffer)
m_ResolveToScreen = cameraData.resolveFinalTarget || m_Destination.nameID == cameraTargetID || m_HasFinalPass == true;
// With camera stacking we not always resolve post to final screen as we might run post-processing in the middle of the stack.
if (m_UseSwapBuffer && !m_ResolveToScreen)
{
if (!m_HasFinalPass)
{
// We need to reenable this to be able to blit to the correct AA target
renderer.EnableSwapBufferMSAA(true);
destination = renderer.GetCameraColorFrontBuffer(cmd);
}
Blitter.BlitCameraTexture(cmd, GetSource(), destination, colorLoadAction, RenderBufferStoreAction.Store, m_Materials.uber, 0);
renderer.ConfigureCameraColorTarget(destination);
Swap(ref renderer);
}
// TODO: Implement swapbuffer in 2DRenderer so we can remove this
// For now, when render post-processing in the middle of the camera stack (not resolving to screen)
// we do an extra blit to ping pong results back to color texture. In future we should allow a Swap of the current active color texture
// in the pipeline to avoid this extra blit.
else if (!m_UseSwapBuffer)
{
var firstSource = GetSource();
Blitter.BlitCameraTexture(cmd, firstSource, GetDestination(), colorLoadAction, RenderBufferStoreAction.Store, m_Materials.uber, 0);
Blitter.BlitCameraTexture(cmd, GetDestination(), m_Destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, m_BlitMaterial, m_Destination.rt?.filterMode == FilterMode.Bilinear ? 1 : 0);
}
else if (m_ResolveToScreen)
{
if (resolveToDebugScreen)
{
// Blit to the debugger texture instead of the camera target
Blitter.BlitCameraTexture(cmd, GetSource(), debugHandler.DebugScreenColorHandle, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, m_Materials.uber, 0);
renderer.ConfigureCameraTarget(debugHandler.DebugScreenColorHandle, debugHandler.DebugScreenDepthHandle);
}
else
{
// Get RTHandle alias to use RTHandle apis
RenderTargetIdentifier cameraTarget = cameraData.targetTexture != null ? new RenderTargetIdentifier(cameraData.targetTexture) : cameraTargetID;
RTHandleStaticHelpers.SetRTHandleStaticWrapper(cameraTarget);
var cameraTargetHandle = RTHandleStaticHelpers.s_RTHandleWrapper;
RenderingUtils.FinalBlit(cmd, ref cameraData, GetSource(), cameraTargetHandle, colorLoadAction, RenderBufferStoreAction.Store, m_Materials.uber, 0);
renderer.ConfigureCameraColorTarget(cameraTargetHandle);
}
}
}
}
#region Sub-pixel Morphological Anti-aliasing
void DoSubpixelMorphologicalAntialiasing(ref CameraData cameraData, CommandBuffer cmd, RTHandle source, RTHandle destination)
{
var camera = cameraData.camera;
var pixelRect = new Rect(Vector2.zero, new Vector2(cameraData.cameraTargetDescriptor.width, cameraData.cameraTargetDescriptor.height));
var material = m_Materials.subpixelMorphologicalAntialiasing;
const int kStencilBit = 64;
// Intermediate targets
RTHandle stencil; // We would only need stencil, no depth. But Unity doesn't support that.
if (m_Depth.nameID == BuiltinRenderTextureType.CameraTarget || m_Descriptor.msaaSamples > 1)
{
// In case m_Depth is CameraTarget it may refer to the backbuffer and we can't use that as an attachment on all platforms
RenderingUtils.ReAllocateIfNeeded(ref m_EdgeStencilTexture, GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, GraphicsFormat.None, DepthBits.Depth24), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_EdgeStencilTexture");
stencil = m_EdgeStencilTexture;
}
else
{
stencil = m_Depth;
}
RenderingUtils.ReAllocateIfNeeded(ref m_EdgeColorTexture, GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, m_SMAAEdgeFormat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_EdgeColorTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_BlendTexture, GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, GraphicsFormat.R8G8B8A8_UNorm), FilterMode.Point, TextureWrapMode.Clamp, name: "_BlendTexture");
// Globals
var targetSize = m_EdgeColorTexture.useScaling ? m_EdgeColorTexture.rtHandleProperties.currentRenderTargetSize : new Vector2Int(m_EdgeColorTexture.rt.width, m_EdgeColorTexture.rt.height);
material.SetVector(ShaderConstants._Metrics, new Vector4(1f / targetSize.x, 1f / targetSize.y, targetSize.x, targetSize.y));
material.SetTexture(ShaderConstants._AreaTexture, m_Data.textures.smaaAreaTex);
material.SetTexture(ShaderConstants._SearchTexture, m_Data.textures.smaaSearchTex);
material.SetFloat(ShaderConstants._StencilRef, (float)kStencilBit);
material.SetFloat(ShaderConstants._StencilMask, (float)kStencilBit);
// Quality presets
material.shaderKeywords = null;
switch (cameraData.antialiasingQuality)
{
case AntialiasingQuality.Low:
material.EnableKeyword(ShaderKeywordStrings.SmaaLow);
break;
case AntialiasingQuality.Medium:
material.EnableKeyword(ShaderKeywordStrings.SmaaMedium);
break;
case AntialiasingQuality.High:
material.EnableKeyword(ShaderKeywordStrings.SmaaHigh);
break;
}
// Pass 1: Edge detection
RenderingUtils.Blit(cmd, source, pixelRect,
m_EdgeColorTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
stencil, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.ColorStencil, Color.clear, // implicit depth=1.0f stencil=0x0
material, 0);
// Pass 2: Blend weights
RenderingUtils.Blit(cmd, m_EdgeColorTexture, pixelRect, m_BlendTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Color, Color.clear, material, 1);
// Pass 3: Neighborhood blending
cmd.SetGlobalTexture(ShaderConstants._BlendTexture, m_BlendTexture.nameID);
Blitter.BlitCameraTexture(cmd, source, destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 2);
}
#endregion
#region Depth Of Field
// TODO: CoC reprojection once TAA gets in LW
// TODO: Proper LDR/gamma support
void DoDepthOfField(Camera camera, CommandBuffer cmd, RTHandle source, RTHandle destination, Rect pixelRect)
{
if (m_DepthOfField.mode.value == DepthOfFieldMode.Gaussian)
DoGaussianDepthOfField(camera, cmd, source, destination, pixelRect);
else if (m_DepthOfField.mode.value == DepthOfFieldMode.Bokeh)
DoBokehDepthOfField(cmd, source, destination, pixelRect);
}
void DoGaussianDepthOfField(Camera camera, CommandBuffer cmd, RTHandle source, RTHandle destination, Rect pixelRect)
{
int downSample = 2;
var material = m_Materials.gaussianDepthOfField;
int wh = m_Descriptor.width / downSample;
int hh = m_Descriptor.height / downSample;
float farStart = m_DepthOfField.gaussianStart.value;
float farEnd = Mathf.Max(farStart, m_DepthOfField.gaussianEnd.value);
// Assumes a radius of 1 is 1 at 1080p
// Past a certain radius our gaussian kernel will look very bad so we'll clamp it for
// very high resolutions (4K+).
float maxRadius = m_DepthOfField.gaussianMaxRadius.value * (wh / 1080f);
maxRadius = Mathf.Min(maxRadius, 2f);
CoreUtils.SetKeyword(material, ShaderKeywordStrings.HighQualitySampling, m_DepthOfField.highQualitySampling.value);
material.SetVector(ShaderConstants._CoCParams, new Vector3(farStart, farEnd, maxRadius));
RenderingUtils.ReAllocateIfNeeded(ref m_FullCoCTexture, GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, m_GaussianCoCFormat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_FullCoCTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_HalfCoCTexture, GetCompatibleDescriptor(wh, hh, m_GaussianCoCFormat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_HalfCoCTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_PingTexture, GetCompatibleDescriptor(wh, hh, GraphicsFormat.R16G16B16A16_SFloat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_PingTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_PongTexture, GetCompatibleDescriptor(wh, hh, GraphicsFormat.R16G16B16A16_SFloat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_PongTexture");
PostProcessUtils.SetSourceSize(cmd, m_Descriptor);
cmd.SetGlobalVector(ShaderConstants._DownSampleScaleFactor, new Vector4(1.0f / downSample, 1.0f / downSample, downSample, downSample));
// Compute CoC
Blitter.BlitCameraTexture(cmd, source, m_FullCoCTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 0);
// Downscale & prefilter color + coc
m_MRT2[0] = m_HalfCoCTexture.nameID;
m_MRT2[1] = m_PingTexture.nameID;
cmd.SetGlobalTexture(ShaderConstants._FullCoCTexture, m_FullCoCTexture.nameID);
CoreUtils.SetRenderTarget(cmd, m_MRT2, m_HalfCoCTexture);
Vector2 viewportScale = source.useScaling ? new Vector2(source.rtHandleProperties.rtHandleScale.x, source.rtHandleProperties.rtHandleScale.y) : Vector2.one;
Blitter.BlitTexture(cmd, source, viewportScale, material, 1);
// Blur
cmd.SetGlobalTexture(ShaderConstants._HalfCoCTexture, m_HalfCoCTexture.nameID);
cmd.SetGlobalTexture(ShaderConstants._ColorTexture, source);
Blitter.BlitCameraTexture(cmd, m_PingTexture, m_PongTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 2);
Blitter.BlitCameraTexture(cmd, m_PongTexture, m_PingTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 3);
// Composite
cmd.SetGlobalTexture(ShaderConstants._ColorTexture, m_PingTexture.nameID);
cmd.SetGlobalTexture(ShaderConstants._FullCoCTexture, m_FullCoCTexture.nameID);
Blitter.BlitCameraTexture(cmd, source, destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 4);
}
void PrepareBokehKernel(float maxRadius, float rcpAspect)
{
const int kRings = 4;
const int kPointsPerRing = 7;
// Check the existing array
if (m_BokehKernel == null)
m_BokehKernel = new Vector4[42];
// Fill in sample points (concentric circles transformed to rotated N-Gon)
int idx = 0;
float bladeCount = m_DepthOfField.bladeCount.value;
float curvature = 1f - m_DepthOfField.bladeCurvature.value;
float rotation = m_DepthOfField.bladeRotation.value * Mathf.Deg2Rad;
const float PI = Mathf.PI;
const float TWO_PI = Mathf.PI * 2f;
for (int ring = 1; ring < kRings; ring++)
{
float bias = 1f / kPointsPerRing;
float radius = (ring + bias) / (kRings - 1f + bias);
int points = ring * kPointsPerRing;
for (int point = 0; point < points; point++)
{
// Angle on ring
float phi = 2f * PI * point / points;
// Transform to rotated N-Gon
// Adapted from "CryEngine 3 Graphics Gems" [Sousa13]
float nt = Mathf.Cos(PI / bladeCount);
float dt = Mathf.Cos(phi - (TWO_PI / bladeCount) * Mathf.Floor((bladeCount * phi + Mathf.PI) / TWO_PI));
float r = radius * Mathf.Pow(nt / dt, curvature);
float u = r * Mathf.Cos(phi - rotation);
float v = r * Mathf.Sin(phi - rotation);
float uRadius = u * maxRadius;
float vRadius = v * maxRadius;
float uRadiusPowTwo = uRadius * uRadius;
float vRadiusPowTwo = vRadius * vRadius;
float kernelLength = Mathf.Sqrt((uRadiusPowTwo + vRadiusPowTwo));
float uRCP = uRadius * rcpAspect;
m_BokehKernel[idx] = new Vector4(uRadius, vRadius, kernelLength, uRCP);
idx++;
}
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
static float GetMaxBokehRadiusInPixels(float viewportHeight)
{
// Estimate the maximum radius of bokeh (empirically derived from the ring count)
const float kRadiusInPixels = 14f;
return Mathf.Min(0.05f, kRadiusInPixels / viewportHeight);
}
void DoBokehDepthOfField(CommandBuffer cmd, RTHandle source, RTHandle destination, Rect pixelRect)
{
int downSample = 2;
var material = m_Materials.bokehDepthOfField;
int wh = m_Descriptor.width / downSample;
int hh = m_Descriptor.height / downSample;
// "A Lens and Aperture Camera Model for Synthetic Image Generation" [Potmesil81]
float F = m_DepthOfField.focalLength.value / 1000f;
float A = m_DepthOfField.focalLength.value / m_DepthOfField.aperture.value;
float P = m_DepthOfField.focusDistance.value;
float maxCoC = (A * F) / (P - F);
float maxRadius = GetMaxBokehRadiusInPixels(m_Descriptor.height);
float rcpAspect = 1f / (wh / (float)hh);
CoreUtils.SetKeyword(material, ShaderKeywordStrings.UseFastSRGBLinearConversion, m_UseFastSRGBLinearConversion);
cmd.SetGlobalVector(ShaderConstants._CoCParams, new Vector4(P, maxCoC, maxRadius, rcpAspect));
// Prepare the bokeh kernel constant buffer
int hash = m_DepthOfField.GetHashCode();
if (hash != m_BokehHash || maxRadius != m_BokehMaxRadius || rcpAspect != m_BokehRCPAspect)
{
m_BokehHash = hash;
m_BokehMaxRadius = maxRadius;
m_BokehRCPAspect = rcpAspect;
PrepareBokehKernel(maxRadius, rcpAspect);
}
cmd.SetGlobalVectorArray(ShaderConstants._BokehKernel, m_BokehKernel);
RenderingUtils.ReAllocateIfNeeded(ref m_FullCoCTexture, GetCompatibleDescriptor(m_Descriptor.width, m_Descriptor.height, GraphicsFormat.R8_UNorm), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_FullCoCTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_PingTexture, GetCompatibleDescriptor(wh, hh, GraphicsFormat.R16G16B16A16_SFloat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_PingTexture");
RenderingUtils.ReAllocateIfNeeded(ref m_PongTexture, GetCompatibleDescriptor(wh, hh, GraphicsFormat.R16G16B16A16_SFloat), FilterMode.Bilinear, TextureWrapMode.Clamp, name: "_PongTexture");
PostProcessUtils.SetSourceSize(cmd, m_Descriptor);
cmd.SetGlobalVector(ShaderConstants._DownSampleScaleFactor, new Vector4(1.0f / downSample, 1.0f / downSample, downSample, downSample));
float uvMargin = (1.0f / m_Descriptor.height) * downSample;
cmd.SetGlobalVector(ShaderConstants._BokehConstants, new Vector4(uvMargin, uvMargin * 2.0f));
// Compute CoC
Blitter.BlitCameraTexture(cmd, source, m_FullCoCTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 0);
cmd.SetGlobalTexture(ShaderConstants._FullCoCTexture, m_FullCoCTexture.nameID);
// Downscale & prefilter color + coc
Blitter.BlitCameraTexture(cmd, source, m_PingTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 1);
// Bokeh blur
Blitter.BlitCameraTexture(cmd, m_PingTexture, m_PongTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 2);
// Post-filtering
Blitter.BlitCameraTexture(cmd, m_PongTexture, m_PingTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 3);
// Composite
cmd.SetGlobalTexture(ShaderConstants._DofTexture, m_PingTexture.nameID);
Blitter.BlitCameraTexture(cmd, source, destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 4);
}
#endregion
#region LensFlareDataDriven
static float GetLensFlareLightAttenuation(Light light, Camera cam, Vector3 wo)
{
// Must always be true
if (light != null)
{
switch (light.type)
{
case LightType.Directional:
return LensFlareCommonSRP.ShapeAttenuationDirLight(light.transform.forward, wo);
case LightType.Point:
return LensFlareCommonSRP.ShapeAttenuationPointLight();
case LightType.Spot:
return LensFlareCommonSRP.ShapeAttenuationSpotConeLight(light.transform.forward, wo, light.spotAngle, light.innerSpotAngle / 180.0f);
default:
return 1.0f;
}
}
return 1.0f;
}
void LensFlareDataDrivenComputeOcclusion(Camera camera, CommandBuffer cmd, RenderTargetIdentifier source, bool usePanini, float paniniDistance, float paniniCropToFit)
{
var gpuNonJitteredProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true);
var gpuVP = gpuNonJitteredProj * camera.worldToCameraMatrix;
cmd.SetGlobalTexture(m_Depth.name, m_Depth.nameID);
LensFlareCommonSRP.ComputeOcclusion(
m_Materials.lensFlareDataDriven, camera,
(float)m_Descriptor.width, (float)m_Descriptor.height,
usePanini, paniniDistance, paniniCropToFit, true,
camera.transform.position,
gpuVP,
cmd,
false, false, null, null,
ShaderConstants._FlareOcclusionTex, -1, ShaderConstants._FlareOcclusionIndex, ShaderConstants._FlareTex, ShaderConstants._FlareColorValue,
-1, ShaderConstants._FlareData0, ShaderConstants._FlareData1, ShaderConstants._FlareData2, ShaderConstants._FlareData3, ShaderConstants._FlareData4);
}
void LensFlareDataDriven(Camera camera, CommandBuffer cmd, RenderTargetIdentifier source, bool usePanini, float paniniDistance, float paniniCropToFit)
{
var gpuNonJitteredProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true);
var gpuVP = gpuNonJitteredProj * camera.worldToCameraMatrix;
LensFlareCommonSRP.DoLensFlareDataDrivenCommon(
m_Materials.lensFlareDataDriven, camera, (float)m_Descriptor.width, (float)m_Descriptor.height,
usePanini, paniniDistance, paniniCropToFit,
true,
camera.transform.position,
gpuVP,
cmd,
false, false, null, null,
source,
(Light light, Camera cam, Vector3 wo) => { return GetLensFlareLightAttenuation(light, cam, wo); },
ShaderConstants._FlareOcclusionRemapTex, ShaderConstants._FlareOcclusionTex, ShaderConstants._FlareOcclusionIndex,
0, 0,
ShaderConstants._FlareTex, ShaderConstants._FlareColorValue, ShaderConstants._FlareData0, ShaderConstants._FlareData1, ShaderConstants._FlareData2, ShaderConstants._FlareData3, ShaderConstants._FlareData4,
false);
}
#endregion
#region Motion Blur
internal static readonly int k_ShaderPropertyId_ViewProjM = Shader.PropertyToID("_ViewProjM");
internal static readonly int k_ShaderPropertyId_PrevViewProjM = Shader.PropertyToID("_PrevViewProjM");
internal static readonly int k_ShaderPropertyId_ViewProjMStereo = Shader.PropertyToID("_ViewProjMStereo");
internal static readonly int k_ShaderPropertyId_PrevViewProjMStereo = Shader.PropertyToID("_PrevViewProjMStereo");
internal static void UpdateMotionBlurMatrices(ref Material material, Camera camera, XRPass xr)
{
MotionVectorsPersistentData motionData = null;
if (camera.TryGetComponent<UniversalAdditionalCameraData>(out var additionalCameraData))
motionData = additionalCameraData.motionVectorsPersistentData;
if (motionData == null)
return;
#if ENABLE_VR && ENABLE_XR_MODULE
if (xr.enabled && xr.singlePassEnabled)
{
material.SetMatrixArray(k_ShaderPropertyId_PrevViewProjMStereo, motionData.previousViewProjectionStereo);
material.SetMatrixArray(k_ShaderPropertyId_ViewProjMStereo, motionData.viewProjectionStereo);
}
else
#endif
{
int viewProjMIdx = 0;
#if ENABLE_VR && ENABLE_XR_MODULE
if (xr.enabled)
viewProjMIdx = xr.multipassId;
#endif
// TODO: These should be part of URP main matrix set. For now, we set them here for motion vector rendering.
material.SetMatrix(k_ShaderPropertyId_PrevViewProjM, motionData.previousViewProjectionStereo[viewProjMIdx]);
material.SetMatrix(k_ShaderPropertyId_ViewProjM, motionData.viewProjectionStereo[viewProjMIdx]);
}
}
void DoMotionBlur(CommandBuffer cmd, RTHandle source, RTHandle destination, ref CameraData cameraData)
{
var material = m_Materials.cameraMotionBlur;
UpdateMotionBlurMatrices(ref material, cameraData.camera, cameraData.xr);
material.SetFloat("_Intensity", m_MotionBlur.intensity.value);
material.SetFloat("_Clamp", m_MotionBlur.clamp.value);
PostProcessUtils.SetSourceSize(cmd, m_Descriptor);
Blitter.BlitCameraTexture(cmd, source, destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, (int)m_MotionBlur.quality.value);
}
#endregion
#region Panini Projection
// Back-ported & adapted from the work of the Stockholm demo team - thanks Lasse!
void DoPaniniProjection(Camera camera, CommandBuffer cmd, RTHandle source, RTHandle destination)
{
float distance = m_PaniniProjection.distance.value;
var viewExtents = CalcViewExtents(camera);
var cropExtents = CalcCropExtents(camera, distance);
float scaleX = cropExtents.x / viewExtents.x;
float scaleY = cropExtents.y / viewExtents.y;
float scaleF = Mathf.Min(scaleX, scaleY);
float paniniD = distance;
float paniniS = Mathf.Lerp(1f, Mathf.Clamp01(scaleF), m_PaniniProjection.cropToFit.value);
var material = m_Materials.paniniProjection;
material.SetVector(ShaderConstants._Params, new Vector4(viewExtents.x, viewExtents.y, paniniD, paniniS));
material.EnableKeyword(
1f - Mathf.Abs(paniniD) > float.Epsilon
? ShaderKeywordStrings.PaniniGeneric : ShaderKeywordStrings.PaniniUnitDistance
);
Blitter.BlitCameraTexture(cmd, source, destination, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, material, 0);
}
Vector2 CalcViewExtents(Camera camera)
{
float fovY = camera.fieldOfView * Mathf.Deg2Rad;
float aspect = m_Descriptor.width / (float)m_Descriptor.height;
float viewExtY = Mathf.Tan(0.5f * fovY);
float viewExtX = aspect * viewExtY;
return new Vector2(viewExtX, viewExtY);
}
Vector2 CalcCropExtents(Camera camera, float d)
{
// given
// S----------- E--X-------
// | ` ~. /,´
// |-- --- Q
// | ,/ `
// 1 | ,´/ `
// | ,´ / ´
// | ,´ / ´
// |,` / ,
// O /
// | / ,
// d | /
// | / ,
// |/ .
// P
// | ´
// | , ´
// +- ´
//
// have X
// want to find E
float viewDist = 1f + d;
var projPos = CalcViewExtents(camera);
var projHyp = Mathf.Sqrt(projPos.x * projPos.x + 1f);
float cylDistMinusD = 1f / projHyp;
float cylDist = cylDistMinusD + d;
var cylPos = projPos * cylDistMinusD;
return cylPos * (viewDist / cylDist);
}
#endregion
#region Bloom
void SetupBloom(CommandBuffer cmd, RTHandle source, Material uberMaterial)
{
// Start at half-res
int downres = 1;
switch (m_Bloom.downscale.value)
{
case BloomDownscaleMode.Half:
downres = 1;
break;
case BloomDownscaleMode.Quarter:
downres = 2;
break;
default:
throw new System.ArgumentOutOfRangeException();
}
int tw = m_Descriptor.width >> downres;
int th = m_Descriptor.height >> downres;
// Determine the iteration count
int maxSize = Mathf.Max(tw, th);
int iterations = Mathf.FloorToInt(Mathf.Log(maxSize, 2f) - 1);
int mipCount = Mathf.Clamp(iterations, 1, m_Bloom.maxIterations.value);
// Pre-filtering parameters
float clamp = m_Bloom.clamp.value;
float threshold = Mathf.GammaToLinearSpace(m_Bloom.threshold.value);
float thresholdKnee = threshold * 0.5f; // Hardcoded soft knee
// Material setup
float scatter = Mathf.Lerp(0.05f, 0.95f, m_Bloom.scatter.value);
var bloomMaterial = m_Materials.bloom;
bloomMaterial.SetVector(ShaderConstants._Params, new Vector4(scatter, clamp, threshold, thresholdKnee));
CoreUtils.SetKeyword(bloomMaterial, ShaderKeywordStrings.BloomHQ, m_Bloom.highQualityFiltering.value);
CoreUtils.SetKeyword(bloomMaterial, ShaderKeywordStrings.UseRGBM, m_UseRGBM);
// Prefilter
var desc = GetCompatibleDescriptor(tw, th, m_DefaultHDRFormat);
for (int i = 0; i < mipCount; i++)
{
RenderingUtils.ReAllocateIfNeeded(ref m_BloomMipUp[i], desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: m_BloomMipUp[i].name);
RenderingUtils.ReAllocateIfNeeded(ref m_BloomMipDown[i], desc, FilterMode.Bilinear, TextureWrapMode.Clamp, name: m_BloomMipDown[i].name);
desc.width = Mathf.Max(1, desc.width >> 1);
desc.height = Mathf.Max(1, desc.height >> 1);
}
Blitter.BlitCameraTexture(cmd, source, m_BloomMipDown[0], RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, bloomMaterial, 0);
// Downsample - gaussian pyramid
var lastDown = m_BloomMipDown[0];
for (int i = 1; i < mipCount; i++)
{
// Classic two pass gaussian blur - use mipUp as a temporary target
// First pass does 2x downsampling + 9-tap gaussian
// Second pass does 9-tap gaussian using a 5-tap filter + bilinear filtering
Blitter.BlitCameraTexture(cmd, lastDown, m_BloomMipUp[i], RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, bloomMaterial, 1);
Blitter.BlitCameraTexture(cmd, m_BloomMipUp[i], m_BloomMipDown[i], RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, bloomMaterial, 2);
lastDown = m_BloomMipDown[i];
}
// Upsample (bilinear by default, HQ filtering does bicubic instead
for (int i = mipCount - 2; i >= 0; i--)
{
var lowMip = (i == mipCount - 2) ? m_BloomMipDown[i + 1] : m_BloomMipUp[i + 1];
var highMip = m_BloomMipDown[i];
var dst = m_BloomMipUp[i];
cmd.SetGlobalTexture(ShaderConstants._SourceTexLowMip, lowMip);
Blitter.BlitCameraTexture(cmd, highMip, dst, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, bloomMaterial, 3);
}
// Setup bloom on uber
var tint = m_Bloom.tint.value.linear;
var luma = ColorUtils.Luminance(tint);
tint = luma > 0f ? tint * (1f / luma) : Color.white;
var bloomParams = new Vector4(m_Bloom.intensity.value, tint.r, tint.g, tint.b);
uberMaterial.SetVector(ShaderConstants._Bloom_Params, bloomParams);
uberMaterial.SetFloat(ShaderConstants._Bloom_RGBM, m_UseRGBM ? 1f : 0f);
cmd.SetGlobalTexture(ShaderConstants._Bloom_Texture, m_BloomMipUp[0]);
// Setup lens dirtiness on uber
// Keep the aspect ratio correct & center the dirt texture, we don't want it to be
// stretched or squashed
var dirtTexture = m_Bloom.dirtTexture.value == null ? Texture2D.blackTexture : m_Bloom.dirtTexture.value;
float dirtRatio = dirtTexture.width / (float)dirtTexture.height;
float screenRatio = m_Descriptor.width / (float)m_Descriptor.height;
var dirtScaleOffset = new Vector4(1f, 1f, 0f, 0f);
float dirtIntensity = m_Bloom.dirtIntensity.value;
if (dirtRatio > screenRatio)
{
dirtScaleOffset.x = screenRatio / dirtRatio;
dirtScaleOffset.z = (1f - dirtScaleOffset.x) * 0.5f;
}
else if (screenRatio > dirtRatio)
{
dirtScaleOffset.y = dirtRatio / screenRatio;
dirtScaleOffset.w = (1f - dirtScaleOffset.y) * 0.5f;
}
uberMaterial.SetVector(ShaderConstants._LensDirt_Params, dirtScaleOffset);
uberMaterial.SetFloat(ShaderConstants._LensDirt_Intensity, dirtIntensity);
uberMaterial.SetTexture(ShaderConstants._LensDirt_Texture, dirtTexture);
// Keyword setup - a bit convoluted as we're trying to save some variants in Uber...
if (m_Bloom.highQualityFiltering.value)
uberMaterial.EnableKeyword(dirtIntensity > 0f ? ShaderKeywordStrings.BloomHQDirt : ShaderKeywordStrings.BloomHQ);
else
uberMaterial.EnableKeyword(dirtIntensity > 0f ? ShaderKeywordStrings.BloomLQDirt : ShaderKeywordStrings.BloomLQ);
}
#endregion
#region Lens Distortion
void SetupLensDistortion(Material material, bool isSceneView)
{
float amount = 1.6f * Mathf.Max(Mathf.Abs(m_LensDistortion.intensity.value * 100f), 1f);
float theta = Mathf.Deg2Rad * Mathf.Min(160f, amount);
float sigma = 2f * Mathf.Tan(theta * 0.5f);
var center = m_LensDistortion.center.value * 2f - Vector2.one;
var p1 = new Vector4(
center.x,
center.y,
Mathf.Max(m_LensDistortion.xMultiplier.value, 1e-4f),
Mathf.Max(m_LensDistortion.yMultiplier.value, 1e-4f)
);
var p2 = new Vector4(
m_LensDistortion.intensity.value >= 0f ? theta : 1f / theta,
sigma,
1f / m_LensDistortion.scale.value,
m_LensDistortion.intensity.value * 100f
);
material.SetVector(ShaderConstants._Distortion_Params1, p1);
material.SetVector(ShaderConstants._Distortion_Params2, p2);
if (m_LensDistortion.IsActive() && !isSceneView)
material.EnableKeyword(ShaderKeywordStrings.Distortion);
}
#endregion
#region Chromatic Aberration
void SetupChromaticAberration(Material material)
{
material.SetFloat(ShaderConstants._Chroma_Params, m_ChromaticAberration.intensity.value * 0.05f);
if (m_ChromaticAberration.IsActive())
material.EnableKeyword(ShaderKeywordStrings.ChromaticAberration);
}
#endregion
#region Vignette
void SetupVignette(Material material, XRPass xrPass)
{
var color = m_Vignette.color.value;
var center = m_Vignette.center.value;
var aspectRatio = m_Descriptor.width / (float)m_Descriptor.height;
#if ENABLE_VR && ENABLE_XR_MODULE
if (xrPass != null && xrPass.enabled)
{
if (xrPass.singlePassEnabled)
material.SetVector(ShaderConstants._Vignette_ParamsXR, xrPass.ApplyXRViewCenterOffset(center));
else
// In multi-pass mode we need to modify the eye center with the values from .xy of the corrected
// center since the version of the shader that is not single-pass will use the value in _Vignette_Params2
center = xrPass.ApplyXRViewCenterOffset(center);
}
#endif
var v1 = new Vector4(
color.r, color.g, color.b,
m_Vignette.rounded.value ? aspectRatio : 1f
);
var v2 = new Vector4(
center.x, center.y,
m_Vignette.intensity.value * 3f,
m_Vignette.smoothness.value * 5f
);
material.SetVector(ShaderConstants._Vignette_Params1, v1);
material.SetVector(ShaderConstants._Vignette_Params2, v2);
}
#endregion
#region Color Grading
void SetupColorGrading(CommandBuffer cmd, ref RenderingData renderingData, Material material)
{
ref var postProcessingData = ref renderingData.postProcessingData;
bool hdr = postProcessingData.gradingMode == ColorGradingMode.HighDynamicRange;
int lutHeight = postProcessingData.lutSize;
int lutWidth = lutHeight * lutHeight;
// Source material setup
float postExposureLinear = Mathf.Pow(2f, m_ColorAdjustments.postExposure.value);
cmd.SetGlobalTexture(ShaderConstants._InternalLut, m_InternalLut.nameID);
material.SetVector(ShaderConstants._Lut_Params, new Vector4(1f / lutWidth, 1f / lutHeight, lutHeight - 1f, postExposureLinear));
material.SetTexture(ShaderConstants._UserLut, m_ColorLookup.texture.value);
material.SetVector(ShaderConstants._UserLut_Params, !m_ColorLookup.IsActive()
? Vector4.zero
: new Vector4(1f / m_ColorLookup.texture.value.width,
1f / m_ColorLookup.texture.value.height,
m_ColorLookup.texture.value.height - 1f,
m_ColorLookup.contribution.value)
);
if (hdr)
{
material.EnableKeyword(ShaderKeywordStrings.HDRGrading);
}
else
{
switch (m_Tonemapping.mode.value)
{
case TonemappingMode.Neutral: material.EnableKeyword(ShaderKeywordStrings.TonemapNeutral); break;
case TonemappingMode.ACES: material.EnableKeyword(ShaderKeywordStrings.TonemapACES); break;
default: break; // None
}
}
}
#endregion
#region Film Grain
void SetupGrain(ref CameraData cameraData, Material material)
{
// TODO: Investigate how to make grain work with HDR output.
if (!m_HasFinalPass && m_FilmGrain.IsActive())
{
material.EnableKeyword(ShaderKeywordStrings.FilmGrain);
PostProcessUtils.ConfigureFilmGrain(
m_Data,
m_FilmGrain,
cameraData.pixelWidth, cameraData.pixelHeight,
material
);
}
}
#endregion
#region 8-bit Dithering
void SetupDithering(ref CameraData cameraData, Material material)
{
// TODO: Investigate how to make dithering work with HDR output.
if (!m_HasFinalPass && cameraData.isDitheringEnabled)
{
material.EnableKeyword(ShaderKeywordStrings.Dithering);
m_DitheringTextureIndex = PostProcessUtils.ConfigureDithering(
m_Data,
m_DitheringTextureIndex,
cameraData.pixelWidth, cameraData.pixelHeight,
material
);
}
}
#endregion
#region HDR Output
void SetupHDROutput(HDROutputUtils.HDRDisplayInformation hdrDisplayInformation, ColorGamut hdrDisplayColorGamut, Material material, HDROutputUtils.Operation hdrOperations)
{
Vector4 hdrOutputLuminanceParams;
UniversalRenderPipeline.GetHDROutputLuminanceParameters(hdrDisplayInformation, hdrDisplayColorGamut, m_Tonemapping, out hdrOutputLuminanceParams);
material.SetVector(ShaderPropertyId.hdrOutputLuminanceParams, hdrOutputLuminanceParams);
HDROutputUtils.ConfigureHDROutput(material, hdrDisplayColorGamut, hdrOperations);
}
#endregion
#region Final pass
void RenderFinalPass(CommandBuffer cmd, ref RenderingData renderingData)
{
ref var cameraData = ref renderingData.cameraData;
var material = m_Materials.finalPass;
material.shaderKeywords = null;
PostProcessUtils.SetSourceSize(cmd, cameraData.cameraTargetDescriptor);
SetupGrain(ref cameraData, material);
SetupDithering(ref cameraData, material);
if (RequireSRGBConversionBlitToBackBuffer(ref cameraData))
material.EnableKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
HDROutputUtils.Operation hdrOperations = HDROutputUtils.Operation.None;
bool requireHDROutput = RequireHDROutput(ref cameraData);
if (requireHDROutput)
{
// If there is a final post process pass, it's always the final pass so do color encoding
hdrOperations = m_EnableColorEncodingIfNeeded ? HDROutputUtils.Operation.ColorEncoding : HDROutputUtils.Operation.None;
// If the color space conversion wasn't applied by the uber pass, do it here
if (!cameraData.postProcessEnabled)
hdrOperations |= HDROutputUtils.Operation.ColorConversion;
SetupHDROutput(cameraData.hdrDisplayInformation, cameraData.hdrDisplayColorGamut, material, hdrOperations);
}
DebugHandler debugHandler = GetActiveDebugHandler(ref renderingData);
bool resolveToDebugScreen = debugHandler != null && debugHandler.WriteToDebugScreenTexture(ref cameraData);
debugHandler?.UpdateShaderGlobalPropertiesForFinalValidationPass(cmd, ref cameraData, m_IsFinalPass && !resolveToDebugScreen);
if (m_UseSwapBuffer)
m_Source = cameraData.renderer.GetCameraColorBackBuffer(cmd);
RTHandle sourceTex = m_Source;
var colorLoadAction = cameraData.isDefaultViewport ? RenderBufferLoadAction.DontCare : RenderBufferLoadAction.Load;
bool isFxaaEnabled = (cameraData.antialiasing == AntialiasingMode.FastApproximateAntialiasing);
// FSR is only considered "enabled" when we're performing upscaling. (downscaling uses a linear filter unconditionally)
bool isFsrEnabled = ((cameraData.imageScalingMode == ImageScalingMode.Upscaling) && (cameraData.upscalingFilter == ImageUpscalingFilter.FSR));
// Reuse RCAS pass as an optional standalone post sharpening pass for TAA.
// This avoids the cost of EASU and is available for other upscaling options.
// If FSR is enabled then FSR settings override the TAA settings and we perform RCAS only once.
bool isTaaSharpeningEnabled = (cameraData.IsTemporalAAEnabled() && cameraData.taaSettings.contrastAdaptiveSharpening > 0.0f) && !isFsrEnabled;
if (cameraData.imageScalingMode != ImageScalingMode.None)
{
// When FXAA is enabled in scaled renders, we execute it in a separate blit since it's not designed to be used in
// situations where the input and output resolutions do not match.
// When FSR is active, we always need an additional pass since it has a very particular color encoding requirement.
// NOTE: An ideal implementation could inline this color conversion logic into the UberPost pass, but the current code structure would make
// this process very complex. Specifically, we'd need to guarantee that the uber post output is always written to a UNORM format render
// target in order to preserve the precision of specially encoded color data.
bool isSetupRequired = (isFxaaEnabled || isFsrEnabled);
// Make sure to remove any MSAA and attached depth buffers from the temporary render targets
var tempRtDesc = cameraData.cameraTargetDescriptor;
tempRtDesc.msaaSamples = 1;
tempRtDesc.depthBufferBits = 0;
// Select a UNORM format since we've already performed tonemapping. (Values are in 0-1 range)
// This improves precision and is required if we want to avoid excessive banding when FSR is in use.
if (!requireHDROutput)
tempRtDesc.graphicsFormat = UniversalRenderPipeline.MakeUnormRenderTextureGraphicsFormat();
m_Materials.scalingSetup.shaderKeywords = null;
if (isSetupRequired)
{
if (requireHDROutput)
{
SetupHDROutput(cameraData.hdrDisplayInformation, cameraData.hdrDisplayColorGamut, m_Materials.scalingSetup, HDROutputUtils.Operation.None);
}
if (isFxaaEnabled && isFsrEnabled)
{
m_Materials.scalingSetup.EnableKeyword(ShaderKeywordStrings.FxaaAndGamma20);
}
else if (isFxaaEnabled)
{
m_Materials.scalingSetup.EnableKeyword(ShaderKeywordStrings.Fxaa);
}
else if (isFsrEnabled)
{
m_Materials.scalingSetup.EnableKeyword(ShaderKeywordStrings.Gamma20);
}
RenderingUtils.ReAllocateIfNeeded(ref m_ScalingSetupTarget, tempRtDesc, FilterMode.Point, TextureWrapMode.Clamp, name: "_ScalingSetupTexture");
Blitter.BlitCameraTexture(cmd, m_Source, m_ScalingSetupTarget, colorLoadAction, RenderBufferStoreAction.Store, m_Materials.scalingSetup, 0);
sourceTex = m_ScalingSetupTarget;
}
else
{
m_ScalingSetupTarget?.Release();
}
switch (cameraData.imageScalingMode)
{
case ImageScalingMode.Upscaling:
{
// In the upscaling case, set material keywords based on the selected upscaling filter
// Note: If FSR is enabled, we go down this path regardless of the current render scale. We do this because
// FSR still provides visual benefits at 100% scale. This will also make the transition between 99% and 100%
// scale less obvious for cases where FSR is used with dynamic resolution scaling.
switch (cameraData.upscalingFilter)
{
case ImageUpscalingFilter.Point:
{
// TAA post sharpening is an RCAS pass, avoid overriding it with point sampling.
if (!isTaaSharpeningEnabled)
material.EnableKeyword(ShaderKeywordStrings.PointSampling);
break;
}
case ImageUpscalingFilter.Linear:
{
// Do nothing as linear is the default filter in the shader
break;
}
case ImageUpscalingFilter.FSR:
{
m_Materials.easu.shaderKeywords = null;
var upscaleRtDesc = tempRtDesc;
upscaleRtDesc.width = cameraData.pixelWidth;
upscaleRtDesc.height = cameraData.pixelHeight;
// EASU
RenderingUtils.ReAllocateIfNeeded(ref m_UpscaledTarget, upscaleRtDesc, FilterMode.Point, TextureWrapMode.Clamp, name: "_UpscaledTexture");
var fsrInputSize = new Vector2(cameraData.cameraTargetDescriptor.width, cameraData.cameraTargetDescriptor.height);
var fsrOutputSize = new Vector2(cameraData.pixelWidth, cameraData.pixelHeight);
FSRUtils.SetEasuConstants(cmd, fsrInputSize, fsrInputSize, fsrOutputSize);
Blitter.BlitCameraTexture(cmd, sourceTex, m_UpscaledTarget, colorLoadAction, RenderBufferStoreAction.Store, m_Materials.easu, 0);
// RCAS
// Use the override value if it's available, otherwise use the default.
float sharpness = cameraData.fsrOverrideSharpness ? cameraData.fsrSharpness : FSRUtils.kDefaultSharpnessLinear;
// Set up the parameters for the RCAS pass unless the sharpness value indicates that it wont have any effect.
if (cameraData.fsrSharpness > 0.0f)
{
// RCAS is performed during the final post blit, but we set up the parameters here for better logical grouping.
material.EnableKeyword(requireHDROutput ? ShaderKeywordStrings.EasuRcasAndHDRInput : ShaderKeywordStrings.Rcas);
FSRUtils.SetRcasConstantsLinear(cmd, sharpness);
}
// Update the source texture for the next operation
sourceTex = m_UpscaledTarget;
PostProcessUtils.SetSourceSize(cmd, upscaleRtDesc);
break;
}
}
break;
}
case ImageScalingMode.Downscaling:
{
// In the downscaling case, we don't perform any sort of filter override logic since we always want linear filtering
// and it's already the default option in the shader.
// Also disable TAA post sharpening pass when downscaling.
isTaaSharpeningEnabled = false;
break;
}
}
}
else if (isFxaaEnabled)
{
// In unscaled renders, FXAA can be safely performed in the FinalPost shader
material.EnableKeyword(ShaderKeywordStrings.Fxaa);
}
// Reuse RCAS as a standalone sharpening filter for TAA.
// If FSR is enabled then it overrides the TAA setting and we skip it.
if (isTaaSharpeningEnabled)
{
material.EnableKeyword(ShaderKeywordStrings.Rcas);
FSRUtils.SetRcasConstantsLinear(cmd, cameraData.taaSettings.contrastAdaptiveSharpening);
}
var cameraTarget = RenderingUtils.GetCameraTargetIdentifier(ref renderingData);
if (resolveToDebugScreen)
{
// Blit to the debugger texture instead of the camera target
Blitter.BlitCameraTexture(cmd, sourceTex, debugHandler.DebugScreenColorHandle, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store, material, 0);
cameraData.renderer.ConfigureCameraTarget(debugHandler.DebugScreenColorHandle, debugHandler.DebugScreenDepthHandle);
}
else
{
// Get RTHandle alias to use RTHandle apis
RTHandleStaticHelpers.SetRTHandleStaticWrapper(cameraTarget);
var cameraTargetHandle = RTHandleStaticHelpers.s_RTHandleWrapper;
RenderingUtils.FinalBlit(cmd, ref cameraData, sourceTex, cameraTargetHandle, colorLoadAction, RenderBufferStoreAction.Store, material, 0);
}
}
#endregion
#region Internal utilities
class MaterialLibrary
{
public readonly Material stopNaN;
public readonly Material subpixelMorphologicalAntialiasing;
public readonly Material gaussianDepthOfField;
public readonly Material bokehDepthOfField;
public readonly Material cameraMotionBlur;
public readonly Material paniniProjection;
public readonly Material bloom;
public readonly Material temporalAntialiasing;
public readonly Material scalingSetup;
public readonly Material easu;
public readonly Material uber;
public readonly Material finalPass;
public readonly Material lensFlareDataDriven;
public MaterialLibrary(PostProcessData data)
{
// NOTE NOTE NOTE NOTE NOTE NOTE
// If you create something here you must also destroy it in Cleanup()
// or it will leak during enter/leave play mode cycles
// NOTE NOTE NOTE NOTE NOTE NOTE
stopNaN = Load(data.shaders.stopNanPS);
subpixelMorphologicalAntialiasing = Load(data.shaders.subpixelMorphologicalAntialiasingPS);
gaussianDepthOfField = Load(data.shaders.gaussianDepthOfFieldPS);
bokehDepthOfField = Load(data.shaders.bokehDepthOfFieldPS);
cameraMotionBlur = Load(data.shaders.cameraMotionBlurPS);
paniniProjection = Load(data.shaders.paniniProjectionPS);
bloom = Load(data.shaders.bloomPS);
temporalAntialiasing = Load(data.shaders.temporalAntialiasingPS);
scalingSetup = Load(data.shaders.scalingSetupPS);
easu = Load(data.shaders.easuPS);
uber = Load(data.shaders.uberPostPS);
finalPass = Load(data.shaders.finalPostPassPS);
lensFlareDataDriven = Load(data.shaders.LensFlareDataDrivenPS);
}
Material Load(Shader shader)
{
if (shader == null)
{
Debug.LogErrorFormat($"Missing shader. PostProcessing render passes will not execute. Check for missing reference in the renderer resources.");
return null;
}
else if (!shader.isSupported)
{
return null;
}
return CoreUtils.CreateEngineMaterial(shader);
}
internal void Cleanup()
{
CoreUtils.Destroy(stopNaN);
CoreUtils.Destroy(subpixelMorphologicalAntialiasing);
CoreUtils.Destroy(gaussianDepthOfField);
CoreUtils.Destroy(bokehDepthOfField);
CoreUtils.Destroy(cameraMotionBlur);
CoreUtils.Destroy(paniniProjection);
CoreUtils.Destroy(bloom);
CoreUtils.Destroy(temporalAntialiasing);
CoreUtils.Destroy(scalingSetup);
CoreUtils.Destroy(easu);
CoreUtils.Destroy(uber);
CoreUtils.Destroy(finalPass);
CoreUtils.Destroy(lensFlareDataDriven);
}
}
// Precomputed shader ids to same some CPU cycles (mostly affects mobile)
static class ShaderConstants
{
public static readonly int _TempTarget = Shader.PropertyToID("_TempTarget");
public static readonly int _TempTarget2 = Shader.PropertyToID("_TempTarget2");
public static readonly int _StencilRef = Shader.PropertyToID("_StencilRef");
public static readonly int _StencilMask = Shader.PropertyToID("_StencilMask");
public static readonly int _FullCoCTexture = Shader.PropertyToID("_FullCoCTexture");
public static readonly int _HalfCoCTexture = Shader.PropertyToID("_HalfCoCTexture");
public static readonly int _DofTexture = Shader.PropertyToID("_DofTexture");
public static readonly int _CoCParams = Shader.PropertyToID("_CoCParams");
public static readonly int _BokehKernel = Shader.PropertyToID("_BokehKernel");
public static readonly int _BokehConstants = Shader.PropertyToID("_BokehConstants");
public static readonly int _PongTexture = Shader.PropertyToID("_PongTexture");
public static readonly int _PingTexture = Shader.PropertyToID("_PingTexture");
public static readonly int _Metrics = Shader.PropertyToID("_Metrics");
public static readonly int _AreaTexture = Shader.PropertyToID("_AreaTexture");
public static readonly int _SearchTexture = Shader.PropertyToID("_SearchTexture");
public static readonly int _EdgeTexture = Shader.PropertyToID("_EdgeTexture");
public static readonly int _BlendTexture = Shader.PropertyToID("_BlendTexture");
public static readonly int _ColorTexture = Shader.PropertyToID("_ColorTexture");
public static readonly int _Params = Shader.PropertyToID("_Params");
public static readonly int _SourceTexLowMip = Shader.PropertyToID("_SourceTexLowMip");
public static readonly int _Bloom_Params = Shader.PropertyToID("_Bloom_Params");
public static readonly int _Bloom_RGBM = Shader.PropertyToID("_Bloom_RGBM");
public static readonly int _Bloom_Texture = Shader.PropertyToID("_Bloom_Texture");
public static readonly int _LensDirt_Texture = Shader.PropertyToID("_LensDirt_Texture");
public static readonly int _LensDirt_Params = Shader.PropertyToID("_LensDirt_Params");
public static readonly int _LensDirt_Intensity = Shader.PropertyToID("_LensDirt_Intensity");
public static readonly int _Distortion_Params1 = Shader.PropertyToID("_Distortion_Params1");
public static readonly int _Distortion_Params2 = Shader.PropertyToID("_Distortion_Params2");
public static readonly int _Chroma_Params = Shader.PropertyToID("_Chroma_Params");
public static readonly int _Vignette_Params1 = Shader.PropertyToID("_Vignette_Params1");
public static readonly int _Vignette_Params2 = Shader.PropertyToID("_Vignette_Params2");
public static readonly int _Vignette_ParamsXR = Shader.PropertyToID("_Vignette_ParamsXR");
public static readonly int _Lut_Params = Shader.PropertyToID("_Lut_Params");
public static readonly int _UserLut_Params = Shader.PropertyToID("_UserLut_Params");
public static readonly int _InternalLut = Shader.PropertyToID("_InternalLut");
public static readonly int _UserLut = Shader.PropertyToID("_UserLut");
public static readonly int _DownSampleScaleFactor = Shader.PropertyToID("_DownSampleScaleFactor");
public static readonly int _FlareOcclusionRemapTex = Shader.PropertyToID("_FlareOcclusionRemapTex");
public static readonly int _FlareOcclusionTex = Shader.PropertyToID("_FlareOcclusionTex");
public static readonly int _FlareOcclusionIndex = Shader.PropertyToID("_FlareOcclusionIndex");
public static readonly int _FlareTex = Shader.PropertyToID("_FlareTex");
public static readonly int _FlareColorValue = Shader.PropertyToID("_FlareColorValue");
public static readonly int _FlareData0 = Shader.PropertyToID("_FlareData0");
public static readonly int _FlareData1 = Shader.PropertyToID("_FlareData1");
public static readonly int _FlareData2 = Shader.PropertyToID("_FlareData2");
public static readonly int _FlareData3 = Shader.PropertyToID("_FlareData3");
public static readonly int _FlareData4 = Shader.PropertyToID("_FlareData4");
public static readonly int _FlareData5 = Shader.PropertyToID("_FlareData5");
public static readonly int _FullscreenProjMat = Shader.PropertyToID("_FullscreenProjMat");
public static int[] _BloomMipUp;
public static int[] _BloomMipDown;
}
#endregion
}
}
这样剔除操作固然能够减少许多RT内存了，但有时候可能会出现Depth不会被剔除一致被累积的情况，这就需要对于的摄像机开启ClearDepth功能，这样就能清除之前的Depth信息了。
