Added a "keep alpha" mode to FXAA

Author: Chman

PostProcessing/Editor/PostProcessLayerEditor.cs

@@ -24,6 +24,7 @@ public sealed class PostProcessLayerEditor : BaseEditor<PostProcessLayer>
         SerializedProperty m_TaaStationaryBlending;
         SerializedProperty m_TaaMotionBlending;
         SerializedProperty m_FxaaMobileOptimized;
+        SerializedProperty m_FxaaKeepAlpha;
 
         SerializedProperty m_AOEnabled;
         SerializedProperty m_AOIntensity;
@@ -68,6 +69,7 @@ void OnEnable()
             m_TaaStationaryBlending = FindProperty(x => x.temporalAntialiasing.stationaryBlending);
             m_TaaMotionBlending = FindProperty(x => x.temporalAntialiasing.motionBlending);
             m_FxaaMobileOptimized = FindProperty(x => x.fastApproximateAntialiasing.mobileOptimized);
+            m_FxaaKeepAlpha = FindProperty(x => x.fastApproximateAntialiasing.keepAlpha);
 
             m_AOEnabled = FindProperty(x => x.ambientOcclusion.enabled);
             m_AOIntensity = FindProperty(x => x.ambientOcclusion.intensity);
@@ -203,6 +205,7 @@ void DoAntialiasing()
                 else if (m_AntialiasingMode.intValue == (int)PostProcessLayer.Antialiasing.FastApproximateAntialiasing)
                 {
                     EditorGUILayout.PropertyField(m_FxaaMobileOptimized);
+                    EditorGUILayout.PropertyField(m_FxaaKeepAlpha);
                 }
             }
             EditorGUI.indentLevel--;

PostProcessing/Runtime/Effects/FastApproximateAntialiasing.cs

@@ -7,5 +7,8 @@ public sealed class FastApproximateAntialiasing
     {
         [Tooltip("Boost performances by lowering the effect quality. This settings is meant to be used on mobile and other low-end platforms.")]
         public bool mobileOptimized = false;
+
+        [Tooltip("Keep alpha channel. This will slightly lower the effect quality but allows rendering against a transparent background.")]
+        public bool keepAlpha = false;
     }
 }

PostProcessing/Runtime/PostProcessLayer.cs

@@ -684,6 +684,10 @@ int RenderBuiltins(PostProcessRenderContext context, bool isFinalPass, int relea
                 tempTarget = m_TargetPool.Get();
                 cmd.GetTemporaryRT(tempTarget, context.width, context.height, 24, FilterMode.Bilinear, context.sourceFormat);
                 context.destination = tempTarget;
+
+                // Handle FXAA's keep alpha mode
+                if (antialiasingMode == Antialiasing.FastApproximateAntialiasing && !fastApproximateAntialiasing.keepAlpha)
+                    uberSheet.properties.SetFloat(ShaderIDs.LumaInAlpha, 1f);
             }
 
             // Depth of field final combination pass used to be done in Uber which led to artifacts
@@ -761,6 +765,9 @@ void RenderFinalPass(PostProcessRenderContext context, int releaseTargetAfterUse
                         ? "FXAA_LOW"
                         : "FXAA"
                     );
+
+                    if (fastApproximateAntialiasing.keepAlpha)
+                        uberSheet.EnableKeyword("FXAA_KEEP_ALPHA");
                 }
                 else if (antialiasingMode == Antialiasing.SubpixelMorphologicalAntialiasing && subpixelMorphologicalAntialiasing.IsSupported())
                 {

PostProcessing/Runtime/Utils/ShaderIDs.cs

@@ -93,6 +93,8 @@ static class ShaderIDs
         internal static readonly int GrainTex                        = Shader.PropertyToID("_GrainTex");
         internal static readonly int Phase                           = Shader.PropertyToID("_Phase");
 
+        internal static readonly int LumaInAlpha                     = Shader.PropertyToID("_LumaInAlpha");
+
         internal static readonly int DitheringTex                    = Shader.PropertyToID("_DitheringTex");
         internal static readonly int Dithering_Coords                = Shader.PropertyToID("_Dithering_Coords");
 

PostProcessing/Shaders/Builtins/FinalPass.shader

@@ -4,15 +4,21 @@ Shader "Hidden/PostProcessing/FinalPass"
 
         #pragma multi_compile __ UNITY_COLORSPACE_GAMMA
         #pragma multi_compile __ FXAA FXAA_LOW
+        #pragma multi_compile __ FXAA_KEEP_ALPHA
         #include "../StdLib.hlsl"
         #include "../Colors.hlsl"
         #include "Dithering.hlsl"
 
         // PS3 and XBOX360 aren't supported in Unity anymore, only use the PC variant
         #define FXAA_PC 1
 
-        // Luma is encoded in alpha after the first Uber pass
-        #define FXAA_GREEN_AS_LUMA 0
+        #if FXAA_KEEP_ALPHA
+            // Luma hasn't been encoded in alpha
+            #define FXAA_GREEN_AS_LUMA 1
+        #else
+            // Luma is encoded in alpha after the first Uber pass
+            #define FXAA_GREEN_AS_LUMA 0
+        #endif
 
         #if FXAA_LOW
             #define FXAA_QUALITY__PRESET 28
@@ -65,6 +71,12 @@ Shader "Hidden/PostProcessing/FinalPass"
                     0.0,                        // fxaaConsoleEdgeThresholdMin (unused)
                     0.0                         // fxaaConsole360ConstDir (unused)
                 );
+
+                #if FXAA_KEEP_ALPHA
+                {
+                    color.a = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uvSPR).a;
+                }
+                #endif
             }
             #else
             {

PostProcessing/Shaders/Builtins/Uber.shader

@@ -64,6 +64,9 @@ Shader "Hidden/PostProcessing/Uber"
         half2 _Grain_Params1; // x: lum_contrib, y: intensity
         float4 _Grain_Params2; // x: xscale, h: yscale, z: xoffset, w: yoffset
 
+        // Misc
+        half _LumaInAlpha;
+
         half4 FragUber(VaryingsDefault i) : SV_Target
         {
             float2 uv = i.texcoord;
@@ -170,8 +173,8 @@ Shader "Hidden/PostProcessing/Uber"
                     }
                     #endif
 
-                    half3 new_color = color * lerp(_Vignette_Color, (1.0).xxx, vfactor);
-                    color.rgb = lerp(color, new_color, _Vignette_Opacity);
+                    half3 new_color = color.rgb * lerp(_Vignette_Color, (1.0).xxx, vfactor);
+                    color.rgb = lerp(color.rgb, new_color, _Vignette_Opacity);
                     color.a = lerp(1.0, color.a, vfactor);
                 }
             }
@@ -202,19 +205,21 @@ Shader "Hidden/PostProcessing/Uber"
             }
             #endif
 
-            half4 output;
+            half4 output = color;
 
             #if FINALPASS
             {
-                color.rgb = Dither(color.rgb, i.texcoord);
-                output = color;
+                output.rgb = Dither(output.rgb, i.texcoord);
             }
             #else
             {
-                // Put saturated luma in alpha for FXAA - higher quality than "green as luma" and
-                // necessary as RGB values will potentially still be HDR for the FXAA pass
-                half luma = Luminance(saturate(color));
-                output = half4(color.rgb, luma);
+                if (_LumaInAlpha > 0.5)
+                {
+                    // Put saturated luma in alpha for FXAA - higher quality than "green as luma" and
+                    // necessary as RGB values will potentially still be HDR for the FXAA pass
+                    half luma = Luminance(saturate(output));
+                    output.a = luma;
+                }
             }
             #endif