[SRP] Screen Coordinates Override (v3)

JIRA Epic: https://jira.unity3d.com/browse/CD-74

Re-submission of #6597 which got reverted due to test failures.

This PR introduces **Screen Coordinates Override** (**SCO** for the remainder of this document) for both URP and HDRP. SCO
provides a transformation of screen space coordinates when evaluating screen space effects.

We have found it useful in virtual production scenarios.

The first use case for this is **Cluster Display** (formerly known as [Cluster Rendering](https://docs.unity3d.com/560/Documentation/Manual/ClusterRendering.html)), that is, distributed rendering. It allows for post effects such as vignette to be properly rendered at the scale of a grid of displays.

Another use case is the implementation of Lens Distortion when replicating the distortion incurred by a physical lens. Since pixels near the edges may be pushed inwards of the viewport by the distortion, we need to render the scene with overscan. (By overscan, we mean rendering to an expanded pixel surface, later cropped out to its original size before being
presented.) To preserve the distortion's aspect in the cropped image, we need to apply a transform to screen space coordinates when the lens distortion is being computed. 

The first implementation of this technique was part of the first Cluster Display effort, and was then called **Cluster
Display Space** or **Global Screen Space**. A high level description of the technique can be found in
[this document](https://docs.google.com/document/d/1I_mR42Tt119nVhhHwHG9F_n7DwpPin7Tds4yhx59oko/edit?usp=sharing) and [this one](https://docs.google.com/document/d/1qZqUTA5VAeV35PkldjOXXjpKD-JxWfgs2KJC6rh-4mo/edit?usp=sharing).

The switch to the **Screen Coordinates Override** terminology is justified by the fact that the technique is relevant outside of
Cluster Display. As illustrated above by our Lens Distortion example.

In the changes we regularly see the introduction of 2 fields:

- `screenCoordScaleBias` holds the scale and bias used to transform screen space coordinates.
- `screenSizeOverride` holds the screen size (and its reciprocal) to be used in conjunction with transformed screen
  space coordinates.

---
### Changes Overview

* #### SRP Core
    - `ScreenCoordOverrideUtils` -> basic utilities to manage the shader keyword. Main point is to avoid the duplication of
      the shader keyword.
    - `ScreenCoordOverride.hlsl` -> shader code and macros to perform the screen space coordinates conversion.

* #### HDRP
    - `FrameSettings` -> add `ScreenCoordOverride` and `AsymmetricProjection` settings. `AsymmetricProjection` allows the
      activation of the asymmetric projection code path even when XR is not enabled. This is useful for Cluster Display.
    - `HDAdditionalCameraData` -> add the `ScreenSizeOverride` and `ScreenCoordScaleBias` fields.
    - `ShaderVariablesGlobal` -> add the `ScreenSizeOverride` and `ScreenCoordScaleBias` fields.
    - `HDCamera` -> update global shader variables.
    - `HDRenderPipeline` -> activates the shader keyword.
    - `HDRenderPipeline.PostProcess` -> activates the shader keyword based on frame settings.
    - `UberPost.compute` -> add SCO support.

* #### URP
    - `ScriptableRenderer` -> fix a swap buffer issue (first
      fixed [here](#6522))
    - `PostProcessUtils` -> init random generation using frame count so that it's consistent across machines in a Cluster
      Display scenario.
    - `UniversalAdditionalCameraData` -> add the `ScreenSizeOverride` and `ScreenCoordScaleBias` fields and feature
      activation.
    - `UniversalRenderPipeline` -> populate additional camera data.
    - `UniversalRenderPipelineCore` -> add fields and associated shader properties.
    - `UniversalRenderer` -> related to swap buffer fix.
    - `Input.hlsl` -> add the `ScreenSizeOverride` and `ScreenCoordScaleBias` fields.
    - `FinalPost.shader` -> add SCO support.
    - `UberPost.shader` -> add SCO support.
    - `CapturePass` -> fixed color buffer access (before, post effects would not be captured)
    - `UniversalRenderPipelineGlobalSettings` -> add shader stripping option (`SerializedUniversalRenderPipelineGlobalSettings`, `UniversalRenderPipelineGlobalSettingsUI.Drawers` and `UniversalRenderPipelineGlobalSettingsUI.Skin` were modified to reflect this change)
    - `ShaderPreprocessor` -> implement shader stripping option

Author: etienne-p

Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.hlsl

@@ -0,0 +1,25 @@
+#ifndef UNITY_SCREEN_COORD_OVERRIDE_INCLUDED
+#define UNITY_SCREEN_COORD_OVERRIDE_INCLUDED
+
+float2 ScreenCoordApplyScaleBias(float2 xy, float4 screenCoordScaleBias)
+{
+    return screenCoordScaleBias.zw + xy * screenCoordScaleBias.xy;
+}
+
+float2 ScreenCoordRemoveScaleBias(float2 xy, float4 screenCoordScaleBias)
+{
+    return (xy - screenCoordScaleBias.zw) / screenCoordScaleBias.xy;
+}
+
+// Note that SCREEN_SIZE_OVERRIDE will be redefined in HDRP to use _PostProcessScreenSize.
+#if defined(SCREEN_COORD_OVERRIDE)
+    #define SCREEN_COORD_APPLY_SCALEBIAS(xy)          ScreenCoordApplyScaleBias(xy, _ScreenCoordScaleBias)
+    #define SCREEN_COORD_REMOVE_SCALEBIAS(xy)         ScreenCoordRemoveScaleBias(xy, _ScreenCoordScaleBias)
+    #define SCREEN_SIZE_OVERRIDE                     _ScreenSizeOverride
+#else
+    #define SCREEN_COORD_APPLY_SCALEBIAS(xy)          xy
+    #define SCREEN_COORD_REMOVE_SCALEBIAS(xy)         xy
+    #define SCREEN_SIZE_OVERRIDE                     _ScreenSize
+#endif
+
+#endif // UNITY_SCREEN_COORD_OVERRIDE_INCLUDED

Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.hlsl.meta

@@ -241,6 +241,16 @@ These settings determine the method that the Cameras and Reflection Probes using
     <td></td>
     <td>Select which material quality level to use when rendering from this Camera.<br>•From <strong>Quality Settings</strong>: The Camera uses the <strong>Material Quality Level</strong> property from your Unity Project's <strong>Quality Settings</strong>. To change this value, open the <strong>Project Settings</strong> window (menu: <strong>Edit</strong> &gt; <strong>Project Settings</strong>…), go to <strong>Quality</strong> &gt; <strong>HDRP</strong> &gt; <strong>Rendering</strong> and set the <strong>Material Quality Level</strong> to the value you want.</td>
   </tr>
+  <tr>
+    <td><strong>Asymmetric Projection</strong></td>
+    <td></td>
+    <td>Enable the checkbox to allow HDRP to account for asymmetric projection when evaluating the view direction based on pixel coordinates.</td>
+  </tr>
+    <tr>
+    <td><strong>Screen Coordinates Override</strong></td>
+    <td></td>
+    <td>Enable the checkbox to allow HDRP to use Screen Coordinates Override for post processing and custom passes. This allows post effects to be compatible with Cluster Display for example.</td>
+  </tr>
 </tbody>
 </table>
 

Packages/com.unity.render-pipelines.high-definition/Documentation~/Frame-Settings.md

@@ -6,6 +6,7 @@ Shader "Hidden/HDRP/FinalPass"
         #pragma editor_sync_compilation
         #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
 
+        #pragma multi_compile_fragment _ SCREEN_COORD_OVERRIDE
         #pragma multi_compile_local_fragment _ FXAA
         #pragma multi_compile_local_fragment _ GRAIN
         #pragma multi_compile_local_fragment _ DITHER
@@ -18,6 +19,7 @@ Shader "Hidden/HDRP/FinalPass"
 
         #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
         #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.hlsl"
         #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
         #include "Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/FXAA.hlsl"
         #include "Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/PostProcessDefines.hlsl"
@@ -143,7 +145,7 @@ Shader "Hidden/HDRP/FinalPass"
             #if GRAIN
             {
                 // Grain in range [0;1] with neutral at 0.5
-                float grain = SAMPLE_TEXTURE2D(_GrainTexture, s_linear_repeat_sampler, (positionNDC * _GrainTextureParams.xy) + _GrainTextureParams.zw).w;
+                float grain = SAMPLE_TEXTURE2D(_GrainTexture, s_linear_repeat_sampler, (SCREEN_COORD_APPLY_SCALEBIAS(positionNDC) * _GrainTextureParams.xy) + _GrainTextureParams.zw).w;
 
                 // Remap [-1;1]
                 grain = (grain - 0.5) * 2.0;

Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/FinalPass.shader

@@ -1,13 +1,16 @@
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl"
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ScreenCoordOverride.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/UberPostFeatures.cs.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/BloomCommon.hlsl"
 #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
 
 #pragma kernel Uber
 
+#pragma multi_compile _ SCREEN_COORD_OVERRIDE
 #pragma multi_compile _ CHROMATIC_ABERRATION
 #pragma multi_compile _ VIGNETTE
 #pragma multi_compile _ LENS_DISTORTION
@@ -118,7 +121,7 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
 {
     UNITY_XR_ASSIGN_VIEW_INDEX(dispatchThreadId.z);
     PositionInputs posInputs = GetPositionInput(float2(dispatchThreadId.xy), _PostProcessScreenSize.zw, uint2(GROUP_SIZE, GROUP_SIZE));
-    float2 uv = posInputs.positionNDC;
+    float2 uv = SCREEN_COORD_APPLY_SCALEBIAS(posInputs.positionNDC.xy);
     float2 uvDistorted = DistortUV(uv);
     CTYPE color = 0.0;
     CTYPE inputColor = 0.0;
@@ -130,15 +133,15 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
     float2 coords = 2.0 * uv - 1.0;
     float2 end = uv - coords * dot(coords, coords) * ChromaAmount;
     float2 diff = end - uv;
-    int samples = clamp(int(length(_PostProcessScreenSize.xy * diff / 2.0)), 3, ChromaMaxSamples);
+    int samples = clamp(int(length(SCREEN_SIZE_OVERRIDE.xy * diff / 2.0)), 3, ChromaMaxSamples);
     float2 delta = diff / samples;
     float2 pos = uv;
     float3 sum = 0.0, filterSum = 0.0;
 
     for (int i = 0; i < samples; i++)
     {
         float t = (i + 0.5) / samples;
-        float3 s = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(DistortUV(pos)), 0.0).xyz;
+        float3 s = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(SCREEN_COORD_REMOVE_SCALEBIAS(DistortUV(pos))), 0.0).xyz;
         float3 filter = SAMPLE_TEXTURE2D_LOD(_ChromaSpectralLut, sampler_ChromaSpectralLut, float2(t, 0.0), 0).xyz;
 
         sum += s * filter;
@@ -148,12 +151,12 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
 
     color.xyz = sum / filterSum;
 #ifdef ENABLE_ALPHA
-    inputColor = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(uvDistorted), 0.0);
+    inputColor = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted)), 0.0);
     color.w = inputColor.w;
 #endif
 
 #else
-    color = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(uvDistorted), 0.0).CTYPE_SWIZZLE;
+    color = SAMPLE_TEXTURE2D_X_LOD(_InputTexture, sampler_LinearClamp, ClampAndScaleUVForBilinearPostProcessTexture(SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted)), 0.0).CTYPE_SWIZZLE;
     inputColor = color;
 #endif
 
@@ -162,9 +165,9 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
     if (BloomEnabled)
     {
         #if 0 // Bilinear
-        float3 bloom = SAMPLE_TEXTURE2D_X_LOD(_BloomTexture, sampler_LinearClamp, ClampAndScaleUVForBilinear(uvDistorted), 0.0).xyz;
+        float3 bloom = SAMPLE_TEXTURE2D_X_LOD(_BloomTexture, sampler_LinearClamp, ClampAndScaleUVForBilinear(SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted)), 0.0).xyz;
         #else
-        float3 bloom = SampleTexture2DBicubic(TEXTURE2D_X_ARGS(_BloomTexture, sampler_LinearClamp), uvDistorted * _RTHandlePostProcessScale.xy, _BloomBicubicParams, _RTHandlePostProcessScale.xy, unity_StereoEyeIndex).xyz;
+        float3 bloom = SampleTexture2DBicubic(TEXTURE2D_X_ARGS(_BloomTexture, sampler_LinearClamp), SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted) * _RTHandlePostProcessScale.xy, _BloomBicubicParams, _RTHandlePostProcessScale.xy, unity_StereoEyeIndex).xyz;
         #endif
 
         float3 thresholdedColor = QuadraticThreshold(color.xyz, _BloomThreshold.x, _BloomThreshold.yzw);
@@ -176,7 +179,7 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
             // UVs for the dirt texture should be DistortUV(uv * DirtScale + DirtOffset) but
             // considering we use a cover-style scale on the dirt texture the difference isn't massive
             // so we chose to save a few ALUs here instead in case lens distortion is active
-            float3 dirt = SAMPLE_TEXTURE2D_LOD(_BloomDirtTexture, sampler_LinearClamp, uvDistorted * DirtScale + DirtOffset, 0.0).xyz;
+            float3 dirt = SAMPLE_TEXTURE2D_LOD(_BloomDirtTexture, sampler_LinearClamp, SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted) * DirtScale + DirtOffset, 0.0).xyz;
             color.xyz += bloom * dirt * DirtIntensity;
         }
 
@@ -193,14 +196,14 @@ void Uber(uint3 dispatchThreadId : SV_DispatchThreadID)
     if (VignetteMode == 0u) // Procedural
     {
         float2 d = abs(uvDistorted - VignetteCenter) * VignetteIntensity;
-        d.x *= lerp(1.0, _PostProcessScreenSize.x / _PostProcessScreenSize.y, VignetteRounded);
+        d.x *= lerp(1.0, SCREEN_SIZE_OVERRIDE.x / SCREEN_SIZE_OVERRIDE.y, VignetteRounded);
         d = pow(saturate(d), VignetteRoundness);
         float vfactor = pow(saturate(1.0 - dot(d, d)), VignetteSmoothness);
         color.xyz *= lerp(VignetteColor, (1.0).xxx, vfactor);
     }
     else // Masked
     {
-        float vfactor = SAMPLE_TEXTURE2D_LOD(_VignetteMask, sampler_VignetteMask, uvDistorted, 0).w;
+        float vfactor = SAMPLE_TEXTURE2D_LOD(_VignetteMask, sampler_VignetteMask, SCREEN_COORD_REMOVE_SCALEBIAS(uvDistorted), 0).w;
         vfactor = FastSRGBToLinear(vfactor);
         float3 newColor = color.xyz * lerp(VignetteColor, (1.0).xxx, vfactor);
         color.xyz = lerp(color.xyz, newColor, VignetteOpacity);

Packages/com.unity.render-pipelines.high-definition/Runtime/PostProcessing/Shaders/UberPost.compute

@@ -363,6 +363,12 @@ public enum TAAQualityLevel
         /// <summary>Enable to retain history buffers even if the camera is disabled.</summary>
         public bool hasPersistentHistory = false;
 
+        /// <summary>Screen size used when Screen Coordinates Override is active.</summary>
+        public Vector4 screenSizeOverride;
+
+        /// <summary>Transform used when Screen Coordinates Override is active.</summary>
+        public Vector4 screenCoordScaleBias;
+
         /// <summary>Allow NVIDIA Deep Learning Super Sampling (DLSS) on this camera.</summary>
         [Tooltip("Allow NVIDIA Deep Learning Super Sampling (DLSS) on this camera")]
         public bool allowDeepLearningSuperSampling = true;
@@ -637,6 +643,9 @@ public void CopyTo(HDAdditionalCameraData data)
 
             data.materialMipBias = materialMipBias;
 
+            data.screenSizeOverride = screenSizeOverride;
+            data.screenCoordScaleBias = screenCoordScaleBias;
+
             // We must not copy the following
             //data.m_IsDebugRegistered = m_IsDebugRegistered;
             //data.m_CameraRegisterName = m_CameraRegisterName;

Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDAdditionalCameraData.cs

@@ -1150,6 +1150,8 @@ unsafe internal void UpdateShaderVariablesGlobalCB(ref ShaderVariablesGlobal cb,
                 && antialiasing == AntialiasingMode.TemporalAntialiasing
                 && camera.cameraType == CameraType.Game;
 
+            var additionalCameraDataIsNull = m_AdditionalCameraData == null;
+
             cb._ViewMatrix = mainViewConstants.viewMatrix;
             cb._CameraViewMatrix = mainViewConstants.viewMatrix;
             cb._InvViewMatrix = mainViewConstants.invViewMatrix;
@@ -1206,13 +1208,18 @@ unsafe internal void UpdateShaderVariablesGlobalCB(ref ShaderVariablesGlobal cb,
             float exposureMultiplierForProbes = 1.0f / Mathf.Max(probeRangeCompressionFactor, 1e-6f);
             cb._ProbeExposureScale = exposureMultiplierForProbes;
 
-            cb._DeExposureMultiplier = m_AdditionalCameraData == null ? 1.0f : m_AdditionalCameraData.deExposureMultiplier;
+            cb._DeExposureMultiplier = additionalCameraDataIsNull ? 1.0f : m_AdditionalCameraData.deExposureMultiplier;
 
             // IMPORTANT NOTE: This checks if we have Movec and not Transparent Motion Vectors because in that case we need to write camera motion vectors
             // for transparent objects, otherwise the transparent objects will look completely broken upon motion if Transparent Motion Vectors is off.
             // If TransparentsWriteMotionVector the camera motion vectors are baked into the per object motion vectors.
             cb._TransparentCameraOnlyMotionVectors = (frameSettings.IsEnabled(FrameSettingsField.MotionVectors) &&
                 !frameSettings.IsEnabled(FrameSettingsField.TransparentsWriteMotionVector)) ? 1 : 0;
+
+            cb._ScreenSizeOverride = additionalCameraDataIsNull ? cb._ScreenSize : m_AdditionalCameraData.screenSizeOverride;
+
+            // Default to identity scale-bias.
+            cb._ScreenCoordScaleBias = additionalCameraDataIsNull ? new Vector4(1, 1, 0, 0) : m_AdditionalCameraData.screenCoordScaleBias;
         }
 
         unsafe internal void UpdateShaderVariablesXRCB(ref ShaderVariablesXR cb)
@@ -1850,8 +1857,8 @@ internal Matrix4x4 GetJitteredProjectionMatrix(Matrix4x4 origProj)
         /// <returns></returns>
         Matrix4x4 ComputePixelCoordToWorldSpaceViewDirectionMatrix(ViewConstants viewConstants, Vector4 resolution, float aspect = -1)
         {
-            // In XR mode, use a more generic matrix to account for asymmetry in the projection
-            var useGenericMatrix = xr.enabled;
+            // In XR mode, or if explicitely required, use a more generic matrix to account for asymmetry in the projection
+            var useGenericMatrix = xr.enabled || frameSettings.IsEnabled(FrameSettingsField.AsymmetricProjection);
 
             // Asymmetry is also possible from a user-provided projection, so we must check for it too.
             // Note however, that in case of physical camera, the lens shift term is the only source of

Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Camera/HDCamera.cs

@@ -148,6 +148,7 @@ public RTHandle Allocator(string id, int frameIndex, RTHandleSystem rtHandleSyst
         bool m_FilmGrainFS;
         bool m_DitheringFS;
         bool m_AntialiasingFS;
+        bool m_ScreenCoordOverride;
 
         // Debug Exposure compensation (Drive by debug menu) to add to all exposure processed value
         float m_DebugExposureCompensation;
@@ -357,6 +358,7 @@ void BeginPostProcessFrame(CommandBuffer cmd, HDCamera camera, HDRenderPipeline
             m_FilmGrainFS = frameSettings.IsEnabled(FrameSettingsField.FilmGrain) && m_PostProcessEnabled;
             m_DitheringFS = frameSettings.IsEnabled(FrameSettingsField.Dithering) && m_PostProcessEnabled;
             m_AntialiasingFS = frameSettings.IsEnabled(FrameSettingsField.Antialiasing) || camera.IsTAAUEnabled();
+            m_ScreenCoordOverride = frameSettings.IsEnabled(FrameSettingsField.ScreenCoordOverride) && m_PostProcessEnabled;
 
             // Override full screen anti-aliasing when doing path tracing (which is naturally anti-aliased already)
             m_AntialiasingFS &= !camera.IsPathTracingEnabled();
@@ -4648,6 +4650,12 @@ TextureHandle UberPass(RenderGraph renderGraph, HDCamera hdCamera, TextureHandle
                 passData.uberPostCS.shaderKeywords = null;
 
                 passData.uberPostKernel = passData.uberPostCS.FindKernel("Uber");
+
+                if (m_ScreenCoordOverride)
+                {
+                    passData.uberPostCS.EnableKeyword("SCREEN_COORD_OVERRIDE");
+                }
+
                 if (PostProcessEnableAlpha())
                 {
                     passData.uberPostCS.EnableKeyword("ENABLE_ALPHA");

Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.PostProcess.cs

@@ -1062,6 +1062,8 @@ void ConfigureKeywords(bool enableBakeShadowMask, HDCamera hdCamera, CommandBuff
 
                 // Raise or remove the depth msaa flag based on the frame setting
                 CoreUtils.SetKeyword(cmd, "WRITE_MSAA_DEPTH", hdCamera.msaaEnabled);
+
+                CoreUtils.SetKeyword(cmd, "SCREEN_COORD_OVERRIDE", hdCamera.frameSettings.IsEnabled(FrameSettingsField.ScreenCoordOverride));
             }
         }
 

Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.cs

@@ -159,6 +159,12 @@ public enum FrameSettingsField
         /// <summary>When enabled, Cameras using these Frame Settings render water surfaces.</summary>
         [FrameSettingsField(0, autoName: Water, customOrderInGroup: 106, tooltip: "When enabled, Cameras using these Frame Settings render water surfaces.")]
         Water = 99,
+        /// <summary>When enabled, HDRP accounts for asymmetry in the projection matrix when evaluating the view direction based on pixel coordinates.</summary>
+        [FrameSettingsField(0, displayedName: "Asymmetric Projection", customOrderInGroup: 107, tooltip: "When enabled HDRP will account for asymmetric projection when evaluating the view direction based on pixel coordinates.")]
+        AsymmetricProjection = 78,
+        /// <summary>When enabled, HDRP evaluates post effects using transformed screen space coordinates, this allows post effects to be compatible with Cluster Display for example.</summary>
+        [FrameSettingsField(0, displayedName: "Screen Coordinates Override", customOrderInGroup: 108, tooltip: "When enabled HDRP will use Screen Coordinates Override for post processing and custom passes. This allows post effects to be compatible with Cluster Display for example.")]
+        ScreenCoordOverride = 77,
 
         /// <summary>When enabled, HDRP processes a motion vector pass for Cameras using these Frame Settings.</summary>
         [FrameSettingsField(0, autoName: MotionVectors, customOrderInGroup: 12, tooltip: "When enabled, HDRP processes a motion vector pass for Cameras using these Frame Settings (Depends on \"Motion Vectors\" in current HDRP Asset).")]

Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Settings/FrameSettings.cs

@@ -0,0 +1,16 @@
+#ifndef UNITY_SCREEN_COORD_OVERRIDE_HDRP_INCLUDED
+#define UNITY_SCREEN_COORD_OVERRIDE_HDRP_INCLUDED
+
+#ifndef UNITY_SCREEN_COORD_OVERRIDE_INCLUDED
+    #error UNITY_SCREEN_COORD_OVERRIDE_INCLUDED not defined, you should include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ScreenCoordOverride.hlsl"
+#else
+    // We must redefine SCREEN_SIZE_OVERRIDE on HDRP to use _PostProcessScreenSize.
+    #undef SCREEN_SIZE_OVERRIDE
+    #if defined(SCREEN_COORD_OVERRIDE)
+        #define SCREEN_SIZE_OVERRIDE _ScreenSizeOverride
+    #else
+        #define SCREEN_SIZE_OVERRIDE _PostProcessScreenSize
+    #endif
+#endif
+
+#endif // UNITY_SCREEN_COORD_OVERRIDE_HDRP_INCLUDED

Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ScreenCoordOverride.hlsl

@@ -253,5 +253,9 @@ unsafe struct ShaderVariablesGlobal
         public float _GlobalTessellationFactorMultiplier;
         public float _SpecularOcclusionBlend;
         public float _DeExposureMultiplier;
+
+        // See ScreenCoordOverride.hlsl for details.
+        public Vector4 _ScreenSizeOverride;
+        public Vector4 _ScreenCoordScaleBias;
     }
 }

Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ScreenCoordOverride.hlsl.meta

@@ -146,6 +146,8 @@ GLOBAL_CBUFFER_START(ShaderVariablesGlobal, b0)
     float _GlobalTessellationFactorMultiplier;
     float _SpecularOcclusionBlend;
     float _DeExposureMultiplier;
+    float4 _ScreenSizeOverride;
+    float4 _ScreenCoordScaleBias;
 CBUFFER_END