Graphics/urp/alpha output

Post-processing alpha handling and output when the render target has an alpha channel and post-process alpha processing is enabled from the asset. The feature is opt-in.

URP alpha output semantics are similar to HDRP.

Enabled by toggling post-process alpha-processing from URPAsset->Post-Processing->Alpha Processing.
![image](https://media.github.cds.internal.unity3d.com/user/2125/files/243baf93-35d6-4d34-959a-c9af140cd841)
Alpha output is disabled by default to avoid regressions in existing projects.
If disabled, the alpha output shaders are stripped.

Alpha output warns if enabled, but the back-buffer format does not support alpha.
![image](https://media.github.cds.internal.unity3d.com/user/2125/files/ff56b253-13d6-433a-ad6f-b9c6f061f737)

Alpha output requires selecting a back-buffer format with alpha from URPAsset->Quality->HDR/HDR Precision.
![image](https://media.github.cds.internal.unity3d.com/user/2125/files/1bb561fb-1947-4a10-9725-d2dbb77c7da0)

| Setting       | Format.     |Alpha Output|
|------------|-----------|-------------|
| SDR 32-bit | RGBA8     | Yes               |
| HDR 32-bit | RGB11f     | No                |
| HDR 64-bit | RGBA16f  | Yes               |

[**URP-1586**](https://jira.unity3d.com/browse/URP-1586)
[**POI-1037**](https://jira.unity3d.com/browse/POI-1037)

Author: eh-unity

Packages/com.unity.render-pipelines.universal/Editor/ShaderBuildPreprocessor.cs

@@ -69,6 +69,7 @@ enum ShaderFeatures : long
         SoftShadowsLow = (1L << 46),
         SoftShadowsMedium = (1L << 47),
         SoftShadowsHigh = (1L << 48),
+        AlphaOutput = (1L << 49),
 
     }
 
@@ -453,6 +454,16 @@ internal static ShaderFeatures GetSupportedShaderFeaturesFromAsset(
             if (urpAsset.gpuResidentDrawerMode != GPUResidentDrawerMode.Disabled)
                 urpAssetShaderFeatures |= ShaderFeatures.UseLegacyLightmaps;
 
+            // URP post-processing and alpha output follows the back-buffer color format requested in the asset.
+            // Back-buffer alpha format is required. Or a render texture with alpha formats.
+            // Without any external option we would need to keep all shaders and assume potential alpha output for all projects.
+            // Therefore we strip the shader based on the asset enabling the alpha output for post-processing.
+            // Alpha backbuffer is supported for:
+            //   SDR 32-bit, RGBA8, (!urpAsset.supportsHDR)
+            //   HDR 64-bit, RGBA16Float, (urpAsset.supportsHDR && urpAsset.hdrColorBufferPrecision == HDRColorBufferPrecision._64Bits)
+            if(urpAsset.allowPostProcessAlphaOutput)
+                urpAssetShaderFeatures |= ShaderFeatures.AlphaOutput;
+
             // Check each renderer & renderer feature
             urpAssetShaderFeatures = GetSupportedShaderFeaturesFromRenderers(
                 ref urpAsset,
@@ -856,6 +867,7 @@ ref List<ScreenSpaceAmbientOcclusionSettings> ssaoRendererFeatures
             spd.stripSoftShadowsQualityMedium = !IsFeatureEnabled(shaderFeatures, ShaderFeatures.SoftShadowsMedium);
             spd.stripSoftShadowsQualityHigh = !IsFeatureEnabled(shaderFeatures, ShaderFeatures.SoftShadowsHigh);
             spd.stripHDRKeywords = stripHDR;
+            spd.stripAlphaOutputKeywords = !IsFeatureEnabled(shaderFeatures, ShaderFeatures.AlphaOutput);
             spd.stripDebugDisplay = stripDebug;
             spd.stripScreenCoordOverride = stripScreenCoord;
 

Packages/com.unity.render-pipelines.universal/Editor/UniversalRenderPipelineAsset/SerializedUniversalRenderPipelineAsset.cs

@@ -78,6 +78,7 @@ internal class SerializedUniversalRenderPipelineAsset
 
         public SerializedProperty colorGradingMode { get; }
         public SerializedProperty colorGradingLutSize { get; }
+        public SerializedProperty allowPostProcessAlphaOutput { get; }
         public SerializedProperty useFastSRGBLinearConversion { get; }
         public SerializedProperty supportDataDrivenLensFlare { get; }
         public SerializedProperty supportScreenSpaceLensFlare { get; }
@@ -172,6 +173,7 @@ public SerializedUniversalRenderPipelineAsset(SerializedObject serializedObject)
             colorGradingMode = serializedObject.FindProperty("m_ColorGradingMode");
             colorGradingLutSize = serializedObject.FindProperty("m_ColorGradingLutSize");
 
+            allowPostProcessAlphaOutput = serializedObject.FindProperty("m_AllowPostProcessAlphaOutput");
             useFastSRGBLinearConversion = serializedObject.FindProperty("m_UseFastSRGBLinearConversion");
             supportDataDrivenLensFlare = serializedObject.FindProperty("m_SupportDataDrivenLensFlare");
             supportScreenSpaceLensFlare = serializedObject.FindProperty("m_SupportScreenSpaceLensFlare");

Packages/com.unity.render-pipelines.universal/Editor/UniversalRenderPipelineAsset/UniversalRenderPipelineAssetUI.Drawers.cs

@@ -617,6 +617,12 @@ static void DrawPostProcessing(SerializedUniversalRenderPipelineAsset serialized
             if (isHdrOn && serialized.colorGradingMode.intValue == (int)ColorGradingMode.HighDynamicRange && serialized.colorGradingLutSize.intValue < 32)
                 EditorGUILayout.HelpBox(Styles.colorGradingLutSizeWarning, MessageType.Warning);
 
+            HDRColorBufferPrecision hdrPrecision = (HDRColorBufferPrecision)serialized.hdrColorBufferPrecisionProp.intValue;
+            bool alphaEnabled = !isHdrOn /*RGBA8*/ || (isHdrOn && hdrPrecision == HDRColorBufferPrecision._64Bits); /*RGBA16Float*/
+            EditorGUILayout.PropertyField(serialized.allowPostProcessAlphaOutput, Styles.allowPostProcessAlphaOutput);
+            if(!alphaEnabled && serialized.allowPostProcessAlphaOutput.boolValue)
+                EditorGUILayout.HelpBox(Styles.alphaOutputWarning, MessageType.Warning);
+
             EditorGUILayout.PropertyField(serialized.useFastSRGBLinearConversion, Styles.useFastSRGBLinearConversion);
             EditorGUILayout.PropertyField(serialized.supportDataDrivenLensFlare, Styles.supportDataDrivenLensFlare);
             EditorGUILayout.PropertyField(serialized.supportScreenSpaceLensFlare, Styles.supportScreenSpaceLensFlare);

Packages/com.unity.render-pipelines.universal/Editor/UniversalRenderPipelineAsset/UniversalRenderPipelineAssetUI.Skin.cs

@@ -108,9 +108,11 @@ internal static class Styles
             // Post-processing
             public static GUIContent colorGradingMode = EditorGUIUtility.TrTextContent("Grading Mode", "Defines how color grading will be applied. Operators will react differently depending on the mode.");
             public static GUIContent colorGradingLutSize = EditorGUIUtility.TrTextContent("LUT size", "Sets the size of the internal and external color grading lookup textures (LUTs).");
+            public static GUIContent allowPostProcessAlphaOutput = EditorGUIUtility.TrTextContent("Alpha Processing", "When enabled, post-processing outputs alpha channel if available. Alpha 0 preserves the original color. Otherwise post-processing applies to the alpha channel as well. Results may vary depending on the effect.");
             public static GUIContent useFastSRGBLinearConversion = EditorGUIUtility.TrTextContent("Fast sRGB/Linear conversions", "Use faster, but less accurate approximation functions when converting between the sRGB and Linear color spaces.");
             public static GUIContent supportDataDrivenLensFlare = EditorGUIUtility.TrTextContent("Data Driven Lens Flare", "When enabled, URP allocates shader variants and memory for Data Driven Lens Flare effect.");
             public static GUIContent supportScreenSpaceLensFlare = EditorGUIUtility.TrTextContent("Screen Space Lens Flare", "When enabled, URP allocates shader variants and memory for Screen Space Lens Flare effect.");
+            public static string alphaOutputWarning = "Camera back-buffer format does not support alpha channel. Final output will be opaque.";
             public static string colorGradingModeWarning = "HDR rendering is required to use the high dynamic range color grading mode. The low dynamic range will be used instead.";
             public static string colorGradingModeWithHDROutput = "With the current configuration, Unity uses the HDR color grading mode when outputting to an HDR display.";
             public static string colorGradingModeSpecInfo = "The high dynamic range color grading mode works best on platforms that support floating point textures.";

Packages/com.unity.render-pipelines.universal/Runtime/2D/Renderer2D.cs

@@ -94,7 +94,7 @@ public Renderer2D(Renderer2DData data) : base(data)
 
             var ppParams = PostProcessParams.Create();
             ppParams.blitMaterial = m_BlitMaterial;
-            ppParams.requestHDRFormat = GraphicsFormat.B10G11R11_UFloatPack32;
+            ppParams.requestColorFormat = GraphicsFormat.B10G11R11_UFloatPack32;
             m_PostProcessPasses = new PostProcessPasses(data.postProcessData, ref ppParams);
 
             m_UseDepthStencilBuffer = data.useDepthStencilBuffer;

Packages/com.unity.render-pipelines.universal/Runtime/Data/UniversalRenderPipelineAsset.cs

@@ -598,6 +598,10 @@ public partial class UniversalRenderPipelineAsset : RenderPipelineAsset<Universa
         // Post-processing settings
         [SerializeField] ColorGradingMode m_ColorGradingMode = ColorGradingMode.LowDynamicRange;
         [SerializeField] int m_ColorGradingLutSize = 32;
+#if UNITY_EDITOR // multi_compile_fragment _ _ENABLE_ALPHA_OUTPUT
+        [ShaderKeywordFilter.SelectOrRemove(true, keywordNames: ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT)]
+#endif
+        [SerializeField] bool m_AllowPostProcessAlphaOutput = false;
 #if UNITY_EDITOR // multi_compile_local_fragment _ _USE_FAST_SRGB_LINEAR_CONVERSION
         [ShaderKeywordFilter.SelectOrRemove(true, keywordNames: ShaderKeywordStrings.UseFastSRGBLinearConversion)]
 #endif
@@ -1584,6 +1588,11 @@ public int colorGradingLutSize
             set => m_ColorGradingLutSize = Mathf.Clamp(value, k_MinLutSize, k_MaxLutSize);
         }
 
+        /// <summary>
+        /// Returns true if post-processing should process and output alpha. Requires the color target to have an alpha channel.
+        /// </summary>
+        public bool allowPostProcessAlphaOutput => m_AllowPostProcessAlphaOutput;
+
         /// <summary>
         /// Returns true if fast approximation functions are used when converting between the sRGB and Linear color spaces, false otherwise.
         /// </summary>

Packages/com.unity.render-pipelines.universal/Runtime/Data/UniversalRenderPipelineAssetPrefiltering.cs

@@ -118,6 +118,10 @@ internal enum PrefilteringModeAdditionalLights
         })]
         [SerializeField] private bool m_PrefilterHDROutput = false;
 
+        // Alpha Output
+        [ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT)]
+        [SerializeField] private bool m_PrefilterAlphaOutput = false;
+
         // Screen Space Ambient Occlusion (SSAO) specific keywords
         [ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SourceDepthNormalsKeyword)]
         [SerializeField] private bool m_PrefilterSSAODepthNormals = false;
@@ -193,6 +197,7 @@ internal struct ShaderPrefilteringData
 
             public bool stripXRKeywords;
             public bool stripHDRKeywords;
+            public bool stripAlphaOutputKeywords;
             public bool stripDebugDisplay;
             public bool stripScreenCoordOverride;
             public bool stripWriteRenderingLayers;
@@ -231,6 +236,7 @@ internal void UpdateShaderKeywordPrefiltering(ref ShaderPrefilteringData prefilt
 
             m_PrefilterXRKeywords                    = prefilteringData.stripXRKeywords;
             m_PrefilterHDROutput                     = prefilteringData.stripHDRKeywords;
+            m_PrefilterAlphaOutput                   = prefilteringData.stripAlphaOutputKeywords;
             m_PrefilterDebugKeywords                 = prefilteringData.stripDebugDisplay;
             m_PrefilterWriteRenderingLayers          = prefilteringData.stripWriteRenderingLayers;
             m_PrefilterScreenCoord                   = prefilteringData.stripScreenCoordOverride;

Packages/com.unity.render-pipelines.universal/Runtime/FrameData/UniversalCameraData.cs

@@ -220,6 +220,11 @@ internal Matrix4x4 GetGPUProjectionMatrix(bool renderIntoTexture, int viewIndex
         /// </summary>
         public bool allowHDROutput;
 
+        /// <summary>
+        /// True if this camera can write the alpha channel. Post-processing uses this. Requires the color target to have an alpha channel.
+        /// </summary>
+        public bool isAlphaOutputEnabled;
+
         /// <summary>
         /// True if this camera requires to write _CameraDepthTexture.
         /// </summary>
@@ -604,6 +609,7 @@ public override void Reset()
             isDefaultViewport = false;
             isHdrEnabled = false;
             allowHDROutput = false;
+            isAlphaOutputEnabled = false;
             requiresDepthTexture = false;
             requiresOpaqueTexture = false;
             postProcessingRequiresDepthTexture = false;

Packages/com.unity.render-pipelines.universal/Runtime/Passes/FinalBlitPass.cs

@@ -127,7 +127,8 @@ public override void Execute(ScriptableRenderContext context, ref RenderingData
             UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
 
             bool outputsToHDR = renderingData.cameraData.isHDROutputActive;
-            InitPassData(cameraData, ref m_PassData, outputsToHDR ? BlitType.HDR : BlitType.Core);
+            bool outputsAlpha = false;
+            InitPassData(cameraData, ref m_PassData, outputsToHDR ? BlitType.HDR : BlitType.Core, outputsAlpha);
 
             if (m_PassData.blitMaterialData.material == null)
             {
@@ -232,6 +233,8 @@ private static void ExecutePass(RasterCommandBuffer cmd, PassData data, RTHandle
             // we never want them to show up as wireframe
             cmd.SetWireframe(false);
 
+            CoreUtils.SetKeyword(data.blitMaterialData.material, ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT, data.enableAlphaOutput);
+
             int shaderPassIndex = source.rt?.filterMode == FilterMode.Bilinear ? data.blitMaterialData.bilinearSamplerPass : data.blitMaterialData.nearestSamplerPass;
             Blitter.BlitTexture(cmd, source, scaleBias, data.blitMaterialData.material, shaderPassIndex);
         }
@@ -243,6 +246,7 @@ private class PassData
             internal int sourceID;
             internal Vector4 hdrOutputLuminanceParams;
             internal bool requireSrgbConversion;
+            internal bool enableAlphaOutput;
             internal BlitMaterialData blitMaterialData;
             internal UniversalCameraData cameraData;
         }
@@ -251,10 +255,11 @@ private class PassData
         /// Initialize the shared pass data.
         /// </summary>
         /// <param name="passData"></param>
-        private void InitPassData(UniversalCameraData cameraData, ref PassData passData, BlitType blitType)
+        private void InitPassData(UniversalCameraData cameraData, ref PassData passData, BlitType blitType, bool enableAlphaOutput)
         {
             passData.cameraData = cameraData;
             passData.requireSrgbConversion = cameraData.requireSrgbConversion;
+            passData.enableAlphaOutput = enableAlphaOutput;
 
             passData.blitMaterialData = m_BlitMaterialData[(int)blitType];
         }
@@ -273,7 +278,8 @@ internal void Render(RenderGraph renderGraph, UniversalCameraData cameraData, in
                 }
 
                 bool outputsToHDR = cameraData.isHDROutputActive;
-                InitPassData(cameraData, ref passData, outputsToHDR ? BlitType.HDR : BlitType.Core);
+                bool outputsAlpha = cameraData.isAlphaOutputEnabled;
+                InitPassData(cameraData, ref passData, outputsToHDR ? BlitType.HDR : BlitType.Core, outputsAlpha);
 
                 passData.sourceID = ShaderPropertyId.sourceTex;
                 passData.source = src;