// Used for updating URP cameraData data struct with XRPass data. internal void UpdateCameraData(ref CameraData baseCameraData, in XRPass xr)
internal void SetupNativeRenderPassFrameData(CameraData cameraData, bool isRenderPassEnabled)
{
//TODO: edge cases to detect that should affect possible passes to merge
// - total number of color attachment > 8
// Go through all the passes and mark the final one as last pass
using (new ProfilingScope(null, Profiling.setupFrameData))
{
int lastPassIndex = m_ActiveRenderPassQueue.Count - 1;
// Make sure the list is already sorted!
m_MergeableRenderPassesMap.Clear();
m_RenderPassesAttachmentCount.Clear();
uint currentHashIndex = 0;
// reset all the passes last pass flag
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
{
var renderPass = m_ActiveRenderPassQueue[i];
renderPass.renderPassQueueIndex = i;
bool RPEnabled = IsRenderPassEnabled(renderPass);
if (!RPEnabled)
{
continue;
}
var rpDesc = InitializeRenderPassDescriptor(cameraData, renderPass);
Hash128 hash = CreateRenderPassHash(rpDesc, currentHashIndex);
m_PassIndexToPassHash[i] = hash;
if (!m_MergeableRenderPassesMap.ContainsKey(hash))
{
m_MergeableRenderPassesMap.Add(hash, m_MergeableRenderPassesMapArrays[m_MergeableRenderPassesMap.Count]);
m_RenderPassesAttachmentCount.Add(hash, 0);
}
else if (m_MergeableRenderPassesMap[hash][GetValidPassIndexCount(m_MergeableRenderPassesMap[hash]) - 1] != (i - 1))
{
// if the passes are not sequential we want to split the current mergeable passes list. So we increment the hashIndex and update the hash
currentHashIndex++;
hash = CreateRenderPassHash(rpDesc, currentHashIndex);
m_PassIndexToPassHash[i] = hash;
m_MergeableRenderPassesMap.Add(hash, m_MergeableRenderPassesMapArrays[m_MergeableRenderPassesMap.Count]);
m_RenderPassesAttachmentCount.Add(hash, 0);
}
m_MergeableRenderPassesMap[hash][GetValidPassIndexCount(m_MergeableRenderPassesMap[hash])] = i;
}
for (int i = 0; i < m_ActiveRenderPassQueue.Count; ++i)
{
m_ActiveRenderPassQueue[i].m_ColorAttachmentIndices = new NativeArray <int>(8, Allocator.Temp);
m_ActiveRenderPassQueue[i].m_InputAttachmentIndices = new NativeArray <int>(8, Allocator.Temp);
}
}
}
internal List <XRPass> SetupFrame(CameraData cameraData)
{
Camera camera = cameraData.camera;
bool xrEnabled = RefreshXrSdk();
if (display != null)
{
// XRTODO: Handle stereo mode selection in URP pipeline asset UI
display.textureLayout = XRDisplaySubsystem.TextureLayout.Texture2DArray;
display.zNear = camera.nearClipPlane;
display.zFar = camera.farClipPlane;
display.sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
}
if (framePasses.Count > 0)
{
Debug.LogWarning("XRSystem.ReleaseFrame() was not called!");
ReleaseFrame();
}
if (camera == null)
{
return(framePasses);
}
// Enable XR layout only for game camera
bool isGameCamera = (camera.cameraType == CameraType.Game || camera.cameraType == CameraType.VR);
bool xrSupported = isGameCamera && camera.targetTexture == null && cameraData.xrRendering;
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (XRGraphicsAutomatedTests.enabled && XRGraphicsAutomatedTests.running && isGameCamera && LayoutSinglePassTestMode(cameraData, new XRLayout()
{
camera = camera, xrSystem = this
}))
{
// test layout in used
}
else
#endif
if (xrEnabled && xrSupported)
{
// Disable vsync on the main display when rendering to a XR device
// XRTODO: Quest provider has a bug where vSyncCount must be 1, otherwise app is locked to 30fps
if (Application.platform == RuntimePlatform.Android)
{
QualitySettings.vSyncCount = 1;
}
else
{
QualitySettings.vSyncCount = 0;
}
CreateLayoutFromXrSdk(camera, singlePassAllowed: true);
}
else
{
AddPassToFrame(emptyPass);
}
return(framePasses);
}
internal void SetNativeRenderPassAttachmentList(ScriptableRenderPass renderPass, ref CameraData cameraData, RTHandle passColorAttachment, RTHandle passDepthAttachment, ClearFlag finalClearFlag, Color finalClearColor)
{
using (new ProfilingScope(null, Profiling.setAttachmentList))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
// Skip if not the first pass
if (currentMergeablePasses.First() != currentPassIndex)
{
return;
}
m_RenderPassesAttachmentCount[currentPassHash] = 0;
UpdateFinalStoreActions(currentMergeablePasses, cameraData);
int currentAttachmentIdx = 0;
foreach (var passIdx in currentMergeablePasses)
{
if (passIdx == -1)
{
break;
}
ScriptableRenderPass pass = m_ActiveRenderPassQueue[passIdx];
for (int i = 0; i < pass.m_ColorAttachmentIndices.Length; ++i)
{
pass.m_ColorAttachmentIndices[i] = -1;
}
AttachmentDescriptor currentAttachmentDescriptor;
var usesTargetTexture = cameraData.targetTexture != null;
var depthOnly = (pass.colorAttachmentHandle.rt != null && IsDepthOnlyRenderTexture(pass.colorAttachmentHandle.rt)) || (usesTargetTexture && IsDepthOnlyRenderTexture(cameraData.targetTexture));
int samples;
RenderTargetIdentifier colorAttachmentTarget;
// We are not rendering to Backbuffer so we have the RT and the information with it
// while also creating a new RenderTargetIdentifier to ignore the current depth slice (which might get bypassed in XR setup eventually)
if (new RenderTargetIdentifier(passColorAttachment.nameID, 0, depthSlice: 0) != BuiltinRenderTextureType.CameraTarget)
{
currentAttachmentDescriptor = new AttachmentDescriptor(depthOnly ? passColorAttachment.rt.descriptor.depthStencilFormat : passColorAttachment.rt.descriptor.graphicsFormat);
samples = passColorAttachment.rt.descriptor.msaaSamples;
colorAttachmentTarget = passColorAttachment.nameID;
}
else // In this case we might be rendering the the targetTexture or the Backbuffer, so less information is available
{
currentAttachmentDescriptor = new AttachmentDescriptor(GetDefaultGraphicsFormat(cameraData, depthOnly));
samples = cameraData.cameraTargetDescriptor.msaaSamples;
colorAttachmentTarget = usesTargetTexture ? new RenderTargetIdentifier(cameraData.targetTexture) : BuiltinRenderTextureType.CameraTarget;
}
currentAttachmentDescriptor.ConfigureTarget(colorAttachmentTarget, ((uint)finalClearFlag & (uint)ClearFlag.Color) == 0, true);
if (PassHasInputAttachments(pass))
{
SetupInputAttachmentIndices(pass);
}
// TODO: this is redundant and is being setup for each attachment. Needs to be done only once per mergeable pass list (we need to make sure mergeable passes use the same depth!)
m_ActiveDepthAttachmentDescriptor = new AttachmentDescriptor(SystemInfo.GetGraphicsFormat(DefaultFormat.DepthStencil));
m_ActiveDepthAttachmentDescriptor.ConfigureTarget(passDepthAttachment.nameID != BuiltinRenderTextureType.CameraTarget ? passDepthAttachment.nameID :
(usesTargetTexture ? new RenderTargetIdentifier(cameraData.targetTexture.depthBuffer) : BuiltinRenderTextureType.Depth),
((uint)finalClearFlag & (uint)ClearFlag.Depth) == 0, true);
if (finalClearFlag != ClearFlag.None)
{
// We don't clear color for Overlay render targets, however pipeline set's up depth only render passes as color attachments which we do need to clear
if ((cameraData.renderType != CameraRenderType.Overlay || depthOnly && ((uint)finalClearFlag & (uint)ClearFlag.Color) != 0))
{
currentAttachmentDescriptor.ConfigureClear(finalClearColor, 1.0f, 0);
}
if (((uint)finalClearFlag & (uint)ClearFlag.Depth) != 0)
{
m_ActiveDepthAttachmentDescriptor.ConfigureClear(Color.black, 1.0f, 0);
}
}
// resolving to the implicit color target's resolve surface TODO: handle m_CameraResolveTarget if present?
if (samples > 1)
{
currentAttachmentDescriptor.ConfigureResolveTarget(colorAttachmentTarget);
if (RenderingUtils.MultisampleDepthResolveSupported())
{
m_ActiveDepthAttachmentDescriptor.ConfigureResolveTarget(m_ActiveDepthAttachmentDescriptor.loadStoreTarget);
}
}
if (m_UseOptimizedStoreActions)
{
currentAttachmentDescriptor.storeAction = m_FinalColorStoreAction[0];
m_ActiveDepthAttachmentDescriptor.storeAction = m_FinalDepthStoreAction;
}
int existingAttachmentIndex = FindAttachmentDescriptorIndexInList(currentAttachmentIdx,
currentAttachmentDescriptor, m_ActiveColorAttachmentDescriptors);
if (existingAttachmentIndex == -1)
{
// add a new attachment
pass.m_ColorAttachmentIndices[0] = currentAttachmentIdx;
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx] = currentAttachmentDescriptor;
currentAttachmentIdx++;
m_RenderPassesAttachmentCount[currentPassHash]++;
}
else
{
// attachment was already present
pass.m_ColorAttachmentIndices[0] = existingAttachmentIndex;
}
}
}
}
internal void ExecuteNativeRenderPass(ScriptableRenderContext context, ScriptableRenderPass renderPass, CameraData cameraData, ref RenderingData renderingData)
{
using (new ProfilingScope(null, Profiling.execute))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
int validColorBuffersCount = m_RenderPassesAttachmentCount[currentPassHash];
var depthOnly = (renderPass.colorAttachmentHandle.rt != null && IsDepthOnlyRenderTexture(renderPass.colorAttachmentHandle.rt)) || (cameraData.targetTexture != null && IsDepthOnlyRenderTexture(cameraData.targetTexture));
bool useDepth = depthOnly || (!renderPass.overrideCameraTarget || (renderPass.overrideCameraTarget && renderPass.depthAttachmentHandle.nameID != BuiltinRenderTextureType.CameraTarget));// &&
var attachments =
new NativeArray <AttachmentDescriptor>(useDepth && !depthOnly ? validColorBuffersCount + 1 : 1, Allocator.Temp);
for (int i = 0; i < validColorBuffersCount; ++i)
{
attachments[i] = m_ActiveColorAttachmentDescriptors[i];
}
if (useDepth && !depthOnly)
{
attachments[validColorBuffersCount] = m_ActiveDepthAttachmentDescriptor;
}
var rpDesc = InitializeRenderPassDescriptor(cameraData, renderPass);
int validPassCount = GetValidPassIndexCount(currentMergeablePasses);
var attachmentIndicesCount = GetSubPassAttachmentIndicesCount(renderPass);
var attachmentIndices = new NativeArray <int>(!depthOnly ? (int)attachmentIndicesCount : 0, Allocator.Temp);
if (!depthOnly)
{
for (int i = 0; i < attachmentIndicesCount; ++i)
{
attachmentIndices[i] = renderPass.m_ColorAttachmentIndices[i];
}
}
if (validPassCount == 1 || currentMergeablePasses[0] == currentPassIndex) // Check if it's the first pass
{
if (PassHasInputAttachments(renderPass))
{
Debug.LogWarning("First pass in a RenderPass should not have input attachments.");
}
context.BeginRenderPass(rpDesc.w, rpDesc.h, Math.Max(rpDesc.samples, 1), attachments,
useDepth ? (!depthOnly ? validColorBuffersCount : 0) : -1);
attachments.Dispose();
context.BeginSubPass(attachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
else
{
// Regarding input attachments, currently we always recreate a new subpass if it contains input attachments
// This might not the most optimal way though and it should be investigated in the future
// Whether merging subpasses with matching input attachments is a more viable option
if (!AreAttachmentIndicesCompatible(m_ActiveRenderPassQueue[m_LastBeginSubpassPassIndex], m_ActiveRenderPassQueue[currentPassIndex]))
{
context.EndSubPass();
if (PassHasInputAttachments(m_ActiveRenderPassQueue[currentPassIndex]))
{
context.BeginSubPass(attachmentIndices, m_ActiveRenderPassQueue[currentPassIndex].m_InputAttachmentIndices);
}
else
{
context.BeginSubPass(attachmentIndices);
}
m_LastBeginSubpassPassIndex = currentPassIndex;
}
else if (PassHasInputAttachments(m_ActiveRenderPassQueue[currentPassIndex]))
{
context.EndSubPass();
context.BeginSubPass(attachmentIndices, m_ActiveRenderPassQueue[currentPassIndex].m_InputAttachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
}
attachmentIndices.Dispose();
renderPass.Execute(context, ref renderingData);
if (validPassCount == 1 || currentMergeablePasses[validPassCount - 1] == currentPassIndex) // Check if it's the last pass
{
context.EndSubPass();
context.EndRenderPass();
m_LastBeginSubpassPassIndex = 0;
}
for (int i = 0; i < m_ActiveColorAttachmentDescriptors.Length; ++i)
{
m_ActiveColorAttachmentDescriptors[i] = RenderingUtils.emptyAttachment;
m_IsActiveColorAttachmentTransient[i] = false;
}
m_ActiveDepthAttachmentDescriptor = RenderingUtils.emptyAttachment;
}
}
internal void UpdateShaderGlobalPropertiesForFinalValidationPass(CommandBuffer cmd, ref CameraData cameraData, bool isFinalPass)
{
// Ensure final validation & fullscreen debug modes are only done once in the very final pass, for the last camera on the stack.
bool isFinal = isFinalPass && cameraData.resolveFinalTarget;
if (!isFinal)
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DEBUG_DISPLAY);
return;
}
if (IsActiveForCamera(ref cameraData))
{
cmd.EnableShaderKeyword(ShaderKeywordStrings.DEBUG_DISPLAY);
}
else
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DEBUG_DISPLAY);
}
if (m_HasDebugRenderTarget)
{
cmd.SetGlobalTexture(m_DebugRenderTargetSupportsStereo ? k_DebugTexturePropertyId : k_DebugTextureNoStereoPropertyId, m_DebugRenderTargetIdentifier);
cmd.SetGlobalVector(k_DebugTextureDisplayRect, m_DebugRenderTargetPixelRect);
cmd.SetGlobalInteger(k_DebugRenderTargetSupportsStereo, m_DebugRenderTargetSupportsStereo ? 1 : 0);
}
var renderingSettings = m_DebugDisplaySettings.RenderingSettings;
if (renderingSettings.validationMode == DebugValidationMode.HighlightOutsideOfRange)
{
cmd.SetGlobalInteger(k_ValidationChannelsId, (int)renderingSettings.validationChannels);
cmd.SetGlobalFloat(k_RangeMinimumId, renderingSettings.ValidationRangeMin);
cmd.SetGlobalFloat(k_RangeMaximumId, renderingSettings.ValidationRangeMax);
}
}
internal void SetNativeRenderPassMRTAttachmentList(ScriptableRenderPass renderPass, ref CameraData cameraData, bool needCustomCameraColorClear, ClearFlag cameraClearFlag)
{
using (new ProfilingScope(null, Profiling.setMRTAttachmentsList))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
// Not the first pass
if (currentMergeablePasses.First() != currentPassIndex)
{
return;
}
m_RenderPassesAttachmentCount[currentPassHash] = 0;
UpdateFinalStoreActions(currentMergeablePasses, cameraData);
int currentAttachmentIdx = 0;
bool hasInput = false;
foreach (var passIdx in currentMergeablePasses)
{
if (passIdx == -1)
{
break;
}
ScriptableRenderPass pass = m_ActiveRenderPassQueue[passIdx];
for (int i = 0; i < pass.m_ColorAttachmentIndices.Length; ++i)
{
pass.m_ColorAttachmentIndices[i] = -1;
}
for (int i = 0; i < pass.m_InputAttachmentIndices.Length; ++i)
{
pass.m_InputAttachmentIndices[i] = -1;
}
uint validColorBuffersCount = RenderingUtils.GetValidColorBufferCount(pass.colorAttachmentHandles);
for (int i = 0; i < validColorBuffersCount; ++i)
{
AttachmentDescriptor currentAttachmentDescriptor =
new AttachmentDescriptor(pass.renderTargetFormat[i] != GraphicsFormat.None ? pass.renderTargetFormat[i] : GetDefaultGraphicsFormat(cameraData));
var colorHandle = pass.overrideCameraTarget ? pass.colorAttachmentHandles[i] : m_CameraColorTarget.handle;
int existingAttachmentIndex = FindAttachmentDescriptorIndexInList(colorHandle.nameID, m_ActiveColorAttachmentDescriptors);
if (m_UseOptimizedStoreActions)
{
currentAttachmentDescriptor.storeAction = m_FinalColorStoreAction[i];
}
if (existingAttachmentIndex == -1)
{
// add a new attachment
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx] = currentAttachmentDescriptor;
bool passHasClearColor = (pass.clearFlag & ClearFlag.Color) != 0;
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx].ConfigureTarget(colorHandle.nameID, !passHasClearColor, true);
if (pass.colorAttachmentHandles[i] == m_CameraColorTarget.handle && needCustomCameraColorClear && (cameraClearFlag & ClearFlag.Color) != 0)
{
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx].ConfigureClear(cameraData.backgroundColor, 1.0f, 0);
}
else if (passHasClearColor)
{
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx].ConfigureClear(CoreUtils.ConvertSRGBToActiveColorSpace(pass.clearColor), 1.0f, 0);
}
pass.m_ColorAttachmentIndices[i] = currentAttachmentIdx;
currentAttachmentIdx++;
m_RenderPassesAttachmentCount[currentPassHash]++;
}
else
{
// attachment was already present
pass.m_ColorAttachmentIndices[i] = existingAttachmentIndex;
}
}
if (PassHasInputAttachments(pass))
{
hasInput = true;
SetupInputAttachmentIndices(pass);
}
// TODO: this is redundant and is being setup for each attachment. Needs to be done only once per mergeable pass list (we need to make sure mergeable passes use the same depth!)
m_ActiveDepthAttachmentDescriptor = new AttachmentDescriptor(SystemInfo.GetGraphicsFormat(DefaultFormat.DepthStencil));
bool passHasClearDepth = (cameraClearFlag & ClearFlag.DepthStencil) != 0;
m_ActiveDepthAttachmentDescriptor.ConfigureTarget(pass.overrideCameraTarget ? pass.depthAttachmentHandle.nameID : m_CameraDepthTarget.nameID, !passHasClearDepth, true);
if (passHasClearDepth)
{
m_ActiveDepthAttachmentDescriptor.ConfigureClear(Color.black, 1.0f, 0);
}
if (m_UseOptimizedStoreActions)
{
m_ActiveDepthAttachmentDescriptor.storeAction = m_FinalDepthStoreAction;
}
}
if (hasInput)
{
SetupTransientInputAttachments(m_RenderPassesAttachmentCount[currentPassHash]);
}
}
}
static void InitializeCameraData(UniversalRenderPipelineAsset settings, Camera camera, UniversalAdditionalCameraData additionalCameraData, out CameraData cameraData)
{
const float kRenderScaleThreshold = 0.05f;
cameraData = new CameraData();
cameraData.camera = camera;
cameraData.isStereoEnabled = IsStereoEnabled(camera);
int msaaSamples = 1;
if (camera.allowMSAA && settings.msaaSampleCount > 1)
{
msaaSamples = (camera.targetTexture != null) ? camera.targetTexture.antiAliasing : settings.msaaSampleCount;
}
cameraData.isSceneViewCamera = camera.cameraType == CameraType.SceneView;
cameraData.isHdrEnabled = camera.allowHDR && settings.supportsHDR;
cameraData.postProcessEnabled = CoreUtils.ArePostProcessesEnabled(camera) &&
camera.cameraType != CameraType.Reflection &&
camera.cameraType != CameraType.Preview &&
SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
// Disables postprocessing in mobile VR. It's not stable on mobile yet.
// TODO: enable postfx for stereo rendering
if (cameraData.isStereoEnabled && Application.isMobilePlatform)
{
cameraData.postProcessEnabled = false;
}
Rect cameraRect = camera.rect;
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));
// If XR is enabled, use XR renderScale.
// Discard variations lesser than kRenderScaleThreshold.
// Scale is only enabled for gameview.
float usedRenderScale = XRGraphics.enabled ? XRGraphics.eyeTextureResolutionScale : settings.renderScale;
cameraData.renderScale = (Mathf.Abs(1.0f - usedRenderScale) < kRenderScaleThreshold) ? 1.0f : usedRenderScale;
cameraData.renderScale = (camera.cameraType == CameraType.Game) ? cameraData.renderScale : 1.0f;
bool anyShadowsEnabled = settings.supportsMainLightShadows || settings.supportsAdditionalLightShadows;
cameraData.maxShadowDistance = (anyShadowsEnabled) ? settings.shadowDistance : 0.0f;
if (additionalCameraData != null)
{
cameraData.maxShadowDistance = (additionalCameraData.renderShadows) ? cameraData.maxShadowDistance : 0.0f;
cameraData.requiresDepthTexture = additionalCameraData.requiresDepthTexture;
cameraData.requiresOpaqueTexture = additionalCameraData.requiresColorTexture;
cameraData.volumeLayerMask = additionalCameraData.volumeLayerMask;
cameraData.volumeTrigger = additionalCameraData.volumeTrigger == null ? camera.transform : additionalCameraData.volumeTrigger;
cameraData.postProcessEnabled &= additionalCameraData.renderPostProcessing;
cameraData.isStopNaNEnabled = cameraData.postProcessEnabled && additionalCameraData.stopNaN && SystemInfo.graphicsShaderLevel >= 35;
cameraData.isDitheringEnabled = cameraData.postProcessEnabled && additionalCameraData.dithering;
cameraData.antialiasing = cameraData.postProcessEnabled ? additionalCameraData.antialiasing : AntialiasingMode.None;
cameraData.antialiasingQuality = additionalCameraData.antialiasingQuality;
}
else
{
cameraData.requiresDepthTexture = settings.supportsCameraDepthTexture;
cameraData.requiresOpaqueTexture = settings.supportsCameraOpaqueTexture;
cameraData.volumeLayerMask = 1; // "Default"
cameraData.volumeTrigger = null;
cameraData.postProcessEnabled = false;
cameraData.isStopNaNEnabled = false;
cameraData.isDitheringEnabled = false;
cameraData.antialiasing = AntialiasingMode.None;
cameraData.antialiasingQuality = AntialiasingQuality.High;
}
cameraData.requiresDepthTexture |= cameraData.isSceneViewCamera || cameraData.postProcessEnabled;
var commonOpaqueFlags = SortingCriteria.CommonOpaque;
var noFrontToBackOpaqueFlags = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges | SortingCriteria.CanvasOrder;
bool hasHSRGPU = SystemInfo.hasHiddenSurfaceRemovalOnGPU;
bool canSkipFrontToBackSorting = (camera.opaqueSortMode == OpaqueSortMode.Default && hasHSRGPU) || camera.opaqueSortMode == OpaqueSortMode.NoDistanceSort;
cameraData.defaultOpaqueSortFlags = canSkipFrontToBackSorting ? noFrontToBackOpaqueFlags : commonOpaqueFlags;
cameraData.captureActions = CameraCaptureBridge.GetCaptureActions(camera);
cameraData.cameraTargetDescriptor = CreateRenderTextureDescriptor(camera, cameraData.renderScale,
cameraData.isStereoEnabled, cameraData.isHdrEnabled, msaaSamples);
}
internal bool IsActiveForCamera(ref CameraData cameraData)
{
return(!cameraData.isPreviewCamera && AreAnySettingsActive);
}
/// <summary>
/// Set RenderBuffer for camera;
/// </summary>
private void RefreshRenderBufferForSingleCamera(ScriptableRenderContext context, ref RenderingData renderingData,
ref CameraData cameraData, out bool requiresDepthPrepass, out bool createDepthTexture)
{
Camera camera = renderingData.cameraData.camera;
RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
bool applyPostProcessing = cameraData.postProcessEnabled;
bool isSceneViewCamera = cameraData.isSceneViewCamera;
bool isPreviewCamera = cameraData.isPreviewCamera;
bool requiresDepthTexture = cameraData.requiresDepthTexture;
bool isStereoEnabled = cameraData.isStereoEnabled;
// 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.
requiresDepthPrepass = requiresDepthTexture && !CanCopyDepth(ref renderingData.cameraData);
requiresDepthPrepass |= isSceneViewCamera;
requiresDepthPrepass |= isPreviewCamera;
// 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
m_CopyDepthPass.renderPassEvent = (!requiresDepthTexture && (applyPostProcessing || isSceneViewCamera)) ?
RenderPassEvent.AfterRenderingTransparents : RenderPassEvent.AfterRenderingOpaques;
// TODO: CopyDepth pass is disabled in XR due to required work to handle camera matrices in URP.
// IF this condition is removed make sure the CopyDepthPass.cs is working properly on all XR modes. This requires PureXR SDK integration.
if (isStereoEnabled && requiresDepthTexture)
{
requiresDepthPrepass = true;
}
bool isRunningHololens = false;
#if ENABLE_VR && ENABLE_VR_MODULE
isRunningHololens = UniversalRenderPipeline.IsRunningHololens(camera);
#endif
bool createColorTexture = RequiresIntermediateColorTexture(ref cameraData);
createColorTexture |= (rendererFeatures.Count != 0 && !isRunningHololens);
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.
createDepthTexture = cameraData.requiresDepthTexture && !requiresDepthPrepass;
createDepthTexture |= (cameraData.renderType == CameraRenderType.Base && !cameraData.resolveFinalTarget);
#if UNITY_ANDROID || UNITY_WEBGL
if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Vulkan)
{
// 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.
createColorTexture |= createDepthTexture;
}
#endif
// Configure all settings require to start a new camera stack (base camera only)
if (cameraData.renderType == CameraRenderType.Base)
{
m_ActiveCameraColorAttachment = (createColorTexture) ? m_CameraColorAttachment : RenderTargetHandle.CameraTarget;
m_ActiveCameraDepthAttachment = (createDepthTexture) ? m_CameraDepthAttachment : RenderTargetHandle.CameraTarget;
bool intermediateRenderTexture = createColorTexture || createDepthTexture;
// Doesn't create texture for Overlay cameras as they are already overlaying on top of created textures.
bool createTextures = intermediateRenderTexture;
if (createTextures)
{
CreateCameraRenderTarget(context, ref renderingData.cameraData);
}
// if rendering to intermediate render texture we don't have to create msaa backbuffer
int backbufferMsaaSamples = (intermediateRenderTexture) ? 1 : cameraTargetDescriptor.msaaSamples;
if (Camera.main == camera && camera.cameraType == CameraType.Game && cameraData.targetTexture == null)
{
SetupBackbufferFormat(backbufferMsaaSamples, isStereoEnabled);
}
}
else
{
if (m_SplitUICameraAndSceneCameraRenderer)
{
RefreshCameraColorAttachment(context, ref renderingData.cameraData);
}
else
{
m_ActiveCameraColorAttachment = m_CameraColorAttachment;
m_ActiveCameraDepthAttachment = m_CameraDepthAttachment;
}
}
ConfigureCameraTarget(m_ActiveCameraColorAttachment.Identifier(), m_ActiveCameraDepthAttachment.Identifier());
}
public override void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters, ref CameraData cameraData)
{
throw new NotSupportedException(k_ErrorMessage);
}
internal void ExecuteNativeRenderPass(ScriptableRenderContext context, ScriptableRenderPass renderPass, CameraData cameraData, ref RenderingData renderingData)
{
using (new ProfilingScope(null, Profiling.execute))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
int validColorBuffersCount = m_RenderPassesAttachmentCount[currentPassHash];
bool isLastPass = renderPass.isLastPass;
// TODO: review the lastPassToBB logic to mak it work with merged passes
// keep track if this is the current camera's last pass and the RT is the backbuffer (BuiltinRenderTextureType.CameraTarget)
bool isLastPassToBB = isLastPass && (m_ActiveColorAttachmentDescriptors[0].loadStoreTarget ==
BuiltinRenderTextureType.CameraTarget);
var depthOnly = renderPass.depthOnly || (cameraData.targetTexture != null && cameraData.targetTexture.graphicsFormat == GraphicsFormat.DepthAuto);
bool useDepth = depthOnly || (!renderPass.overrideCameraTarget || (renderPass.overrideCameraTarget && renderPass.depthAttachment != BuiltinRenderTextureType.CameraTarget)) &&
(!(isLastPassToBB || (isLastPass && cameraData.camera.targetTexture != null)));
var attachments =
new NativeArray <AttachmentDescriptor>(useDepth && !depthOnly ? validColorBuffersCount + 1 : 1,
Allocator.Temp);
for (int i = 0; i < validColorBuffersCount; ++i)
{
attachments[i] = m_ActiveColorAttachmentDescriptors[i];
}
if (useDepth && !depthOnly)
{
attachments[validColorBuffersCount] = m_ActiveDepthAttachmentDescriptor;
}
var rpDesc = InitializeRenderPassDescriptor(cameraData, renderPass);
int validPassCount = GetValidPassIndexCount(currentMergeablePasses);
var attachmentIndicesCount = GetSubPassAttachmentIndicesCount(renderPass);
var attachmentIndices = new NativeArray <int>(!depthOnly ? (int)attachmentIndicesCount : 0, Allocator.Temp);
if (!depthOnly)
{
for (int i = 0; i < attachmentIndicesCount; ++i)
{
attachmentIndices[i] = renderPass.m_InputAttachmentIndices[i];
}
}
if (validPassCount == 1 || currentMergeablePasses[0] == currentPassIndex) // Check if it's the first pass
{
context.BeginRenderPass(rpDesc.w, rpDesc.h, Math.Max(rpDesc.samples, 1), attachments,
useDepth ? (!depthOnly ? validColorBuffersCount : 0) : -1);
attachments.Dispose();
context.BeginSubPass(attachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
else
{
if (!AreAttachmentIndicesCompatible(m_ActiveRenderPassQueue[m_LastBeginSubpassPassIndex], m_ActiveRenderPassQueue[currentPassIndex]))
{
context.EndSubPass();
context.BeginSubPass(attachmentIndices);
m_LastBeginSubpassPassIndex = currentPassIndex;
}
}
attachmentIndices.Dispose();
renderPass.Execute(context, ref renderingData);
if (validPassCount == 1 || currentMergeablePasses[validPassCount - 1] == currentPassIndex) // Check if it's the last pass
{
context.EndSubPass();
context.EndRenderPass();
m_LastBeginSubpassPassIndex = 0;
}
for (int i = 0; i < m_ActiveColorAttachmentDescriptors.Length; ++i)
{
m_ActiveColorAttachmentDescriptors[i] = RenderingUtils.emptyAttachment;
}
m_ActiveDepthAttachmentDescriptor = RenderingUtils.emptyAttachment;
}
}
internal void ConfigureNativeRenderPass(CommandBuffer cmd, ScriptableRenderPass renderPass, CameraData cameraData)
{
using (new ProfilingScope(null, Profiling.configure))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
// If it's the first pass, configure the whole merge block
if (currentMergeablePasses.First() == currentPassIndex)
{
foreach (var passIdx in currentMergeablePasses)
{
if (passIdx == -1)
{
break;
}
ScriptableRenderPass pass = m_ActiveRenderPassQueue[passIdx];
pass.Configure(cmd, cameraData.cameraTargetDescriptor);
}
}
}
}
internal void SetNativeRenderPassAttachmentList(ScriptableRenderPass renderPass, ref CameraData cameraData, RenderTargetIdentifier passColorAttachment, RenderTargetIdentifier passDepthAttachment, ClearFlag finalClearFlag, Color finalClearColor)
{
using (new ProfilingScope(null, Profiling.setAttachmentList))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
// Skip if not the first pass
if (currentMergeablePasses.First() != currentPassIndex)
{
return;
}
m_RenderPassesAttachmentCount[currentPassHash] = 0;
int currentAttachmentIdx = 0;
foreach (var passIdx in currentMergeablePasses)
{
if (passIdx == -1)
{
break;
}
ScriptableRenderPass pass = m_ActiveRenderPassQueue[passIdx];
for (int i = 0; i < pass.m_InputAttachmentIndices.Length; ++i)
{
pass.m_InputAttachmentIndices[i] = -1;
}
AttachmentDescriptor currentAttachmentDescriptor;
var usesTargetTexture = cameraData.targetTexture != null;
var depthOnly = renderPass.depthOnly || (usesTargetTexture && cameraData.targetTexture.graphicsFormat == GraphicsFormat.DepthAuto);
// Offscreen depth-only cameras need this set explicitly
if (depthOnly && usesTargetTexture)
{
if (cameraData.targetTexture.graphicsFormat == GraphicsFormat.DepthAuto && !pass.overrideCameraTarget)
{
passColorAttachment = new RenderTargetIdentifier(cameraData.targetTexture);
}
else
{
passColorAttachment = renderPass.colorAttachment;
}
currentAttachmentDescriptor = new AttachmentDescriptor(GraphicsFormat.DepthAuto);
}
else
{
currentAttachmentDescriptor =
new AttachmentDescriptor(cameraData.cameraTargetDescriptor.graphicsFormat);
}
if (pass.overrideCameraTarget)
{
currentAttachmentDescriptor = new AttachmentDescriptor(pass.renderTargetFormat[0] != GraphicsFormat.None ? pass.renderTargetFormat[0] : GetDefaultGraphicsFormat(cameraData));
}
var samples = pass.renderTargetSampleCount != -1
? pass.renderTargetSampleCount
: cameraData.cameraTargetDescriptor.msaaSamples;
var colorAttachmentTarget =
(depthOnly || passColorAttachment != BuiltinRenderTextureType.CameraTarget)
? passColorAttachment : (usesTargetTexture
? new RenderTargetIdentifier(cameraData.targetTexture.colorBuffer)
: BuiltinRenderTextureType.CameraTarget);
var depthAttachmentTarget = (passDepthAttachment != BuiltinRenderTextureType.CameraTarget) ?
passDepthAttachment : (usesTargetTexture
? new RenderTargetIdentifier(cameraData.targetTexture.depthBuffer)
: BuiltinRenderTextureType.Depth);
// TODO: review the lastPassToBB logic to mak it work with merged passes
// keep track if this is the current camera's last pass and the RT is the backbuffer (BuiltinRenderTextureType.CameraTarget)
// knowing isLastPassToBB can help decide the optimal store action as it gives us additional information about the current frame
bool isLastPassToBB = pass.isLastPass && (colorAttachmentTarget == BuiltinRenderTextureType.CameraTarget);
currentAttachmentDescriptor.ConfigureTarget(colorAttachmentTarget, ((uint)finalClearFlag & (uint)ClearFlag.Color) == 0, !(samples > 1 && isLastPassToBB));
// TODO: this is redundant and is being setup for each attachment. Needs to be done only once per mergeable pass list (we need to make sure mergeable passes use the same depth!)
m_ActiveDepthAttachmentDescriptor = new AttachmentDescriptor(GraphicsFormat.DepthAuto);
m_ActiveDepthAttachmentDescriptor.ConfigureTarget(depthAttachmentTarget,
((uint)finalClearFlag & (uint)ClearFlag.Depth) == 0, !isLastPassToBB);
if (finalClearFlag != ClearFlag.None)
{
// We don't clear color for Overlay render targets, however pipeline set's up depth only render passes as color attachments which we do need to clear
if ((cameraData.renderType != CameraRenderType.Overlay || depthOnly && ((uint)finalClearFlag & (uint)ClearFlag.Color) != 0))
{
currentAttachmentDescriptor.ConfigureClear(finalClearColor, 1.0f, 0);
}
if (((uint)finalClearFlag & (uint)ClearFlag.Depth) != 0)
{
m_ActiveDepthAttachmentDescriptor.ConfigureClear(Color.black, 1.0f, 0);
}
}
// resolving to the implicit color target's resolve surface TODO: handle m_CameraResolveTarget if present?
if (samples > 1)
{
currentAttachmentDescriptor.ConfigureResolveTarget(colorAttachmentTarget);
}
int existingAttachmentIndex = FindAttachmentDescriptorIndexInList(currentAttachmentIdx,
currentAttachmentDescriptor, m_ActiveColorAttachmentDescriptors);
if (existingAttachmentIndex == -1)
{
// add a new attachment
pass.m_InputAttachmentIndices[0] = currentAttachmentIdx;
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx] = currentAttachmentDescriptor;
currentAttachmentIdx++;
m_RenderPassesAttachmentCount[currentPassHash]++;
}
else
{
// attachment was already present
pass.m_InputAttachmentIndices[0] = existingAttachmentIndex;
}
}
}
}
internal void SetNativeRenderPassMRTAttachmentList(ScriptableRenderPass renderPass, ref CameraData cameraData, uint validColorBuffersCount, bool needCustomCameraColorClear, ClearFlag clearFlag)
{
using (new ProfilingScope(null, Profiling.setMRTAttachmentsList))
{
int currentPassIndex = renderPass.renderPassQueueIndex;
Hash128 currentPassHash = m_PassIndexToPassHash[currentPassIndex];
int[] currentMergeablePasses = m_MergeableRenderPassesMap[currentPassHash];
// Not the first pass
if (currentMergeablePasses.First() != currentPassIndex)
{
return;
}
m_RenderPassesAttachmentCount[currentPassHash] = 0;
int currentAttachmentIdx = 0;
foreach (var passIdx in currentMergeablePasses)
{
if (passIdx == -1)
{
break;
}
ScriptableRenderPass pass = m_ActiveRenderPassQueue[passIdx];
for (int i = 0; i < pass.m_InputAttachmentIndices.Length; ++i)
{
pass.m_InputAttachmentIndices[i] = -1;
}
// TODO: review the lastPassToBB logic to mak it work with merged passes
bool isLastPassToBB = false;
for (int i = 0; i < validColorBuffersCount; ++i)
{
AttachmentDescriptor currentAttachmentDescriptor =
new AttachmentDescriptor(pass.renderTargetFormat[i] != GraphicsFormat.None ? pass.renderTargetFormat[i] : GetDefaultGraphicsFormat(cameraData));
// if this is the current camera's last pass, also check if one of the RTs is the backbuffer (BuiltinRenderTextureType.CameraTarget)
isLastPassToBB |= pass.isLastPass && (pass.colorAttachments[i] == BuiltinRenderTextureType.CameraTarget);
int existingAttachmentIndex = FindAttachmentDescriptorIndexInList(currentAttachmentIdx,
currentAttachmentDescriptor, m_ActiveColorAttachmentDescriptors);
if (existingAttachmentIndex == -1)
{
// add a new attachment
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx] = currentAttachmentDescriptor;
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx].ConfigureTarget(pass.colorAttachments[i], (clearFlag & ClearFlag.Color) == 0, true);
if ((clearFlag & ClearFlag.Color) != 0)
{
var clearColor = (needCustomCameraColorClear && pass.colorAttachments[i] == m_CameraColorTarget) ? cameraData.camera.backgroundColor : renderPass.clearColor;
m_ActiveColorAttachmentDescriptors[currentAttachmentIdx].ConfigureClear(CoreUtils.ConvertSRGBToActiveColorSpace(clearColor), 1.0f, 0);
}
pass.m_InputAttachmentIndices[i] = currentAttachmentIdx;
currentAttachmentIdx++;
m_RenderPassesAttachmentCount[currentPassHash]++;
}
else
{
// attachment was already present
pass.m_InputAttachmentIndices[i] = existingAttachmentIndex;
}
}
// TODO: this is redundant and is being setup for each attachment. Needs to be done only once per mergeable pass list (we need to make sure mergeable passes use the same depth!)
m_ActiveDepthAttachmentDescriptor = new AttachmentDescriptor(GraphicsFormat.DepthAuto);
m_ActiveDepthAttachmentDescriptor.ConfigureTarget(pass.depthAttachment, (clearFlag & ClearFlag.DepthStencil) == 0, !isLastPassToBB);
if ((clearFlag & ClearFlag.DepthStencil) != 0)
{
m_ActiveDepthAttachmentDescriptor.ConfigureClear(Color.black, 1.0f, 0);
}
}
}
}
/// <summary>
/// Set camera and screen shader variables as described in https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
/// </summary>
/// <param name="cmd">CommandBuffer to submit data to GPU.</param>
/// <param name="cameraData">CameraData containing camera matrices information.</param>
void SetPerCameraShaderVariables(CommandBuffer cmd, ref CameraData cameraData)
{
Camera camera = cameraData.camera;
Rect pixelRect = cameraData.pixelRect;
float scaledCameraWidth = (float)pixelRect.width * cameraData.renderScale;
float scaledCameraHeight = (float)pixelRect.height * cameraData.renderScale;
float cameraWidth = (float)pixelRect.width;
float cameraHeight = (float)pixelRect.height;
// Use eye texture's width and height as screen params when XR is enabled
if (cameraData.xr.enabled)
{
scaledCameraWidth = (float)cameraData.cameraTargetDescriptor.width;
scaledCameraHeight = (float)cameraData.cameraTargetDescriptor.height;
cameraWidth = (float)cameraData.cameraTargetDescriptor.width;
cameraHeight = (float)cameraData.cameraTargetDescriptor.height;
}
float near = camera.nearClipPlane;
float far = camera.farClipPlane;
float invNear = Mathf.Approximately(near, 0.0f) ? 0.0f : 1.0f / near;
float invFar = Mathf.Approximately(far, 0.0f) ? 0.0f : 1.0f / far;
float isOrthographic = camera.orthographic ? 1.0f : 0.0f;
// From http://www.humus.name/temp/Linearize%20depth.txt
// But as depth component textures on OpenGL always return in 0..1 range (as in D3D), we have to use
// the same constants for both D3D and OpenGL here.
// OpenGL would be this:
// zc0 = (1.0 - far / near) / 2.0;
// zc1 = (1.0 + far / near) / 2.0;
// D3D is this:
float zc0 = 1.0f - far * invNear;
float zc1 = far * invNear;
Vector4 zBufferParams = new Vector4(zc0, zc1, zc0 * invFar, zc1 * invFar);
if (SystemInfo.usesReversedZBuffer)
{
zBufferParams.y += zBufferParams.x;
zBufferParams.x = -zBufferParams.x;
zBufferParams.w += zBufferParams.z;
zBufferParams.z = -zBufferParams.z;
}
// Projection flip sign logic is very deep in GfxDevice::SetInvertProjectionMatrix
// For now we don't deal with _ProjectionParams.x and let SetupCameraProperties handle it.
// We need to enable this when we remove SetupCameraProperties
// float projectionFlipSign = ???
// Vector4 projectionParams = new Vector4(projectionFlipSign, near, far, 1.0f * invFar);
// cmd.SetGlobalVector(ShaderPropertyId.projectionParams, projectionParams);
Vector4 orthoParams = new Vector4(camera.orthographicSize * cameraData.aspectRatio, camera.orthographicSize, 0.0f, isOrthographic);
// Camera and Screen variables as described in https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
cmd.SetGlobalVector(ShaderPropertyId.worldSpaceCameraPos, camera.transform.position);
cmd.SetGlobalVector(ShaderPropertyId.screenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
cmd.SetGlobalVector(ShaderPropertyId.scaledScreenParams, new Vector4(scaledCameraWidth, scaledCameraHeight, 1.0f + 1.0f / scaledCameraWidth, 1.0f + 1.0f / scaledCameraHeight));
cmd.SetGlobalVector(ShaderPropertyId.zBufferParams, zBufferParams);
cmd.SetGlobalVector(ShaderPropertyId.orthoParams, orthoParams);
}
