Added lens distortion effect

Author: Chman

PostProcessing/Editor/Effects/LensDistortionEditor.cs

@@ -0,0 +1,16 @@
+using UnityEngine.Rendering.PostProcessing;
+
+namespace UnityEditor.Rendering.PostProcessing
+{
+    [PostProcessEditor(typeof(LensDistortion))]
+    public sealed class LensDistortionEditor : DefaultPostProcessEffectEditor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (RuntimeUtilities.isVREnabled)
+                EditorGUILayout.HelpBox("Lens Distortion is automatically disabled when VR is enabled.", MessageType.Warning);
+
+            base.OnInspectorGUI();
+        }
+    }
+}

PostProcessing/Editor/Effects/LensDistortionEditor.cs.meta

@@ -0,0 +1,55 @@
+using System;
+
+namespace UnityEngine.Rendering.PostProcessing
+{
+    [Serializable]
+    [PostProcess(typeof(LensDistortionRenderer), "Unity/Lens Distortion")]
+    public sealed class LensDistortion : PostProcessEffectSettings
+    {
+        [Range(-100f, 100f), Tooltip("Total distortion amount.")]
+        public FloatParameter intensity = new FloatParameter { value = 0f };
+
+        [Range(0f, 1f), DisplayName("Y Multiplier"), Tooltip("Intensity multiplier on X axis. Set it to 0 to disable distortion on this axis.")]
+        public FloatParameter intensityX = new FloatParameter { value = 1f };
+
+        [Range(0f, 1f), DisplayName("X Multiplier"), Tooltip("Intensity multiplier on Y axis. Set it to 0 to disable distortion on this axis.")]
+        public FloatParameter intensityY = new FloatParameter { value = 1f };
+
+        [Space]
+        [Range(-1f, 1f), Tooltip("Distortion center point (X axis).")]
+        public FloatParameter centerX = new FloatParameter { value = 0f };
+
+        [Range(-1f, 1f), Tooltip("Distortion center point (Y axis).")]
+        public FloatParameter centerY = new FloatParameter { value = 0f };
+
+        [Space]
+        [Range(0.01f, 5f), Tooltip("Global screen scaling.")]
+        public FloatParameter scale = new FloatParameter { value = 1f };
+
+        public override bool IsEnabledAndSupported(PostProcessRenderContext context)
+        {
+            return enabled.value
+                && !Mathf.Approximately(intensity, 0f)
+                && (intensityX > 0f || intensityY > 0f)
+                && !RuntimeUtilities.isVREnabled;
+        }
+    }
+
+    public sealed class LensDistortionRenderer : PostProcessEffectRenderer<LensDistortion>
+    {
+        public override void Render(PostProcessRenderContext context)
+        {
+            var sheet = context.uberSheet;
+            
+            float amount = 1.6f * Math.Max(Mathf.Abs(settings.intensity.value), 1f);
+            float theta = Mathf.Deg2Rad * Math.Min(160f, amount);
+            float sigma = 2f * Mathf.Tan(theta * 0.5f);
+            var p0 = new Vector4(settings.centerX.value, settings.centerY.value, Mathf.Max(settings.intensityX.value, 1e-4f), Mathf.Max(settings.intensityY.value, 1e-4f));
+            var p1 = new Vector4(settings.intensity.value >= 0f ? theta : 1f / theta, sigma, 1f / settings.scale.value, settings.intensity.value);
+
+            sheet.EnableKeyword("DISTORT");
+            sheet.properties.SetVector(ShaderIDs.Distortion_CenterScale, p0);
+            sheet.properties.SetVector(ShaderIDs.Distortion_Amount, p1);
+        }
+    }
+}

PostProcessing/Runtime/Effects/LensDistortion.cs

@@ -839,6 +839,7 @@ int RenderBuiltins(PostProcessRenderContext context, bool isFinalPass, int relea
             RenderEffect<AutoExposure>(context);
             uberSheet.properties.SetTexture(ShaderIDs.AutoExposureTex, context.autoExposureTexture);
 
+            RenderEffect<LensDistortion>(context);
             RenderEffect<ChromaticAberration>(context);
             RenderEffect<Bloom>(context);
             RenderEffect<Vignette>(context);

PostProcessing/Runtime/Effects/LensDistortion.cs.meta

@@ -93,6 +93,9 @@ static class ShaderIDs
         internal static readonly int ChromaticAberration_Amount      = Shader.PropertyToID("_ChromaticAberration_Amount");
         internal static readonly int ChromaticAberration_SpectralLut = Shader.PropertyToID("_ChromaticAberration_SpectralLut");
 
+        internal static readonly int Distortion_CenterScale          = Shader.PropertyToID("_Distortion_CenterScale");
+        internal static readonly int Distortion_Amount               = Shader.PropertyToID("_Distortion_Amount");
+
         internal static readonly int Lut2D                           = Shader.PropertyToID("_Lut2D");
         internal static readonly int Lut3D                           = Shader.PropertyToID("_Lut3D");
         internal static readonly int Lut3D_Params                    = Shader.PropertyToID("_Lut3D_Params");

PostProcessing/Runtime/PostProcessLayer.cs

@@ -0,0 +1,34 @@
+#ifndef UNITY_POSTFX_DISTORTION
+#define UNITY_POSTFX_DISTORTION
+
+float4 _Distortion_Amount;
+float4 _Distortion_CenterScale;
+
+float2 Distort(float2 uv)
+{
+    // Note: lens distortion is automatically disabled in VR so we won't bother handling stereo uvs
+    #if DISTORT
+    {
+        uv = (uv - 0.5) * _Distortion_Amount.z + 0.5;
+        float2 ruv = _Distortion_CenterScale.zw * (uv - 0.5 - _Distortion_CenterScale.xy);
+        float ru = length(float2(ruv));
+
+        UNITY_BRANCH
+        if (_Distortion_Amount.w > 0.0)
+        {
+            float wu = ru * _Distortion_Amount.x;
+            ru = tan(wu) * (1.0 / (ru * _Distortion_Amount.y));
+            uv = uv + ruv * (ru - 1.0);
+        }
+        else
+        {
+            ru = (1.0 / ru) * _Distortion_Amount.x * atan(ru * _Distortion_Amount.y);
+            uv = uv + ruv * (ru - 1.0);
+        }
+    }
+    #endif
+
+    return uv;
+}
+
+#endif // UNITY_POSTFX_DISTORTION

PostProcessing/Runtime/Utils/ShaderIDs.cs

@@ -5,6 +5,7 @@ Shader "Hidden/PostProcessing/Uber"
         #pragma target 3.0
 
         #pragma multi_compile __ UNITY_COLORSPACE_GAMMA
+        #pragma multi_compile __ DISTORT
         #pragma multi_compile __ CHROMATIC_ABERRATION CHROMATIC_ABERRATION_LOW
         #pragma multi_compile __ BLOOM
         #pragma multi_compile __ COLOR_GRADING_LDR_2D COLOR_GRADING_HDR_2D COLOR_GRADING_HDR_3D
@@ -15,6 +16,7 @@ Shader "Hidden/PostProcessing/Uber"
         #include "../StdLib.hlsl"
         #include "../Colors.hlsl"
         #include "../Sampling.hlsl"
+        #include "Distortion.hlsl"
         #include "Dithering.hlsl"
 
         #define MAX_CHROMATIC_SAMPLES 16
@@ -71,6 +73,12 @@ Shader "Hidden/PostProcessing/Uber"
         half4 FragUber(VaryingsDefault i) : SV_Target
         {
             float2 uv = i.texcoord;
+
+            //>>> Automatically skipped by the shader optimizer when not used
+            float2 uvDistorted = Distort(i.texcoord);
+            float2 uvStereoDistorted = Distort(i.texcoordStereo);
+            //<<<
+
             half autoExposure = SAMPLE_TEXTURE2D(_AutoExposureTex, sampler_AutoExposureTex, uv).r;
             half4 color = (0.0).xxxx;
 
@@ -90,7 +98,7 @@ Shader "Hidden/PostProcessing/Uber"
                 for (int i = 0; i < samples; i++)
                 {
                     half t = (i + 0.5) / samples;
-                    half4 s = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(pos), 0);
+                    half4 s = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(Distort(pos)), 0);
                     half4 filter = half4(SAMPLE_TEXTURE2D_LOD(_ChromaticAberration_SpectralLut, sampler_ChromaticAberration_SpectralLut, float2(t, 0.0), 0).rgb, 1.0);
 
                     sum += s * filter;
@@ -110,17 +118,17 @@ Shader "Hidden/PostProcessing/Uber"
                 half4 filterB = half4(SAMPLE_TEXTURE2D_LOD(_ChromaticAberration_SpectralLut, sampler_ChromaticAberration_SpectralLut, float2(1.5 / 3, 0.0), 0).rgb, 1.0);
                 half4 filterC = half4(SAMPLE_TEXTURE2D_LOD(_ChromaticAberration_SpectralLut, sampler_ChromaticAberration_SpectralLut, float2(2.5 / 3, 0.0), 0).rgb, 1.0);
 
-                half4 texelA = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(uv), 0);
-                half4 texelB = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(delta + uv), 0);
-                half4 texelC = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(delta * 2.0 + uv), 0);
+                half4 texelA = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(Distort(uv)), 0);
+                half4 texelB = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(Distort(delta + uv)), 0);
+                half4 texelC = SAMPLE_TEXTURE2D_LOD(_MainTex, sampler_MainTex, UnityStereoTransformScreenSpaceTex(Distort(delta * 2.0 + uv)), 0);
 
                 half4 sum = texelA * filterA + texelB * filterB + texelC * filterC;
                 half4 filterSum = filterA + filterB + filterC;
                 color = sum / filterSum;
             }
             #else
             {
-                color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoordStereo);
+                color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uvStereoDistorted);
             }
             #endif
 
@@ -135,8 +143,13 @@ Shader "Hidden/PostProcessing/Uber"
 
             #if BLOOM
             {
-                half4 bloom = UpsampleTent(TEXTURE2D_PARAM(_BloomTex, sampler_BloomTex), i.texcoord, _BloomTex_TexelSize.xy, _Bloom_Settings.x);
-                half4 dirt = half4(SAMPLE_TEXTURE2D(_Bloom_DirtTex, sampler_Bloom_DirtTex, i.texcoord * _Bloom_DirtTileOffset.xy + _Bloom_DirtTileOffset.zw).rgb, 0.0);
+                half4 bloom = UpsampleTent(TEXTURE2D_PARAM(_BloomTex, sampler_BloomTex), uvDistorted, _BloomTex_TexelSize.xy, _Bloom_Settings.x);
+
+                // UVs should be Distort(uv * _Bloom_DirtTileOffset.xy + _Bloom_DirtTileOffset.zw)
+                // 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
+                half4 dirt = half4(SAMPLE_TEXTURE2D(_Bloom_DirtTex, sampler_Bloom_DirtTex, uvDistorted * _Bloom_DirtTileOffset.xy + _Bloom_DirtTileOffset.zw).rgb, 0.0);
 
                 // Additive bloom (artist friendly)
                 bloom *= _Bloom_Settings.y;
@@ -151,7 +164,7 @@ Shader "Hidden/PostProcessing/Uber"
                 UNITY_BRANCH
                 if (_Vignette_Mode < 0.5)
                 {
-                    half2 d = abs(uv - _Vignette_Center) * _Vignette_Settings.x;
+                    half2 d = abs(uvDistorted - _Vignette_Center) * _Vignette_Settings.x;
                     d.x *= lerp(1.0, _ScreenParams.x / _ScreenParams.y, _Vignette_Settings.w);
                     d = pow(saturate(d), _Vignette_Settings.z); // Roundness
                     half vfactor = pow(saturate(1.0 - dot(d, d)), _Vignette_Settings.y);
@@ -160,7 +173,7 @@ Shader "Hidden/PostProcessing/Uber"
                 }
                 else
                 {
-                    half vfactor = SAMPLE_TEXTURE2D(_Vignette_Mask, sampler_Vignette_Mask, uv).a;
+                    half vfactor = SAMPLE_TEXTURE2D(_Vignette_Mask, sampler_Vignette_Mask, uvDistorted).a;
 
                     #if !UNITY_COLORSPACE_GAMMA
                     {