1434 lines
70 KiB
C#
1434 lines
70 KiB
C#
using System;
|
|
using Unity.Collections;
|
|
using System.Collections.Generic;
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
using UnityEditor.Rendering.Universal;
|
|
#endif
|
|
using UnityEngine.Scripting.APIUpdating;
|
|
using Lightmapping = UnityEngine.Experimental.GlobalIllumination.Lightmapping;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using UnityEngine.Profiling;
|
|
|
|
namespace UnityEngine.Rendering.Universal
|
|
{
|
|
public sealed partial class UniversalRenderPipeline : RenderPipeline
|
|
{
|
|
public const string k_ShaderTagName = "UniversalPipeline";
|
|
|
|
private static class Profiling
|
|
{
|
|
private static Dictionary<int, ProfilingSampler> s_HashSamplerCache = new Dictionary<int, ProfilingSampler>();
|
|
public static readonly ProfilingSampler unknownSampler = new ProfilingSampler("Unknown");
|
|
|
|
// Specialization for camera loop to avoid allocations.
|
|
public static ProfilingSampler TryGetOrAddCameraSampler(Camera camera)
|
|
{
|
|
#if UNIVERSAL_PROFILING_NO_ALLOC
|
|
return unknownSampler;
|
|
#else
|
|
ProfilingSampler ps = null;
|
|
int cameraId = camera.GetHashCode();
|
|
bool exists = s_HashSamplerCache.TryGetValue(cameraId, out ps);
|
|
if (!exists)
|
|
{
|
|
// NOTE: camera.name allocates!
|
|
ps = new ProfilingSampler($"{nameof(UniversalRenderPipeline)}.{nameof(RenderSingleCamera)}: {camera.name}");
|
|
s_HashSamplerCache.Add(cameraId, ps);
|
|
}
|
|
return ps;
|
|
#endif
|
|
}
|
|
|
|
public static class Pipeline
|
|
{
|
|
// TODO: Would be better to add Profiling name hooks into RenderPipeline.cs, requires changes outside of Universal.
|
|
#if UNITY_2021_1_OR_NEWER
|
|
public static readonly ProfilingSampler beginContextRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(BeginContextRendering)}");
|
|
public static readonly ProfilingSampler endContextRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(EndContextRendering)}");
|
|
#else
|
|
public static readonly ProfilingSampler beginFrameRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(BeginFrameRendering)}");
|
|
public static readonly ProfilingSampler endFrameRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(EndFrameRendering)}");
|
|
#endif
|
|
public static readonly ProfilingSampler beginCameraRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(BeginCameraRendering)}");
|
|
public static readonly ProfilingSampler endCameraRendering = new ProfilingSampler($"{nameof(RenderPipeline)}.{nameof(EndCameraRendering)}");
|
|
|
|
const string k_Name = nameof(UniversalRenderPipeline);
|
|
public static readonly ProfilingSampler initializeCameraData = new ProfilingSampler($"{k_Name}.{nameof(InitializeCameraData)}");
|
|
public static readonly ProfilingSampler initializeStackedCameraData = new ProfilingSampler($"{k_Name}.{nameof(InitializeStackedCameraData)}");
|
|
public static readonly ProfilingSampler initializeAdditionalCameraData = new ProfilingSampler($"{k_Name}.{nameof(InitializeAdditionalCameraData)}");
|
|
public static readonly ProfilingSampler initializeRenderingData = new ProfilingSampler($"{k_Name}.{nameof(InitializeRenderingData)}");
|
|
public static readonly ProfilingSampler initializeShadowData = new ProfilingSampler($"{k_Name}.{nameof(InitializeShadowData)}");
|
|
public static readonly ProfilingSampler initializeLightData = new ProfilingSampler($"{k_Name}.{nameof(InitializeLightData)}");
|
|
public static readonly ProfilingSampler getPerObjectLightFlags = new ProfilingSampler($"{k_Name}.{nameof(GetPerObjectLightFlags)}");
|
|
public static readonly ProfilingSampler getMainLightIndex = new ProfilingSampler($"{k_Name}.{nameof(GetMainLightIndex)}");
|
|
public static readonly ProfilingSampler setupPerFrameShaderConstants = new ProfilingSampler($"{k_Name}.{nameof(SetupPerFrameShaderConstants)}");
|
|
|
|
public static class Renderer
|
|
{
|
|
const string k_Name = nameof(ScriptableRenderer);
|
|
public static readonly ProfilingSampler setupCullingParameters = new ProfilingSampler($"{k_Name}.{nameof(ScriptableRenderer.SetupCullingParameters)}");
|
|
public static readonly ProfilingSampler setup = new ProfilingSampler($"{k_Name}.{nameof(ScriptableRenderer.Setup)}");
|
|
};
|
|
|
|
public static class Context
|
|
{
|
|
const string k_Name = nameof(ScriptableRenderContext);
|
|
public static readonly ProfilingSampler submit = new ProfilingSampler($"{k_Name}.{nameof(ScriptableRenderContext.Submit)}");
|
|
};
|
|
|
|
public static class XR
|
|
{
|
|
public static readonly ProfilingSampler mirrorView = new ProfilingSampler("XR Mirror View");
|
|
};
|
|
};
|
|
}
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
internal static XRSystem m_XRSystem = new XRSystem();
|
|
#endif
|
|
|
|
public static float maxShadowBias
|
|
{
|
|
get => 10.0f;
|
|
}
|
|
|
|
public static float minRenderScale
|
|
{
|
|
get => 0.1f;
|
|
}
|
|
|
|
public static float maxRenderScale
|
|
{
|
|
get => 2.0f;
|
|
}
|
|
|
|
// Amount of Lights that can be shaded per object (in the for loop in the shader)
|
|
public static int maxPerObjectLights
|
|
{
|
|
// No support to bitfield mask and int[] in gles2. Can't index fast more than 4 lights.
|
|
// Check Lighting.hlsl for more details.
|
|
get => (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2) ? 4 : 8;
|
|
}
|
|
|
|
// These limits have to match same limits in Input.hlsl
|
|
internal const int k_MaxVisibleAdditionalLightsMobileShaderLevelLessThan45 = 16;
|
|
internal const int k_MaxVisibleAdditionalLightsMobile = 32;
|
|
internal const int k_MaxVisibleAdditionalLightsNonMobile = 256;
|
|
public static int maxVisibleAdditionalLights
|
|
{
|
|
get
|
|
{
|
|
// Must match: Input.hlsl, MAX_VISIBLE_LIGHTS
|
|
bool isMobile = GraphicsSettings.HasShaderDefine(BuiltinShaderDefine.SHADER_API_MOBILE);
|
|
if (isMobile && (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2 || (SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES3 && Graphics.minOpenGLESVersion <= OpenGLESVersion.OpenGLES30)))
|
|
return k_MaxVisibleAdditionalLightsMobileShaderLevelLessThan45;
|
|
|
|
// GLES can be selected as platform on Windows (not a mobile platform) but uniform buffer size so we must use a low light count.
|
|
return (isMobile || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLCore || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES2 || SystemInfo.graphicsDeviceType == GraphicsDeviceType.OpenGLES3)
|
|
? k_MaxVisibleAdditionalLightsMobile : k_MaxVisibleAdditionalLightsNonMobile;
|
|
}
|
|
}
|
|
|
|
// Match with values in Input.hlsl
|
|
internal static int lightsPerTile => ((maxVisibleAdditionalLights + 31) / 32) * 32;
|
|
internal static int maxZBins => 1024 * 4;
|
|
internal static int maxTileVec4s => 4096;
|
|
|
|
internal const int k_DefaultRenderingLayerMask = 0x00000001;
|
|
private readonly DebugDisplaySettingsUI m_DebugDisplaySettingsUI = new DebugDisplaySettingsUI();
|
|
|
|
private UniversalRenderPipelineGlobalSettings m_GlobalSettings;
|
|
public override RenderPipelineGlobalSettings defaultSettings => m_GlobalSettings;
|
|
|
|
// Reference to the asset associated with the pipeline.
|
|
// When a pipeline asset is switched in `GraphicsSettings`, the `UniversalRenderPipelineCore.asset` member
|
|
// becomes unreliable for the purpose of pipeline and renderer clean-up in the `Dispose` call from
|
|
// `RenderPipelineManager.CleanupRenderPipeline`.
|
|
// This field provides the correct reference for the purpose of cleaning up the renderers on this pipeline
|
|
// asset.
|
|
private readonly UniversalRenderPipelineAsset pipelineAsset;
|
|
|
|
/// <inheritdoc/>
|
|
public override string ToString() => pipelineAsset?.ToString();
|
|
|
|
public UniversalRenderPipeline(UniversalRenderPipelineAsset asset)
|
|
{
|
|
pipelineAsset = asset;
|
|
#if UNITY_EDITOR
|
|
m_GlobalSettings = UniversalRenderPipelineGlobalSettings.Ensure();
|
|
#else
|
|
m_GlobalSettings = UniversalRenderPipelineGlobalSettings.instance;
|
|
#endif
|
|
SetSupportedRenderingFeatures();
|
|
|
|
// In QualitySettings.antiAliasing disabled state uses value 0, where in URP 1
|
|
int qualitySettingsMsaaSampleCount = QualitySettings.antiAliasing > 0 ? QualitySettings.antiAliasing : 1;
|
|
bool msaaSampleCountNeedsUpdate = qualitySettingsMsaaSampleCount != asset.msaaSampleCount;
|
|
|
|
// Let engine know we have MSAA on for cases where we support MSAA backbuffer
|
|
if (msaaSampleCountNeedsUpdate)
|
|
{
|
|
QualitySettings.antiAliasing = asset.msaaSampleCount;
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
XRSystem.UpdateMSAALevel(asset.msaaSampleCount);
|
|
#endif
|
|
}
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
XRSystem.UpdateRenderScale(asset.renderScale);
|
|
#endif
|
|
Shader.globalRenderPipeline = "UniversalPipeline";
|
|
|
|
Lightmapping.SetDelegate(lightsDelegate);
|
|
|
|
CameraCaptureBridge.enabled = true;
|
|
|
|
RenderingUtils.ClearSystemInfoCache();
|
|
|
|
DecalProjector.defaultMaterial = asset.decalMaterial;
|
|
|
|
DebugManager.instance.RefreshEditor();
|
|
m_DebugDisplaySettingsUI.RegisterDebug(DebugDisplaySettings.Instance);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
m_DebugDisplaySettingsUI.UnregisterDebug();
|
|
|
|
base.Dispose(disposing);
|
|
|
|
pipelineAsset.DestroyRenderers();
|
|
|
|
Shader.globalRenderPipeline = "";
|
|
|
|
SupportedRenderingFeatures.active = new SupportedRenderingFeatures();
|
|
ShaderData.instance.Dispose();
|
|
DeferredShaderData.instance.Dispose();
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
m_XRSystem?.Dispose();
|
|
#endif
|
|
|
|
#if UNITY_EDITOR
|
|
SceneViewDrawMode.ResetDrawMode();
|
|
#endif
|
|
Lightmapping.ResetDelegate();
|
|
CameraCaptureBridge.enabled = false;
|
|
}
|
|
|
|
#if UNITY_2021_1_OR_NEWER
|
|
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
|
|
{
|
|
Render(renderContext, new List<Camera>(cameras));
|
|
}
|
|
|
|
#endif
|
|
|
|
#if UNITY_2021_1_OR_NEWER
|
|
protected override void Render(ScriptableRenderContext renderContext, List<Camera> cameras)
|
|
#else
|
|
protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
|
|
#endif
|
|
{
|
|
// TODO: Would be better to add Profiling name hooks into RenderPipelineManager.
|
|
// C#8 feature, only in >= 2020.2
|
|
using var profScope = new ProfilingScope(null, ProfilingSampler.Get(URPProfileId.UniversalRenderTotal));
|
|
|
|
#if UNITY_2021_1_OR_NEWER
|
|
using (new ProfilingScope(null, Profiling.Pipeline.beginContextRendering))
|
|
{
|
|
BeginContextRendering(renderContext, cameras);
|
|
}
|
|
#else
|
|
using (new ProfilingScope(null, Profiling.Pipeline.beginFrameRendering))
|
|
{
|
|
BeginFrameRendering(renderContext, cameras);
|
|
}
|
|
#endif
|
|
|
|
GraphicsSettings.lightsUseLinearIntensity = (QualitySettings.activeColorSpace == ColorSpace.Linear);
|
|
GraphicsSettings.lightsUseColorTemperature = true;
|
|
GraphicsSettings.useScriptableRenderPipelineBatching = asset.useSRPBatcher;
|
|
GraphicsSettings.defaultRenderingLayerMask = k_DefaultRenderingLayerMask;
|
|
SetupPerFrameShaderConstants();
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
// Update XR MSAA level per frame.
|
|
XRSystem.UpdateMSAALevel(asset.msaaSampleCount);
|
|
#endif
|
|
|
|
#if UNITY_EDITOR
|
|
// We do not want to start rendering if URP global settings are not ready (m_globalSettings is null)
|
|
// or been deleted/moved (m_globalSettings is not necessarily null)
|
|
if (m_GlobalSettings == null || UniversalRenderPipelineGlobalSettings.instance == null)
|
|
{
|
|
m_GlobalSettings = UniversalRenderPipelineGlobalSettings.Ensure();
|
|
if(m_GlobalSettings == null) return;
|
|
}
|
|
#endif
|
|
|
|
SortCameras(cameras);
|
|
#if UNITY_2021_1_OR_NEWER
|
|
for (int i = 0; i < cameras.Count; ++i)
|
|
#else
|
|
for (int i = 0; i < cameras.Length; ++i)
|
|
#endif
|
|
{
|
|
var camera = cameras[i];
|
|
if (IsGameCamera(camera))
|
|
{
|
|
RenderCameraStack(renderContext, camera);
|
|
}
|
|
else
|
|
{
|
|
using (new ProfilingScope(null, Profiling.Pipeline.beginCameraRendering))
|
|
{
|
|
BeginCameraRendering(renderContext, camera);
|
|
}
|
|
#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
|
|
//It should be called before culling to prepare material. When there isn't any VisualEffect component, this method has no effect.
|
|
VFX.VFXManager.PrepareCamera(camera);
|
|
#endif
|
|
UpdateVolumeFramework(camera, null);
|
|
|
|
RenderSingleCamera(renderContext, camera);
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.endCameraRendering))
|
|
{
|
|
EndCameraRendering(renderContext, camera);
|
|
}
|
|
}
|
|
}
|
|
#if UNITY_2021_1_OR_NEWER
|
|
using (new ProfilingScope(null, Profiling.Pipeline.endContextRendering))
|
|
{
|
|
EndContextRendering(renderContext, cameras);
|
|
}
|
|
#else
|
|
using (new ProfilingScope(null, Profiling.Pipeline.endFrameRendering))
|
|
{
|
|
EndFrameRendering(renderContext, cameras);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// Standalone camera rendering. Use this to render procedural cameras.
|
|
/// This method doesn't call <c>BeginCameraRendering</c> and <c>EndCameraRendering</c> callbacks.
|
|
/// </summary>
|
|
/// <param name="context">Render context used to record commands during execution.</param>
|
|
/// <param name="camera">Camera to render.</param>
|
|
/// <seealso cref="ScriptableRenderContext"/>
|
|
public static void RenderSingleCamera(ScriptableRenderContext context, Camera camera)
|
|
{
|
|
UniversalAdditionalCameraData additionalCameraData = null;
|
|
if (IsGameCamera(camera))
|
|
camera.gameObject.TryGetComponent(out additionalCameraData);
|
|
|
|
if (additionalCameraData != null && additionalCameraData.renderType != CameraRenderType.Base)
|
|
{
|
|
Debug.LogWarning("Only Base cameras can be rendered with standalone RenderSingleCamera. Camera will be skipped.");
|
|
return;
|
|
}
|
|
|
|
InitializeCameraData(camera, additionalCameraData, true, out var cameraData);
|
|
#if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER
|
|
if (asset.useAdaptivePerformance)
|
|
ApplyAdaptivePerformance(ref cameraData);
|
|
#endif
|
|
RenderSingleCamera(context, cameraData, cameraData.postProcessEnabled);
|
|
}
|
|
|
|
static bool TryGetCullingParameters(CameraData cameraData, out ScriptableCullingParameters cullingParams)
|
|
{
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
if (cameraData.xr.enabled)
|
|
{
|
|
cullingParams = cameraData.xr.cullingParams;
|
|
|
|
// Sync the FOV on the camera to match the projection from the XR device
|
|
if (!cameraData.camera.usePhysicalProperties && !XRGraphicsAutomatedTests.enabled)
|
|
cameraData.camera.fieldOfView = Mathf.Rad2Deg * Mathf.Atan(1.0f / cullingParams.stereoProjectionMatrix.m11) * 2.0f;
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
return cameraData.camera.TryGetCullingParameters(false, out cullingParams);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders a single camera. This method will do culling, setup and execution of the renderer.
|
|
/// </summary>
|
|
/// <param name="context">Render context used to record commands during execution.</param>
|
|
/// <param name="cameraData">Camera rendering data. This might contain data inherited from a base camera.</param>
|
|
/// <param name="anyPostProcessingEnabled">True if at least one camera has post-processing enabled in the stack, false otherwise.</param>
|
|
static void RenderSingleCamera(ScriptableRenderContext context, CameraData cameraData, bool anyPostProcessingEnabled)
|
|
{
|
|
Camera camera = cameraData.camera;
|
|
var renderer = cameraData.renderer;
|
|
if (renderer == null)
|
|
{
|
|
Debug.LogWarning(string.Format("Trying to render {0} with an invalid renderer. Camera rendering will be skipped.", camera.name));
|
|
return;
|
|
}
|
|
|
|
if (!TryGetCullingParameters(cameraData, out var cullingParameters))
|
|
return;
|
|
|
|
ScriptableRenderer.current = renderer;
|
|
bool isSceneViewCamera = cameraData.isSceneViewCamera;
|
|
|
|
// NOTE: Do NOT mix ProfilingScope with named CommandBuffers i.e. CommandBufferPool.Get("name").
|
|
// Currently there's an issue which results in mismatched markers.
|
|
// The named CommandBuffer will close its "profiling scope" on execution.
|
|
// That will orphan ProfilingScope markers as the named CommandBuffer markers are their parents.
|
|
// Resulting in following pattern:
|
|
// exec(cmd.start, scope.start, cmd.end) and exec(cmd.start, scope.end, cmd.end)
|
|
CommandBuffer cmd = CommandBufferPool.Get();
|
|
|
|
// TODO: move skybox code from C++ to URP in order to remove the call to context.Submit() inside DrawSkyboxPass
|
|
// Until then, we can't use nested profiling scopes with XR multipass
|
|
CommandBuffer cmdScope = cameraData.xr.enabled ? null : cmd;
|
|
|
|
ProfilingSampler sampler = Profiling.TryGetOrAddCameraSampler(camera);
|
|
using (new ProfilingScope(cmdScope, sampler)) // Enqueues a "BeginSample" command into the CommandBuffer cmd
|
|
{
|
|
renderer.Clear(cameraData.renderType);
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.Renderer.setupCullingParameters))
|
|
{
|
|
renderer.OnPreCullRenderPasses(in cameraData);
|
|
renderer.SetupCullingParameters(ref cullingParameters, ref cameraData);
|
|
}
|
|
|
|
context.ExecuteCommandBuffer(cmd); // Send all the commands enqueued so far in the CommandBuffer cmd, to the ScriptableRenderContext context
|
|
cmd.Clear();
|
|
|
|
#if UNITY_EDITOR
|
|
// Emit scene view UI
|
|
if (isSceneViewCamera)
|
|
{
|
|
ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
|
|
}
|
|
#endif
|
|
|
|
var cullResults = context.Cull(ref cullingParameters);
|
|
InitializeRenderingData(asset, ref cameraData, ref cullResults, anyPostProcessingEnabled, out var renderingData);
|
|
|
|
#if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER
|
|
if (asset.useAdaptivePerformance)
|
|
ApplyAdaptivePerformance(ref renderingData);
|
|
#endif
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.Renderer.setup))
|
|
{
|
|
renderer.Setup(context, ref renderingData);
|
|
}
|
|
|
|
// Timing scope inside
|
|
renderer.Execute(context, ref renderingData);
|
|
CleanupLightData(ref renderingData.lightData);
|
|
} // When ProfilingSample goes out of scope, an "EndSample" command is enqueued into CommandBuffer cmd
|
|
|
|
cameraData.xr.EndCamera(cmd, cameraData);
|
|
context.ExecuteCommandBuffer(cmd); // Sends to ScriptableRenderContext all the commands enqueued since cmd.Clear, i.e the "EndSample" command
|
|
CommandBufferPool.Release(cmd);
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.Context.submit))
|
|
{
|
|
if (renderer.useRenderPassEnabled && !context.SubmitForRenderPassValidation())
|
|
{
|
|
renderer.useRenderPassEnabled = false;
|
|
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.RenderPassEnabled, false);
|
|
Debug.LogWarning("Rendering command not supported inside a native RenderPass found. Falling back to non-RenderPass rendering path");
|
|
}
|
|
context.Submit(); // Actually execute the commands that we previously sent to the ScriptableRenderContext context
|
|
}
|
|
|
|
ScriptableRenderer.current = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Renders a camera stack. This method calls RenderSingleCamera for each valid camera in the stack.
|
|
/// The last camera resolves the final target to screen.
|
|
/// </summary>
|
|
/// <param name="context">Render context used to record commands during execution.</param>
|
|
/// <param name="camera">Camera to render.</param>
|
|
static void RenderCameraStack(ScriptableRenderContext context, Camera baseCamera)
|
|
{
|
|
using var profScope = new ProfilingScope(null, ProfilingSampler.Get(URPProfileId.RenderCameraStack));
|
|
|
|
baseCamera.TryGetComponent<UniversalAdditionalCameraData>(out var baseCameraAdditionalData);
|
|
|
|
// Overlay cameras will be rendered stacked while rendering base cameras
|
|
if (baseCameraAdditionalData != null && baseCameraAdditionalData.renderType == CameraRenderType.Overlay)
|
|
return;
|
|
|
|
// Renderer contains a stack if it has additional data and the renderer supports stacking
|
|
// The renderer is checked if it supports Base camera. Since Base is the only relevant type at this moment.
|
|
var renderer = baseCameraAdditionalData?.scriptableRenderer;
|
|
bool supportsCameraStacking = renderer != null && renderer.SupportsCameraStackingType(CameraRenderType.Base);
|
|
List<Camera> cameraStack = (supportsCameraStacking) ? baseCameraAdditionalData?.cameraStack : null;
|
|
|
|
bool anyPostProcessingEnabled = baseCameraAdditionalData != null && baseCameraAdditionalData.renderPostProcessing;
|
|
|
|
// We need to know the last active camera in the stack to be able to resolve
|
|
// rendering to screen when rendering it. The last camera in the stack is not
|
|
// necessarily the last active one as it users might disable it.
|
|
int lastActiveOverlayCameraIndex = -1;
|
|
if (cameraStack != null)
|
|
{
|
|
var baseCameraRendererType = baseCameraAdditionalData?.scriptableRenderer.GetType();
|
|
bool shouldUpdateCameraStack = false;
|
|
|
|
for (int i = 0; i < cameraStack.Count; ++i)
|
|
{
|
|
Camera currCamera = cameraStack[i];
|
|
if (currCamera == null)
|
|
{
|
|
shouldUpdateCameraStack = true;
|
|
continue;
|
|
}
|
|
|
|
if (currCamera.isActiveAndEnabled)
|
|
{
|
|
currCamera.TryGetComponent<UniversalAdditionalCameraData>(out var data);
|
|
|
|
// Checking if the base and the overlay camera is of the same renderer type.
|
|
var currCameraRendererType = data?.scriptableRenderer.GetType();
|
|
if (currCameraRendererType != baseCameraRendererType)
|
|
{
|
|
Debug.LogWarning("Only cameras with compatible renderer types can be stacked. " +
|
|
$"The camera: {currCamera.name} are using the renderer {currCameraRendererType.Name}, " +
|
|
$"but the base camera: {baseCamera.name} are using {baseCameraRendererType.Name}. Will skip rendering");
|
|
continue;
|
|
}
|
|
|
|
var overlayRenderer = data.scriptableRenderer;
|
|
// Checking if they are the same renderer type but just not supporting Overlay
|
|
if ((overlayRenderer.SupportedCameraStackingTypes() & 1 << (int)CameraRenderType.Overlay) == 0)
|
|
{
|
|
Debug.LogWarning($"The camera: {currCamera.name} is using a renderer of type {renderer.GetType().Name} which does not support Overlay cameras in it's current state.");
|
|
continue;
|
|
}
|
|
|
|
if (data == null || data.renderType != CameraRenderType.Overlay)
|
|
{
|
|
Debug.LogWarning($"Stack can only contain Overlay cameras. The camera: {currCamera.name} " +
|
|
$"has a type {data.renderType} that is not supported. Will skip rendering.");
|
|
continue;
|
|
}
|
|
|
|
anyPostProcessingEnabled |= data.renderPostProcessing;
|
|
lastActiveOverlayCameraIndex = i;
|
|
}
|
|
}
|
|
if (shouldUpdateCameraStack)
|
|
{
|
|
baseCameraAdditionalData.UpdateCameraStack();
|
|
}
|
|
}
|
|
|
|
// Post-processing not supported in GLES2.
|
|
anyPostProcessingEnabled &= SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
|
|
|
|
bool isStackedRendering = lastActiveOverlayCameraIndex != -1;
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
var xrActive = false;
|
|
var xrRendering = true;
|
|
if (baseCameraAdditionalData != null)
|
|
xrRendering = baseCameraAdditionalData.allowXRRendering;
|
|
var xrPasses = m_XRSystem.SetupFrame(baseCamera, xrRendering);
|
|
foreach (XRPass xrPass in xrPasses)
|
|
{
|
|
if (xrPass.enabled)
|
|
{
|
|
xrActive = true;
|
|
UpdateCameraStereoMatrices(baseCamera, xrPass);
|
|
}
|
|
#endif
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.beginCameraRendering))
|
|
{
|
|
BeginCameraRendering(context, baseCamera);
|
|
}
|
|
// Update volumeframework before initializing additional camera data
|
|
UpdateVolumeFramework(baseCamera, baseCameraAdditionalData);
|
|
InitializeCameraData(baseCamera, baseCameraAdditionalData, !isStackedRendering, out var baseCameraData);
|
|
RenderTextureDescriptor originalTargetDesc = baseCameraData.cameraTargetDescriptor;
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
if (xrPass.enabled)
|
|
{
|
|
baseCameraData.xr = xrPass;
|
|
// XRTODO: remove isStereoEnabled in 2021.x
|
|
#pragma warning disable 0618
|
|
baseCameraData.isStereoEnabled = xrPass.enabled;
|
|
#pragma warning restore 0618
|
|
|
|
// Helper function for updating cameraData with xrPass Data
|
|
m_XRSystem.UpdateCameraData(ref baseCameraData, baseCameraData.xr);
|
|
// Need to update XRSystem using baseCameraData to handle the case where camera position is modified in BeginCameraRendering
|
|
m_XRSystem.UpdateFromCamera(ref baseCameraData.xr, baseCameraData);
|
|
m_XRSystem.BeginLateLatching(baseCamera, xrPass);
|
|
}
|
|
#endif
|
|
|
|
#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
|
|
//It should be called before culling to prepare material. When there isn't any VisualEffect component, this method has no effect.
|
|
VFX.VFXManager.PrepareCamera(baseCamera);
|
|
#endif
|
|
#if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER
|
|
if (asset.useAdaptivePerformance)
|
|
ApplyAdaptivePerformance(ref baseCameraData);
|
|
#endif
|
|
RenderSingleCamera(context, baseCameraData, anyPostProcessingEnabled);
|
|
using (new ProfilingScope(null, Profiling.Pipeline.endCameraRendering))
|
|
{
|
|
EndCameraRendering(context, baseCamera);
|
|
}
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
m_XRSystem.EndLateLatching(baseCamera, xrPass);
|
|
#endif
|
|
|
|
if (isStackedRendering)
|
|
{
|
|
for (int i = 0; i < cameraStack.Count; ++i)
|
|
{
|
|
var currCamera = cameraStack[i];
|
|
if (!currCamera.isActiveAndEnabled)
|
|
continue;
|
|
|
|
currCamera.TryGetComponent<UniversalAdditionalCameraData>(out var currCameraData);
|
|
// Camera is overlay and enabled
|
|
if (currCameraData != null)
|
|
{
|
|
// Copy base settings from base camera data and initialize initialize remaining specific settings for this camera type.
|
|
CameraData overlayCameraData = baseCameraData;
|
|
bool lastCamera = i == lastActiveOverlayCameraIndex;
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
UpdateCameraStereoMatrices(currCameraData.camera, xrPass);
|
|
#endif
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.beginCameraRendering))
|
|
{
|
|
BeginCameraRendering(context, currCamera);
|
|
}
|
|
#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
|
|
//It should be called before culling to prepare material. When there isn't any VisualEffect component, this method has no effect.
|
|
VFX.VFXManager.PrepareCamera(currCamera);
|
|
#endif
|
|
UpdateVolumeFramework(currCamera, currCameraData);
|
|
InitializeAdditionalCameraData(currCamera, currCameraData, lastCamera, ref overlayCameraData);
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
if (baseCameraData.xr.enabled)
|
|
m_XRSystem.UpdateFromCamera(ref overlayCameraData.xr, overlayCameraData);
|
|
#endif
|
|
RenderSingleCamera(context, overlayCameraData, anyPostProcessingEnabled);
|
|
|
|
using (new ProfilingScope(null, Profiling.Pipeline.endCameraRendering))
|
|
{
|
|
EndCameraRendering(context, currCamera);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
if (baseCameraData.xr.enabled)
|
|
baseCameraData.cameraTargetDescriptor = originalTargetDesc;
|
|
}
|
|
|
|
if (xrActive)
|
|
{
|
|
CommandBuffer cmd = CommandBufferPool.Get();
|
|
using (new ProfilingScope(cmd, Profiling.Pipeline.XR.mirrorView))
|
|
{
|
|
m_XRSystem.RenderMirrorView(cmd, baseCamera);
|
|
}
|
|
|
|
context.ExecuteCommandBuffer(cmd);
|
|
context.Submit();
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
|
|
m_XRSystem.ReleaseFrame();
|
|
#endif
|
|
}
|
|
|
|
static void UpdateVolumeFramework(Camera camera, UniversalAdditionalCameraData additionalCameraData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, ProfilingSampler.Get(URPProfileId.UpdateVolumeFramework));
|
|
|
|
// We update the volume framework for:
|
|
// * All cameras in the editor when not in playmode
|
|
// * scene cameras
|
|
// * cameras with update mode set to EveryFrame
|
|
// * cameras with update mode set to UsePipelineSettings and the URP Asset set to EveryFrame
|
|
bool shouldUpdate = camera.cameraType == CameraType.SceneView;
|
|
shouldUpdate |= additionalCameraData != null && additionalCameraData.requiresVolumeFrameworkUpdate;
|
|
|
|
#if UNITY_EDITOR
|
|
shouldUpdate |= Application.isPlaying == false;
|
|
#endif
|
|
|
|
// When we have volume updates per-frame disabled...
|
|
if (!shouldUpdate && additionalCameraData)
|
|
{
|
|
// Create a local volume stack and cache the state if it's null
|
|
if (additionalCameraData.volumeStack == null)
|
|
{
|
|
camera.UpdateVolumeStack(additionalCameraData);
|
|
}
|
|
|
|
VolumeManager.instance.stack = additionalCameraData.volumeStack;
|
|
return;
|
|
}
|
|
|
|
// When we want to update the volumes every frame...
|
|
|
|
// We destroy the volumeStack in the additional camera data, if present, to make sure
|
|
// it gets recreated and initialized if the update mode gets later changed to ViaScripting...
|
|
if (additionalCameraData && additionalCameraData.volumeStack != null)
|
|
{
|
|
camera.DestroyVolumeStack(additionalCameraData);
|
|
}
|
|
|
|
// Get the mask + trigger and update the stack
|
|
camera.GetVolumeLayerMaskAndTrigger(additionalCameraData, out LayerMask layerMask, out Transform trigger);
|
|
VolumeManager.instance.ResetMainStack();
|
|
VolumeManager.instance.Update(trigger, layerMask);
|
|
}
|
|
|
|
static bool CheckPostProcessForDepth(in CameraData cameraData)
|
|
{
|
|
if (!cameraData.postProcessEnabled)
|
|
return false;
|
|
|
|
if (cameraData.antialiasing == AntialiasingMode.SubpixelMorphologicalAntiAliasing)
|
|
return true;
|
|
|
|
var stack = VolumeManager.instance.stack;
|
|
|
|
if (stack.GetComponent<DepthOfField>().IsActive())
|
|
return true;
|
|
|
|
if (stack.GetComponent<MotionBlur>().IsActive())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
static void SetSupportedRenderingFeatures()
|
|
{
|
|
#if UNITY_EDITOR
|
|
SupportedRenderingFeatures.active = new SupportedRenderingFeatures()
|
|
{
|
|
reflectionProbeModes = SupportedRenderingFeatures.ReflectionProbeModes.None,
|
|
defaultMixedLightingModes = SupportedRenderingFeatures.LightmapMixedBakeModes.Subtractive,
|
|
mixedLightingModes = SupportedRenderingFeatures.LightmapMixedBakeModes.Subtractive | SupportedRenderingFeatures.LightmapMixedBakeModes.IndirectOnly | SupportedRenderingFeatures.LightmapMixedBakeModes.Shadowmask,
|
|
lightmapBakeTypes = LightmapBakeType.Baked | LightmapBakeType.Mixed | LightmapBakeType.Realtime,
|
|
lightmapsModes = LightmapsMode.CombinedDirectional | LightmapsMode.NonDirectional,
|
|
lightProbeProxyVolumes = false,
|
|
motionVectors = false,
|
|
receiveShadows = false,
|
|
reflectionProbes = false,
|
|
reflectionProbesBlendDistance = true,
|
|
particleSystemInstancing = true
|
|
};
|
|
SceneViewDrawMode.SetupDrawMode();
|
|
#endif
|
|
}
|
|
|
|
static void InitializeCameraData(Camera camera, UniversalAdditionalCameraData additionalCameraData, bool resolveFinalTarget, out CameraData cameraData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeCameraData);
|
|
|
|
cameraData = new CameraData();
|
|
InitializeStackedCameraData(camera, additionalCameraData, ref cameraData);
|
|
InitializeAdditionalCameraData(camera, additionalCameraData, resolveFinalTarget, ref cameraData);
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Descriptor settings /
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
var renderer = additionalCameraData?.scriptableRenderer;
|
|
bool rendererSupportsMSAA = renderer != null && renderer.supportedRenderingFeatures.msaa;
|
|
|
|
int msaaSamples = 1;
|
|
if (camera.allowMSAA && asset.msaaSampleCount > 1 && rendererSupportsMSAA)
|
|
msaaSamples = (camera.targetTexture != null) ? camera.targetTexture.antiAliasing : asset.msaaSampleCount;
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
// Use XR's MSAA if camera is XR camera. XR MSAA needs special handle here because it is not per Camera.
|
|
// Multiple cameras could render into the same XR display and they should share the same MSAA level.
|
|
if (cameraData.xrRendering && rendererSupportsMSAA)
|
|
msaaSamples = XRSystem.GetMSAALevel();
|
|
#endif
|
|
|
|
bool needsAlphaChannel = Graphics.preserveFramebufferAlpha;
|
|
cameraData.cameraTargetDescriptor = CreateRenderTextureDescriptor(camera, cameraData.renderScale,
|
|
cameraData.isHdrEnabled, msaaSamples, needsAlphaChannel, cameraData.requiresOpaqueTexture);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize camera data settings common for all cameras in the stack. Overlay cameras will inherit
|
|
/// settings from base camera.
|
|
/// </summary>
|
|
/// <param name="baseCamera">Base camera to inherit settings from.</param>
|
|
/// <param name="baseAdditionalCameraData">Component that contains additional base camera data.</param>
|
|
/// <param name="cameraData">Camera data to initialize setttings.</param>
|
|
static void InitializeStackedCameraData(Camera baseCamera, UniversalAdditionalCameraData baseAdditionalCameraData, ref CameraData cameraData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeStackedCameraData);
|
|
|
|
var settings = asset;
|
|
cameraData.targetTexture = baseCamera.targetTexture;
|
|
cameraData.cameraType = baseCamera.cameraType;
|
|
bool isSceneViewCamera = cameraData.isSceneViewCamera;
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Environment and Post-processing settings /
|
|
///////////////////////////////////////////////////////////////////
|
|
if (isSceneViewCamera)
|
|
{
|
|
cameraData.volumeLayerMask = 1; // "Default"
|
|
cameraData.volumeTrigger = null;
|
|
cameraData.isStopNaNEnabled = false;
|
|
cameraData.isDitheringEnabled = false;
|
|
cameraData.antialiasing = AntialiasingMode.None;
|
|
cameraData.antialiasingQuality = AntialiasingQuality.High;
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
cameraData.xrRendering = false;
|
|
#endif
|
|
}
|
|
else if (baseAdditionalCameraData != null)
|
|
{
|
|
cameraData.volumeLayerMask = baseAdditionalCameraData.volumeLayerMask;
|
|
cameraData.volumeTrigger = baseAdditionalCameraData.volumeTrigger == null ? baseCamera.transform : baseAdditionalCameraData.volumeTrigger;
|
|
cameraData.isStopNaNEnabled = baseAdditionalCameraData.stopNaN && SystemInfo.graphicsShaderLevel >= 35;
|
|
cameraData.isDitheringEnabled = baseAdditionalCameraData.dithering;
|
|
cameraData.antialiasing = baseAdditionalCameraData.antialiasing;
|
|
cameraData.antialiasingQuality = baseAdditionalCameraData.antialiasingQuality;
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
cameraData.xrRendering = baseAdditionalCameraData.allowXRRendering && m_XRSystem.RefreshXrSdk();
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
cameraData.volumeLayerMask = 1; // "Default"
|
|
cameraData.volumeTrigger = null;
|
|
cameraData.isStopNaNEnabled = false;
|
|
cameraData.isDitheringEnabled = false;
|
|
cameraData.antialiasing = AntialiasingMode.None;
|
|
cameraData.antialiasingQuality = AntialiasingQuality.High;
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
cameraData.xrRendering = m_XRSystem.RefreshXrSdk();
|
|
#endif
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Settings that control output of the camera /
|
|
///////////////////////////////////////////////////////////////////
|
|
|
|
cameraData.isHdrEnabled = baseCamera.allowHDR && settings.supportsHDR;
|
|
|
|
Rect cameraRect = baseCamera.rect;
|
|
cameraData.pixelRect = baseCamera.pixelRect;
|
|
cameraData.pixelWidth = baseCamera.pixelWidth;
|
|
cameraData.pixelHeight = baseCamera.pixelHeight;
|
|
cameraData.aspectRatio = (float)cameraData.pixelWidth / (float)cameraData.pixelHeight;
|
|
cameraData.isDefaultViewport = (!(Math.Abs(cameraRect.x) > 0.0f || Math.Abs(cameraRect.y) > 0.0f ||
|
|
Math.Abs(cameraRect.width) < 1.0f || Math.Abs(cameraRect.height) < 1.0f));
|
|
|
|
// Discard variations lesser than kRenderScaleThreshold.
|
|
// Scale is only enabled for gameview.
|
|
const float kRenderScaleThreshold = 0.05f;
|
|
cameraData.renderScale = (Mathf.Abs(1.0f - settings.renderScale) < kRenderScaleThreshold) ? 1.0f : settings.renderScale;
|
|
|
|
// Convert the upscaling filter selection from the pipeline asset into an image upscaling filter
|
|
cameraData.upscalingFilter = ResolveUpscalingFilterSelection(new Vector2(cameraData.pixelWidth, cameraData.pixelHeight), cameraData.renderScale, settings.upscalingFilter);
|
|
|
|
if (cameraData.renderScale > 1.0f)
|
|
{
|
|
cameraData.imageScalingMode = ImageScalingMode.Downscaling;
|
|
}
|
|
else if ((cameraData.renderScale < 1.0f) || (cameraData.upscalingFilter == ImageUpscalingFilter.FSR))
|
|
{
|
|
// When FSR is enabled, we still consider 100% render scale an upscaling operation.
|
|
// This allows us to run the FSR shader passes all the time since they improve visual quality even at 100% scale.
|
|
|
|
cameraData.imageScalingMode = ImageScalingMode.Upscaling;
|
|
}
|
|
else
|
|
{
|
|
cameraData.imageScalingMode = ImageScalingMode.None;
|
|
}
|
|
|
|
cameraData.fsrOverrideSharpness = settings.fsrOverrideSharpness;
|
|
cameraData.fsrSharpness = settings.fsrSharpness;
|
|
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
cameraData.xr = m_XRSystem.emptyPass;
|
|
XRSystem.UpdateRenderScale(cameraData.renderScale);
|
|
#else
|
|
cameraData.xr = XRPass.emptyPass;
|
|
#endif
|
|
|
|
var commonOpaqueFlags = SortingCriteria.CommonOpaque;
|
|
var noFrontToBackOpaqueFlags = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges | SortingCriteria.CanvasOrder;
|
|
bool hasHSRGPU = SystemInfo.hasHiddenSurfaceRemovalOnGPU;
|
|
bool canSkipFrontToBackSorting = (baseCamera.opaqueSortMode == OpaqueSortMode.Default && hasHSRGPU) || baseCamera.opaqueSortMode == OpaqueSortMode.NoDistanceSort;
|
|
|
|
cameraData.defaultOpaqueSortFlags = canSkipFrontToBackSorting ? noFrontToBackOpaqueFlags : commonOpaqueFlags;
|
|
cameraData.captureActions = CameraCaptureBridge.GetCaptureActions(baseCamera);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize settings that can be different for each camera in the stack.
|
|
/// </summary>
|
|
/// <param name="camera">Camera to initialize settings from.</param>
|
|
/// <param name="additionalCameraData">Additional camera data component to initialize settings from.</param>
|
|
/// <param name="resolveFinalTarget">True if this is the last camera in the stack and rendering should resolve to camera target.</param>
|
|
/// <param name="cameraData">Settings to be initilized.</param>
|
|
static void InitializeAdditionalCameraData(Camera camera, UniversalAdditionalCameraData additionalCameraData, bool resolveFinalTarget, ref CameraData cameraData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeAdditionalCameraData);
|
|
|
|
var settings = asset;
|
|
cameraData.camera = camera;
|
|
|
|
bool anyShadowsEnabled = settings.supportsMainLightShadows || settings.supportsAdditionalLightShadows;
|
|
cameraData.maxShadowDistance = Mathf.Min(settings.shadowDistance, camera.farClipPlane);
|
|
cameraData.maxShadowDistance = (anyShadowsEnabled && cameraData.maxShadowDistance >= camera.nearClipPlane) ? cameraData.maxShadowDistance : 0.0f;
|
|
|
|
// Getting the background color from preferences to add to the preview camera
|
|
#if UNITY_EDITOR
|
|
if (cameraData.camera.cameraType == CameraType.Preview)
|
|
{
|
|
camera.backgroundColor = CoreRenderPipelinePreferences.previewBackgroundColor;
|
|
}
|
|
#endif
|
|
|
|
bool isSceneViewCamera = cameraData.isSceneViewCamera;
|
|
if (isSceneViewCamera)
|
|
{
|
|
cameraData.renderType = CameraRenderType.Base;
|
|
cameraData.clearDepth = true;
|
|
cameraData.postProcessEnabled = CoreUtils.ArePostProcessesEnabled(camera);
|
|
cameraData.requiresDepthTexture = settings.supportsCameraDepthTexture;
|
|
cameraData.requiresOpaqueTexture = settings.supportsCameraOpaqueTexture;
|
|
cameraData.renderer = asset.scriptableRenderer;
|
|
}
|
|
else if (additionalCameraData != null)
|
|
{
|
|
cameraData.renderType = additionalCameraData.renderType;
|
|
cameraData.clearDepth = (additionalCameraData.renderType != CameraRenderType.Base) ? additionalCameraData.clearDepth : true;
|
|
cameraData.postProcessEnabled = additionalCameraData.renderPostProcessing;
|
|
cameraData.maxShadowDistance = (additionalCameraData.renderShadows) ? cameraData.maxShadowDistance : 0.0f;
|
|
cameraData.requiresDepthTexture = additionalCameraData.requiresDepthTexture;
|
|
cameraData.requiresOpaqueTexture = additionalCameraData.requiresColorTexture;
|
|
cameraData.renderer = additionalCameraData.scriptableRenderer;
|
|
}
|
|
else
|
|
{
|
|
cameraData.renderType = CameraRenderType.Base;
|
|
cameraData.clearDepth = true;
|
|
cameraData.postProcessEnabled = false;
|
|
cameraData.requiresDepthTexture = settings.supportsCameraDepthTexture;
|
|
cameraData.requiresOpaqueTexture = settings.supportsCameraOpaqueTexture;
|
|
cameraData.renderer = asset.scriptableRenderer;
|
|
}
|
|
|
|
// Disables post if GLes2
|
|
cameraData.postProcessEnabled &= SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
|
|
|
|
cameraData.requiresDepthTexture |= isSceneViewCamera;
|
|
cameraData.postProcessingRequiresDepthTexture |= CheckPostProcessForDepth(cameraData);
|
|
cameraData.resolveFinalTarget = resolveFinalTarget;
|
|
|
|
// Disable depth and color copy. We should add it in the renderer instead to avoid performance pitfalls
|
|
// of camera stacking breaking render pass execution implicitly.
|
|
bool isOverlayCamera = (cameraData.renderType == CameraRenderType.Overlay);
|
|
if (isOverlayCamera)
|
|
{
|
|
cameraData.requiresDepthTexture = false;
|
|
cameraData.requiresOpaqueTexture = false;
|
|
cameraData.postProcessingRequiresDepthTexture = false;
|
|
}
|
|
|
|
Matrix4x4 projectionMatrix = camera.projectionMatrix;
|
|
|
|
// Overlay cameras inherit viewport from base.
|
|
// If the viewport is different between them we might need to patch the projection to adjust aspect ratio
|
|
// matrix to prevent squishing when rendering objects in overlay cameras.
|
|
if (isOverlayCamera && !camera.orthographic && cameraData.pixelRect != camera.pixelRect)
|
|
{
|
|
// m00 = (cotangent / aspect), therefore m00 * aspect gives us cotangent.
|
|
float cotangent = camera.projectionMatrix.m00 * camera.aspect;
|
|
|
|
// Get new m00 by dividing by base camera aspectRatio.
|
|
float newCotangent = cotangent / cameraData.aspectRatio;
|
|
projectionMatrix.m00 = newCotangent;
|
|
}
|
|
|
|
cameraData.SetViewAndProjectionMatrix(camera.worldToCameraMatrix, projectionMatrix);
|
|
|
|
cameraData.worldSpaceCameraPos = camera.transform.position;
|
|
}
|
|
|
|
static void InitializeRenderingData(UniversalRenderPipelineAsset settings, ref CameraData cameraData, ref CullingResults cullResults,
|
|
bool anyPostProcessingEnabled, out RenderingData renderingData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeRenderingData);
|
|
|
|
var visibleLights = cullResults.visibleLights;
|
|
|
|
int mainLightIndex = GetMainLightIndex(settings, visibleLights);
|
|
bool mainLightCastShadows = false;
|
|
bool additionalLightsCastShadows = false;
|
|
|
|
if (cameraData.maxShadowDistance > 0.0f)
|
|
{
|
|
mainLightCastShadows = (mainLightIndex != -1 && visibleLights[mainLightIndex].light != null &&
|
|
visibleLights[mainLightIndex].light.shadows != LightShadows.None);
|
|
|
|
// If additional lights are shaded per-pixel they cannot cast shadows
|
|
if (settings.additionalLightsRenderingMode == LightRenderingMode.PerPixel)
|
|
{
|
|
for (int i = 0; i < visibleLights.Length; ++i)
|
|
{
|
|
if (i == mainLightIndex)
|
|
continue;
|
|
|
|
Light light = visibleLights[i].light;
|
|
|
|
// UniversalRP doesn't support additional directional light shadows yet
|
|
if ((visibleLights[i].lightType == LightType.Spot || visibleLights[i].lightType == LightType.Point) && light != null && light.shadows != LightShadows.None)
|
|
{
|
|
additionalLightsCastShadows = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
renderingData.cullResults = cullResults;
|
|
renderingData.cameraData = cameraData;
|
|
InitializeLightData(settings, visibleLights, mainLightIndex, out renderingData.lightData);
|
|
InitializeShadowData(settings, visibleLights, mainLightCastShadows, additionalLightsCastShadows && !renderingData.lightData.shadeAdditionalLightsPerVertex, out renderingData.shadowData);
|
|
InitializePostProcessingData(settings, out renderingData.postProcessingData);
|
|
renderingData.supportsDynamicBatching = settings.supportsDynamicBatching;
|
|
renderingData.perObjectData = GetPerObjectLightFlags(renderingData.lightData.additionalLightsCount);
|
|
renderingData.postProcessingEnabled = anyPostProcessingEnabled;
|
|
|
|
CheckAndApplyDebugSettings(ref renderingData);
|
|
}
|
|
|
|
static void InitializeShadowData(UniversalRenderPipelineAsset settings, NativeArray<VisibleLight> visibleLights, bool mainLightCastShadows, bool additionalLightsCastShadows, out ShadowData shadowData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeShadowData);
|
|
|
|
m_ShadowBiasData.Clear();
|
|
m_ShadowResolutionData.Clear();
|
|
|
|
for (int i = 0; i < visibleLights.Length; ++i)
|
|
{
|
|
Light light = visibleLights[i].light;
|
|
UniversalAdditionalLightData data = null;
|
|
if (light != null)
|
|
{
|
|
light.gameObject.TryGetComponent(out data);
|
|
}
|
|
|
|
if (data && !data.usePipelineSettings)
|
|
m_ShadowBiasData.Add(new Vector4(light.shadowBias, light.shadowNormalBias, 0.0f, 0.0f));
|
|
else
|
|
m_ShadowBiasData.Add(new Vector4(settings.shadowDepthBias, settings.shadowNormalBias, 0.0f, 0.0f));
|
|
|
|
if (data && (data.additionalLightsShadowResolutionTier == UniversalAdditionalLightData.AdditionalLightsShadowResolutionTierCustom))
|
|
{
|
|
m_ShadowResolutionData.Add((int)light.shadowResolution); // native code does not clamp light.shadowResolution between -1 and 3
|
|
}
|
|
else if (data && (data.additionalLightsShadowResolutionTier != UniversalAdditionalLightData.AdditionalLightsShadowResolutionTierCustom))
|
|
{
|
|
int resolutionTier = Mathf.Clamp(data.additionalLightsShadowResolutionTier, UniversalAdditionalLightData.AdditionalLightsShadowResolutionTierLow, UniversalAdditionalLightData.AdditionalLightsShadowResolutionTierHigh);
|
|
m_ShadowResolutionData.Add(settings.GetAdditionalLightsShadowResolution(resolutionTier));
|
|
}
|
|
else
|
|
{
|
|
m_ShadowResolutionData.Add(settings.GetAdditionalLightsShadowResolution(UniversalAdditionalLightData.AdditionalLightsShadowDefaultResolutionTier));
|
|
}
|
|
}
|
|
|
|
shadowData.bias = m_ShadowBiasData;
|
|
shadowData.resolution = m_ShadowResolutionData;
|
|
shadowData.supportsMainLightShadows = SystemInfo.supportsShadows && settings.supportsMainLightShadows && mainLightCastShadows;
|
|
|
|
// We no longer use screen space shadows in URP.
|
|
// This change allows us to have particles & transparent objects receive shadows.
|
|
#pragma warning disable 0618
|
|
shadowData.requiresScreenSpaceShadowResolve = false;
|
|
#pragma warning restore 0618
|
|
|
|
shadowData.mainLightShadowCascadesCount = settings.shadowCascadeCount;
|
|
shadowData.mainLightShadowmapWidth = settings.mainLightShadowmapResolution;
|
|
shadowData.mainLightShadowmapHeight = settings.mainLightShadowmapResolution;
|
|
|
|
switch (shadowData.mainLightShadowCascadesCount)
|
|
{
|
|
case 1:
|
|
shadowData.mainLightShadowCascadesSplit = new Vector3(1.0f, 0.0f, 0.0f);
|
|
break;
|
|
|
|
case 2:
|
|
shadowData.mainLightShadowCascadesSplit = new Vector3(settings.cascade2Split, 1.0f, 0.0f);
|
|
break;
|
|
|
|
case 3:
|
|
shadowData.mainLightShadowCascadesSplit = new Vector3(settings.cascade3Split.x, settings.cascade3Split.y, 0.0f);
|
|
break;
|
|
|
|
default:
|
|
shadowData.mainLightShadowCascadesSplit = settings.cascade4Split;
|
|
break;
|
|
}
|
|
|
|
shadowData.mainLightShadowCascadeBorder = settings.cascadeBorder;
|
|
|
|
shadowData.supportsAdditionalLightShadows = SystemInfo.supportsShadows && settings.supportsAdditionalLightShadows && additionalLightsCastShadows;
|
|
shadowData.additionalLightsShadowmapWidth = shadowData.additionalLightsShadowmapHeight = settings.additionalLightsShadowmapResolution;
|
|
shadowData.supportsSoftShadows = settings.supportsSoftShadows && (shadowData.supportsMainLightShadows || shadowData.supportsAdditionalLightShadows);
|
|
shadowData.shadowmapDepthBufferBits = 16;
|
|
|
|
// This will be setup in AdditionalLightsShadowCasterPass.
|
|
shadowData.isKeywordAdditionalLightShadowsEnabled = false;
|
|
shadowData.isKeywordSoftShadowsEnabled = false;
|
|
}
|
|
|
|
static void InitializePostProcessingData(UniversalRenderPipelineAsset settings, out PostProcessingData postProcessingData)
|
|
{
|
|
postProcessingData.gradingMode = settings.supportsHDR
|
|
? settings.colorGradingMode
|
|
: ColorGradingMode.LowDynamicRange;
|
|
|
|
postProcessingData.lutSize = settings.colorGradingLutSize;
|
|
postProcessingData.useFastSRGBLinearConversion = settings.useFastSRGBLinearConversion;
|
|
}
|
|
|
|
static void InitializeLightData(UniversalRenderPipelineAsset settings, NativeArray<VisibleLight> visibleLights, int mainLightIndex, out LightData lightData)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.initializeLightData);
|
|
|
|
int maxPerObjectAdditionalLights = UniversalRenderPipeline.maxPerObjectLights;
|
|
int maxVisibleAdditionalLights = UniversalRenderPipeline.maxVisibleAdditionalLights;
|
|
|
|
lightData.mainLightIndex = mainLightIndex;
|
|
|
|
if (settings.additionalLightsRenderingMode != LightRenderingMode.Disabled)
|
|
{
|
|
lightData.additionalLightsCount =
|
|
Math.Min((mainLightIndex != -1) ? visibleLights.Length - 1 : visibleLights.Length,
|
|
maxVisibleAdditionalLights);
|
|
lightData.maxPerObjectAdditionalLightsCount = Math.Min(settings.maxAdditionalLightsCount, maxPerObjectAdditionalLights);
|
|
}
|
|
else
|
|
{
|
|
lightData.additionalLightsCount = 0;
|
|
lightData.maxPerObjectAdditionalLightsCount = 0;
|
|
}
|
|
|
|
lightData.supportsAdditionalLights = settings.additionalLightsRenderingMode != LightRenderingMode.Disabled;
|
|
lightData.shadeAdditionalLightsPerVertex = settings.additionalLightsRenderingMode == LightRenderingMode.PerVertex;
|
|
lightData.visibleLights = visibleLights;
|
|
lightData.supportsMixedLighting = settings.supportsMixedLighting;
|
|
lightData.reflectionProbeBlending = settings.reflectionProbeBlending;
|
|
lightData.reflectionProbeBoxProjection = settings.reflectionProbeBoxProjection;
|
|
lightData.supportsLightLayers = RenderingUtils.SupportsLightLayers(SystemInfo.graphicsDeviceType) && settings.supportsLightLayers;
|
|
lightData.originalIndices = new NativeArray<int>(visibleLights.Length, Allocator.Temp);
|
|
for (var i = 0; i < lightData.originalIndices.Length; i++)
|
|
{
|
|
lightData.originalIndices[i] = i;
|
|
}
|
|
}
|
|
|
|
static void CleanupLightData(ref LightData lightData)
|
|
{
|
|
lightData.originalIndices.Dispose();
|
|
}
|
|
|
|
static void UpdateCameraStereoMatrices(Camera camera, XRPass xr)
|
|
{
|
|
#if ENABLE_VR && ENABLE_XR_MODULE
|
|
if (xr.enabled)
|
|
{
|
|
if (xr.singlePassEnabled)
|
|
{
|
|
for (int i = 0; i < Mathf.Min(2, xr.viewCount); i++)
|
|
{
|
|
camera.SetStereoProjectionMatrix((Camera.StereoscopicEye)i, xr.GetProjMatrix(i));
|
|
camera.SetStereoViewMatrix((Camera.StereoscopicEye)i, xr.GetViewMatrix(i));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
camera.SetStereoProjectionMatrix((Camera.StereoscopicEye)xr.multipassId, xr.GetProjMatrix(0));
|
|
camera.SetStereoViewMatrix((Camera.StereoscopicEye)xr.multipassId, xr.GetViewMatrix(0));
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static PerObjectData GetPerObjectLightFlags(int additionalLightsCount)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.getPerObjectLightFlags);
|
|
|
|
var configuration = PerObjectData.ReflectionProbes | PerObjectData.Lightmaps | PerObjectData.LightProbe | PerObjectData.LightData | PerObjectData.OcclusionProbe | PerObjectData.ShadowMask;
|
|
|
|
if (additionalLightsCount > 0)
|
|
{
|
|
configuration |= PerObjectData.LightData;
|
|
|
|
// In this case we also need per-object indices (unity_LightIndices)
|
|
if (!RenderingUtils.useStructuredBuffer)
|
|
configuration |= PerObjectData.LightIndices;
|
|
}
|
|
|
|
return configuration;
|
|
}
|
|
|
|
// Main Light is always a directional light
|
|
static int GetMainLightIndex(UniversalRenderPipelineAsset settings, NativeArray<VisibleLight> visibleLights)
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.getMainLightIndex);
|
|
|
|
int totalVisibleLights = visibleLights.Length;
|
|
|
|
if (totalVisibleLights == 0 || settings.mainLightRenderingMode != LightRenderingMode.PerPixel)
|
|
return -1;
|
|
|
|
Light sunLight = RenderSettings.sun;
|
|
int brightestDirectionalLightIndex = -1;
|
|
float brightestLightIntensity = 0.0f;
|
|
for (int i = 0; i < totalVisibleLights; ++i)
|
|
{
|
|
VisibleLight currVisibleLight = visibleLights[i];
|
|
Light currLight = currVisibleLight.light;
|
|
|
|
// Particle system lights have the light property as null. We sort lights so all particles lights
|
|
// come last. Therefore, if first light is particle light then all lights are particle lights.
|
|
// In this case we either have no main light or already found it.
|
|
if (currLight == null)
|
|
break;
|
|
|
|
if (currVisibleLight.lightType == LightType.Directional)
|
|
{
|
|
// Sun source needs be a directional light
|
|
if (currLight == sunLight)
|
|
return i;
|
|
|
|
// In case no sun light is present we will return the brightest directional light
|
|
if (currLight.intensity > brightestLightIntensity)
|
|
{
|
|
brightestLightIntensity = currLight.intensity;
|
|
brightestDirectionalLightIndex = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return brightestDirectionalLightIndex;
|
|
}
|
|
|
|
static void SetupPerFrameShaderConstants()
|
|
{
|
|
using var profScope = new ProfilingScope(null, Profiling.Pipeline.setupPerFrameShaderConstants);
|
|
|
|
// When glossy reflections are OFF in the shader we set a constant color to use as indirect specular
|
|
SphericalHarmonicsL2 ambientSH = RenderSettings.ambientProbe;
|
|
Color linearGlossyEnvColor = new Color(ambientSH[0, 0], ambientSH[1, 0], ambientSH[2, 0]) * RenderSettings.reflectionIntensity;
|
|
Color glossyEnvColor = CoreUtils.ConvertLinearToActiveColorSpace(linearGlossyEnvColor);
|
|
Shader.SetGlobalVector(ShaderPropertyId.glossyEnvironmentColor, glossyEnvColor);
|
|
|
|
// Used as fallback cubemap for reflections
|
|
Shader.SetGlobalVector(ShaderPropertyId.glossyEnvironmentCubeMapHDR, ReflectionProbe.defaultTextureHDRDecodeValues);
|
|
Shader.SetGlobalTexture(ShaderPropertyId.glossyEnvironmentCubeMap, ReflectionProbe.defaultTexture);
|
|
|
|
// Ambient
|
|
Shader.SetGlobalVector(ShaderPropertyId.ambientSkyColor, CoreUtils.ConvertSRGBToActiveColorSpace(RenderSettings.ambientSkyColor));
|
|
Shader.SetGlobalVector(ShaderPropertyId.ambientEquatorColor, CoreUtils.ConvertSRGBToActiveColorSpace(RenderSettings.ambientEquatorColor));
|
|
Shader.SetGlobalVector(ShaderPropertyId.ambientGroundColor, CoreUtils.ConvertSRGBToActiveColorSpace(RenderSettings.ambientGroundColor));
|
|
|
|
// Used when subtractive mode is selected
|
|
Shader.SetGlobalVector(ShaderPropertyId.subtractiveShadowColor, CoreUtils.ConvertSRGBToActiveColorSpace(RenderSettings.subtractiveShadowColor));
|
|
|
|
// Required for 2D Unlit Shadergraph master node as it doesn't currently support hidden properties.
|
|
Shader.SetGlobalColor(ShaderPropertyId.rendererColor, Color.white);
|
|
}
|
|
|
|
static void CheckAndApplyDebugSettings(ref RenderingData renderingData)
|
|
{
|
|
DebugDisplaySettings debugDisplaySettings = DebugDisplaySettings.Instance;
|
|
ref CameraData cameraData = ref renderingData.cameraData;
|
|
|
|
if (debugDisplaySettings.AreAnySettingsActive && !cameraData.isPreviewCamera)
|
|
{
|
|
DebugDisplaySettingsRendering renderingSettings = debugDisplaySettings.RenderingSettings;
|
|
int msaaSamples = cameraData.cameraTargetDescriptor.msaaSamples;
|
|
|
|
if (!renderingSettings.enableMsaa)
|
|
msaaSamples = 1;
|
|
|
|
if (!renderingSettings.enableHDR)
|
|
cameraData.isHdrEnabled = false;
|
|
|
|
if (!debugDisplaySettings.IsPostProcessingAllowed)
|
|
cameraData.postProcessEnabled = false;
|
|
|
|
cameraData.cameraTargetDescriptor.graphicsFormat = MakeRenderTextureGraphicsFormat(cameraData.isHdrEnabled, true);
|
|
cameraData.cameraTargetDescriptor.msaaSamples = msaaSamples;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the best supported image upscaling filter based on the provided upscaling filter selection
|
|
/// </summary>
|
|
/// <param name="imageSize">Size of the final image</param>
|
|
/// <param name="renderScale">Scale being applied to the final image size</param>
|
|
/// <param name="selection">Upscaling filter selected by the user</param>
|
|
/// <returns>Either the original filter provided, or the best replacement available</returns>
|
|
static ImageUpscalingFilter ResolveUpscalingFilterSelection(Vector2 imageSize, float renderScale, UpscalingFilterSelection selection)
|
|
{
|
|
// By default we just use linear filtering since it's the most compatible choice
|
|
ImageUpscalingFilter filter = ImageUpscalingFilter.Linear;
|
|
|
|
// Fall back to the automatic filter if FSR was selected, but isn't supported on the current platform
|
|
if ((selection == UpscalingFilterSelection.FSR) && !FSRUtils.IsSupported())
|
|
{
|
|
selection = UpscalingFilterSelection.Auto;
|
|
}
|
|
|
|
switch (selection)
|
|
{
|
|
case UpscalingFilterSelection.Auto:
|
|
{
|
|
// The user selected "auto" for their upscaling filter so we should attempt to choose the best filter
|
|
// for the current situation. When the current resolution and render scale are compatible with integer
|
|
// scaling we use the point sampling filter. Otherwise we just use the default filter (linear).
|
|
float pixelScale = (1.0f / renderScale);
|
|
bool isIntegerScale = Mathf.Approximately((pixelScale - Mathf.Floor(pixelScale)), 0.0f);
|
|
|
|
if (isIntegerScale)
|
|
{
|
|
float widthScale = (imageSize.x / pixelScale);
|
|
float heightScale = (imageSize.y / pixelScale);
|
|
|
|
bool isImageCompatible = (Mathf.Approximately((widthScale - Mathf.Floor(widthScale)), 0.0f) &&
|
|
Mathf.Approximately((heightScale - Mathf.Floor(heightScale)), 0.0f));
|
|
|
|
if (isImageCompatible)
|
|
{
|
|
filter = ImageUpscalingFilter.Point;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case UpscalingFilterSelection.Linear:
|
|
{
|
|
// Do nothing since linear is already the default
|
|
|
|
break;
|
|
}
|
|
|
|
case UpscalingFilterSelection.Point:
|
|
{
|
|
filter = ImageUpscalingFilter.Point;
|
|
|
|
break;
|
|
}
|
|
|
|
case UpscalingFilterSelection.FSR:
|
|
{
|
|
filter = ImageUpscalingFilter.FSR;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return filter;
|
|
}
|
|
|
|
#if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER
|
|
static void ApplyAdaptivePerformance(ref CameraData cameraData)
|
|
{
|
|
var noFrontToBackOpaqueFlags = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges | SortingCriteria.CanvasOrder;
|
|
if (AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipFrontToBackSorting)
|
|
cameraData.defaultOpaqueSortFlags = noFrontToBackOpaqueFlags;
|
|
|
|
var MaxShadowDistanceMultiplier = AdaptivePerformance.AdaptivePerformanceRenderSettings.MaxShadowDistanceMultiplier;
|
|
cameraData.maxShadowDistance *= MaxShadowDistanceMultiplier;
|
|
|
|
var RenderScaleMultiplier = AdaptivePerformance.AdaptivePerformanceRenderSettings.RenderScaleMultiplier;
|
|
cameraData.renderScale *= RenderScaleMultiplier;
|
|
|
|
// TODO
|
|
if (!cameraData.xr.enabled)
|
|
{
|
|
cameraData.cameraTargetDescriptor.width = (int)(cameraData.camera.pixelWidth * cameraData.renderScale);
|
|
cameraData.cameraTargetDescriptor.height = (int)(cameraData.camera.pixelHeight * cameraData.renderScale);
|
|
}
|
|
|
|
var antialiasingQualityIndex = (int)cameraData.antialiasingQuality - AdaptivePerformance.AdaptivePerformanceRenderSettings.AntiAliasingQualityBias;
|
|
if (antialiasingQualityIndex < 0)
|
|
cameraData.antialiasing = AntialiasingMode.None;
|
|
cameraData.antialiasingQuality = (AntialiasingQuality)Mathf.Clamp(antialiasingQualityIndex, (int)AntialiasingQuality.Low, (int)AntialiasingQuality.High);
|
|
}
|
|
|
|
static void ApplyAdaptivePerformance(ref RenderingData renderingData)
|
|
{
|
|
if (AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipDynamicBatching)
|
|
renderingData.supportsDynamicBatching = false;
|
|
|
|
var MainLightShadowmapResolutionMultiplier = AdaptivePerformance.AdaptivePerformanceRenderSettings.MainLightShadowmapResolutionMultiplier;
|
|
renderingData.shadowData.mainLightShadowmapWidth = (int)(renderingData.shadowData.mainLightShadowmapWidth * MainLightShadowmapResolutionMultiplier);
|
|
renderingData.shadowData.mainLightShadowmapHeight = (int)(renderingData.shadowData.mainLightShadowmapHeight * MainLightShadowmapResolutionMultiplier);
|
|
|
|
var MainLightShadowCascadesCountBias = AdaptivePerformance.AdaptivePerformanceRenderSettings.MainLightShadowCascadesCountBias;
|
|
renderingData.shadowData.mainLightShadowCascadesCount = Mathf.Clamp(renderingData.shadowData.mainLightShadowCascadesCount - MainLightShadowCascadesCountBias, 0, 4);
|
|
|
|
var shadowQualityIndex = AdaptivePerformance.AdaptivePerformanceRenderSettings.ShadowQualityBias;
|
|
for (int i = 0; i < shadowQualityIndex; i++)
|
|
{
|
|
if (renderingData.shadowData.supportsSoftShadows)
|
|
{
|
|
renderingData.shadowData.supportsSoftShadows = false;
|
|
continue;
|
|
}
|
|
|
|
if (renderingData.shadowData.supportsAdditionalLightShadows)
|
|
{
|
|
renderingData.shadowData.supportsAdditionalLightShadows = false;
|
|
continue;
|
|
}
|
|
|
|
if (renderingData.shadowData.supportsMainLightShadows)
|
|
{
|
|
renderingData.shadowData.supportsMainLightShadows = false;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (AdaptivePerformance.AdaptivePerformanceRenderSettings.LutBias >= 1 && renderingData.postProcessingData.lutSize == 32)
|
|
renderingData.postProcessingData.lutSize = 16;
|
|
}
|
|
|
|
#endif
|
|
}
|
|
}
|