Optimized the Grain effect and added a "Colored" option

PS4 numbers:
- Old Fast grain : 152µs
- Old Filmic grain : 464µs
- New Filmic grain : 185µs

As a result the "fast" variant has been dropped because of it's bad
quality and is only slightly faster than the new grain.

Author: Chman

PostProcessing/Editor/Models/GrainModelEditor.cs

@@ -7,27 +7,43 @@ namespace UnityEditor.PostProcessing
     [PostProcessingModelEditor(typeof(GrainModel))]
     public class GrainModelEditor : PostProcessingModelEditor
     {
-        SerializedProperty m_Mode;
-        SerializedProperty m_Amount;
+        SerializedProperty m_Colored;
+        SerializedProperty m_Intensity;
+        SerializedProperty m_WeightR;
+        SerializedProperty m_WeightG;
+        SerializedProperty m_WeightB;
         SerializedProperty m_Size;
         SerializedProperty m_LuminanceContribution;
 
         public override void OnEnable()
         {
-            m_Mode = FindSetting((Settings x) => x.mode);
-            m_Amount = FindSetting((Settings x) => x.intensity);
+            m_Colored = FindSetting((Settings x) => x.colored);
+            m_Intensity = FindSetting((Settings x) => x.intensity);
+            m_WeightR = FindSetting((Settings x) => x.weightR);
+            m_WeightG = FindSetting((Settings x) => x.weightG);
+            m_WeightB = FindSetting((Settings x) => x.weightB);
             m_Size = FindSetting((Settings x) => x.size);
             m_LuminanceContribution = FindSetting((Settings x) => x.luminanceContribution);
         }
 
         public override void OnInspectorGUI()
         {
-            EditorGUILayout.PropertyField(m_Mode);
-            EditorGUILayout.PropertyField(m_Amount);
+            EditorGUILayout.PropertyField(m_Intensity);
             EditorGUILayout.PropertyField(m_LuminanceContribution);
+            EditorGUILayout.PropertyField(m_Size);
+            EditorGUILayout.PropertyField(m_Colored);
 
-            if (m_Mode.intValue == (int)GrainModel.Mode.Filmic)
-                EditorGUILayout.PropertyField(m_Size);
+            if (m_Colored.boolValue)
+            {
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField("Channel Weights", EditorStyles.boldLabel);
+
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_WeightR, EditorGUIHelper.GetContent("Red"));
+                EditorGUILayout.PropertyField(m_WeightG, EditorGUIHelper.GetContent("Green"));
+                EditorGUILayout.PropertyField(m_WeightB, EditorGUIHelper.GetContent("Blue"));
+                EditorGUI.indentLevel--;
+            }
         }
     }
 }

PostProcessing/Resources/Shaders/GrainGen.shader

@@ -0,0 +1,106 @@
+Shader "Hidden/Post FX/Grain Generator"
+{
+    CGINCLUDE
+
+        #include "UnityCG.cginc"
+        #include "Common.cginc"
+
+        float4 _Params; // x: size, y: time, z: cos_angle, w: sin_angle
+
+        float3 Rnm(float2 tc, float time)
+        {
+            float noise = sin(dot(tc + time.xx, float2(12.9898, 78.233))) * 43758.5453;
+            return frac(noise.xxx * float3(1.0, 1.2154, 1.3647)) * 2.0 - 1.0;
+        }
+
+        float Fade(float t)
+        {
+            return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+        }
+
+        // 2d gradient noise
+        float PNoise(float2 p, float time)
+        {
+            const float kPermTexUnit = 1.0 / 256.0;
+            const float kPermTexUnitHalf = 0.5 / 256.0;
+
+            float2 pi = kPermTexUnit * floor(p) + kPermTexUnitHalf;
+            float2 pf = frac(p);
+
+            float perm00 = Rnm(pi, time).z;
+            float2 grad000 = Rnm(float2(perm00, kPermTexUnitHalf), time).xy * 4.0 - 1.0;
+            float n000 = dot(grad000, pf);
+
+            float perm01 = Rnm(pi + float2(0.0, kPermTexUnit), time).z;
+            half2 grad010 = Rnm(float2(perm01, kPermTexUnitHalf), time).xy * 4.0 - 1.0;
+            float n010 = dot(grad010, pf - float2(0.0, 1.0));
+
+            float perm10 = Rnm(pi + float2(kPermTexUnit, 0.0), time).z;
+            float2 grad100 = Rnm(float2(perm10, kPermTexUnitHalf), time).xy * 4.0 - 1.0;
+            float n100 = dot(grad100, pf - float2(1.0, 0.0));
+
+            float perm11 = Rnm(pi + float2(kPermTexUnit, kPermTexUnit), time).z;
+            float2 grad110 = Rnm(float2(perm11, kPermTexUnitHalf), time).xy * 4.0 - 1.0;
+            float n110 = dot(grad110, pf - float2(1.0, 1.0));
+
+            float2 n_x = lerp(float2(n000, n010), float2(n100, n110), Fade(pf.x));
+
+            return lerp(n_x.x, n_x.y, Fade(pf.y));
+        }
+
+        float2 CoordRot(float2 tc, float2 angle)
+        {
+            float s = angle.y;
+            float c = angle.x;
+            tc = tc * 2.0 - 1.0;
+            float2 rot = float2((tc.x * c) - (tc.y * s), (tc.y * c) + (tc.x * s));
+            return rot * 0.5 + 0.5;
+        }
+
+        float4 FragGrain(VaryingsDefault i) : SV_Target
+        {
+            float2 rotCoords = CoordRot(i.uv, _Params.zw);
+            float n = PNoise(rotCoords * (192.0).xx / _Params.x, _Params.y);
+            return n.xxxx;
+        }
+
+        float4 FragGrainColored(VaryingsDefault i) : SV_Target
+        {
+            float2 rotCoordsR = CoordRot(i.uv, _Params.zw);
+            float2 rotCoordsG = CoordRot(i.uv + (0.1).xx, _Params.zw);
+            float2 rotCoordsB = CoordRot(i.uv - (0.1).xx, _Params.zw);
+
+            float r = PNoise(rotCoordsR * (192.0).xx / _Params.x, _Params.y);
+            float g = PNoise(rotCoordsG * (192.0).xx / _Params.x, _Params.y);
+            float b = PNoise(rotCoordsB * (192.0).xx / _Params.x, _Params.y);
+
+            return float4(r, g, b, 1.0);
+        }
+
+    ENDCG
+
+    SubShader
+    {
+        Cull Off ZWrite Off ZTest Always
+
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex VertDefault
+                #pragma fragment FragGrain
+
+            ENDCG
+        }
+
+        Pass
+        {
+            CGPROGRAM
+
+                #pragma vertex VertDefault
+                #pragma fragment FragGrainColored
+
+            ENDCG
+        }
+    }
+}

PostProcessing/Resources/Shaders/GrainGen.shader.meta

@@ -5,7 +5,8 @@ Shader "Hidden/Post FX/Uber Shader"
         _MainTex ("Texture", 2D) = "white" {}
         _AutoExposure ("", 2D) = "" {}
         _BloomTex ("", 2D) = "" {}
-        _Bloom_DirtTex("", 2D) = "" {}
+        _Bloom_DirtTex ("", 2D) = "" {}
+        _GrainTex ("", 2D) = "" {}
         _LogLut ("", 2D) = "" {}
         _UserLut ("", 2D) = "" {}
         _Vignette_Mask ("", 2D) = "" {}
@@ -23,12 +24,11 @@ Shader "Hidden/Post FX/Uber Shader"
         #pragma multi_compile __ BLOOM_LENS_DIRT
         #pragma multi_compile __ COLOR_GRADING COLOR_GRADING_LOG_VIEW
         #pragma multi_compile __ USER_LUT
-        #pragma multi_compile __ GRAIN_FAST GRAIN_FILMIC
+        #pragma multi_compile __ GRAIN
         #pragma multi_compile __ VIGNETTE_CLASSIC VIGNETTE_ROUND VIGNETTE_MASKED
 
         #include "UnityCG.cginc"
         #include "Bloom.cginc"
-        #include "Grain.cginc"
         #include "ColorGrading.cginc"
 
         // Auto exposure / eye adaptation
@@ -56,8 +56,9 @@ Shader "Hidden/Post FX/Uber Shader"
         half4 _UserLut_Params; // @see _LogLut_Params
 
         // Grain
-        half4 _Grain_Params1; // x: amount, y: size, z: lum_contrib, w: aspect
-        half3 _Grain_Params2; // x: cos_angle, y: sin_angle, z: time
+        half4 _Grain_Params1; // x: lum_contrib, y: intensityR, z: intensityG, w: intensityB
+        half4 _Grain_Params2; // x: xscale, h: yscale, z: xoffset, w: yoffset
+        sampler2D _GrainTex;
 
         // Vignette
         half3 _Vignette_Color;
@@ -95,7 +96,7 @@ Shader "Hidden/Post FX/Uber Shader"
 
         half4 FragUber(VaryingsFlipped i) : SV_Target
         {
-            half2 uv = i.uv;
+            float2 uv = i.uv;
             half autoExposure = 1.0;
 
             // Store the auto exposure value for later
@@ -117,13 +118,13 @@ Shader "Hidden/Post FX/Uber Shader"
             // TODO: Take advantage of TAA to get even smoother results
             #if CHROMATIC_ABERRATION
             {
-                half2 coords = 2.0 * uv - 1.0;
-                half2 end = uv - coords * dot(coords, coords) * _ChromaticAberration_Amount;
+                float2 coords = 2.0 * uv - 1.0;
+                float2 end = uv - coords * dot(coords, coords) * _ChromaticAberration_Amount;
 
-                half2 diff = end - uv;
+                float2 diff = end - uv;
                 int samples = clamp(int(length(_MainTex_TexelSize.zw * diff / 2.0)), 3, 16);
-                half2 delta = diff / samples;
-                half2 pos = uv;
+                float2 delta = diff / samples;
+                float2 pos = uv;
                 half3 sum = (0.0).xxx, filterSum = (0.0).xxx;
 
                 for (int i = 0; i < samples; i++)
@@ -219,9 +220,16 @@ Shader "Hidden/Post FX/Uber Shader"
             color = saturate(color);
 
             // Grain / dithering
-            #if (GRAIN_FAST || GRAIN_FILMIC)
+            #if (GRAIN)
             {
-                color = ApplyGrain(color, uv, _Grain_Params1, _Grain_Params2);
+                float3 grain = tex2D(_GrainTex, uv * _Grain_Params2.xy + _Grain_Params2.zw).rgb;
+
+                // Noisiness response curve based on scene luminance
+                float luminance = lerp(0.0, AcesLuminance(color), _Grain_Params1.x);
+                float lum = smoothstep(0.2, 0.0, luminance) + luminance;
+
+                grain = lerp(grain, 0.0, Pow4(lum));
+                color += grain * _Grain_Params1.yzw;
             }
             #endif
 

PostProcessing/Resources/Shaders/Uber.shader

@@ -6,40 +6,84 @@ static class Uniforms
         {
             internal static readonly int _Grain_Params1 = Shader.PropertyToID("_Grain_Params1");
             internal static readonly int _Grain_Params2 = Shader.PropertyToID("_Grain_Params2");
+            internal static readonly int _GrainTex = Shader.PropertyToID("_GrainTex");
+            internal static readonly int _Params = Shader.PropertyToID("_Params");
         }
 
         public override bool active
         {
             get
             {
                 return model.enabled
-                       && model.settings.intensity > 0f;
+                       && model.settings.intensity > 0f
+                       && SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf);
             }
         }
 
+        RenderTexture m_GrainLookupRT;
+
+        public override void OnDisable()
+        {
+            GraphicsUtils.Destroy(m_GrainLookupRT);
+            m_GrainLookupRT = null;
+        }
+
         public override void Prepare(Material uberMaterial)
         {
             var settings = model.settings;
 
-            uberMaterial.EnableKeyword(
-                settings.mode == GrainModel.Mode.Fast
-                ? "GRAIN_FAST"
-                : "GRAIN_FILMIC"
-                );
+            uberMaterial.EnableKeyword("GRAIN");
 
 #if POSTFX_DEBUG_STATIC_GRAIN
+            // Chosen by a fair dice roll
             float time = 4f;
+            float rndXOffset = 0f;
+            float rndYOffset = 0f;
 #else
             float time = Time.realtimeSinceStartup;
+            float rndXOffset = Random.value;
+            float rndYOffset = Random.value;
 #endif
 
             // Used for sample rotation in Filmic mode and position offset in Fast mode
             const float kRotationOffset = 1.425f;
             float c = Mathf.Cos(time + kRotationOffset);
             float s = Mathf.Sin(time + kRotationOffset);
 
-            uberMaterial.SetVector(Uniforms._Grain_Params1, new Vector4(settings.intensity * 0.25f, settings.size, settings.luminanceContribution, (float)context.width / (float)context.height));
-            uberMaterial.SetVector(Uniforms._Grain_Params2, new Vector3(c, s, time / 20f));
+            if (m_GrainLookupRT == null || !m_GrainLookupRT.IsCreated())
+            {
+                GraphicsUtils.Destroy(m_GrainLookupRT);
+
+                m_GrainLookupRT = new RenderTexture(192, 192, 0, RenderTextureFormat.ARGBHalf)
+                {
+                    filterMode = FilterMode.Bilinear,
+                    wrapMode = TextureWrapMode.Repeat,
+                    anisoLevel = 0,
+                    name = "Grain Lookup Texture"
+                };
+
+                m_GrainLookupRT.Create();
+            }
+
+            var grainMaterial = context.materialFactory.Get("Hidden/Post FX/Grain Generator");
+            grainMaterial.SetVector(Uniforms._Params, new Vector4(settings.size, time / 20f, c, s));
+
+            Graphics.Blit((Texture)null, m_GrainLookupRT, grainMaterial, settings.colored ? 1 : 0);
+
+            uberMaterial.SetTexture(Uniforms._GrainTex, m_GrainLookupRT);
+
+            float intensity = settings.intensity * 0.25f;
+
+            if (!settings.colored)
+            {
+                uberMaterial.SetVector(Uniforms._Grain_Params1, new Vector4(settings.luminanceContribution, intensity, intensity, intensity));
+            }
+            else
+            {
+                uberMaterial.SetVector(Uniforms._Grain_Params1, new Vector4(settings.luminanceContribution, settings.weightR * intensity, settings.weightG * intensity, settings.weightB * intensity));
+            }
+
+            uberMaterial.SetVector(Uniforms._Grain_Params2, new Vector4((float)context.width / (float)m_GrainLookupRT.width, (float)context.height / (float)m_GrainLookupRT.height, rndXOffset, rndYOffset));
         }
     }
 }

PostProcessing/Runtime/Components/GrainComponent.cs

@@ -5,21 +5,24 @@ namespace UnityEngine.PostProcessing
     [Serializable]
     public class GrainModel : PostProcessingModel
     {
-        public enum Mode
-        {
-            Fast,
-            Filmic
-        }
-
         [Serializable]
         public struct Settings
         {
-            [Tooltip("Grain mode. \"Filmic\" produces a high quality, camera-like grain. \"Fast\" is aimed at lower-end platforms as it's a lot faster but doesn't look as good as \"Filmic\".")]
-            public Mode mode;
+            [Tooltip("Enable the use of colored grain.")]
+            public bool colored;
 
             [Range(0f, 1f), Tooltip("Grain strength. Higher means more visible grain.")]
             public float intensity;
 
+            [Range(0f, 2f), Tooltip("Grain weight for the red channel. Higher means more visible grain.")]
+            public float weightR;
+
+            [Range(0f, 2f), Tooltip("Grain weight for the green channel. Higher means more visible grain.")]
+            public float weightG;
+
+            [Range(0f, 2f), Tooltip("Grain weight for the blue channel. Higher means more visible grain.")]
+            public float weightB;
+
             [Range(1.5f, 3f), Tooltip("Grain particle size in \"Filmic\" mode.")]
             public float size;
 
@@ -32,8 +35,11 @@ public static Settings defaultSettings
                 {
                     return new Settings
                     {
-                        mode = Mode.Filmic,
+                        colored = false,
                         intensity = 0.12f,
+                        weightR = 1f,
+                        weightG = 1f,
+                        weightB = 1f,
                         size = 1.6f,
                         luminanceContribution = 0.75f
                     };