Improved volume texture blending; Added support for ldr luts others than 1024x32

Author: Chman

PostProcessing/Runtime/Effects/ColorGrading.cs

@@ -61,11 +61,8 @@ public sealed class ColorGrading : PostProcessEffectSettings
         [DisplayName("Gamma"), Min(0.001f), Tooltip("")]
         public FloatParameter toneCurveGamma = new FloatParameter { value = 1f };
 
-        [DisplayName("Lookup Texture"), Tooltip("Custom log-space lookup texture (strip format, e.g. 1024x32). EXR format is highly recommended or precision will be heavily degraded. Refer to the documentation for more information about how to create such a Lut.")]
-        public TextureParameter logLut = new TextureParameter { value = null };
-
         [DisplayName("Lookup Texture"), Tooltip("Custom lookup texture (strip format, e.g. 256x16) to apply before the rest of the color grading operators. If none is provided, a neutral one will be generated internally.")]
-        public TextureParameter ldrLut = new TextureParameter { value = null }; // LDR only
+        public TextureParameter ldrLut = new TextureParameter { value = null, defaultState = TextureParameterDefault.Lut2D }; // LDR only
 
         [DisplayName("Temperature"), Range(-100f, 100f), Tooltip("Sets the white balance to a custom color temperature.")]
         public FloatParameter temperature = new FloatParameter { value = 0f };
@@ -309,7 +306,7 @@ void RenderHDRPipeline3D(PostProcessRenderContext context)
         // LUT (33^3 -> 32^3) but most of the time it's imperceptible.
         void RenderHDRPipeline2D(PostProcessRenderContext context)
         {
-            // For the same reasons as in RenderHDRPipeline3D, regen LUT on evey frame
+            // For the same reasons as in RenderHDRPipeline3D, regen LUT on every frame
             {
                 CheckInternalStripLut();
 
@@ -388,7 +385,7 @@ void RenderHDRPipeline2D(PostProcessRenderContext context)
         // LDR color pipeline is rendered to a 2D strip lut (works on every platform)
         void RenderLDRPipeline2D(PostProcessRenderContext context)
         {
-            // For the same reasons as in RenderHDRPipeline3D, regen LUT on evey frame
+            // For the same reasons as in RenderHDRPipeline3D, regen LUT on every frame
             {
                 CheckInternalStripLut();
 
@@ -426,11 +423,18 @@ void RenderLDRPipeline2D(PostProcessRenderContext context)
 
                 // Generate the lut
                 context.command.BeginSample("LdrColorGradingLut2D");
+
                 var userLut = settings.ldrLut.value;
                 if (userLut == null)
+                {
                     context.command.BlitFullscreenTriangle(BuiltinRenderTextureType.None, m_InternalLdrLut, lutSheet, (int)Pass.LutGenLDRFromScratch);
+                }
                 else
+                {
+                    lutSheet.properties.SetVector(ShaderIDs.UserLut2D_Params, new Vector3(1f / userLut.width, 1f / userLut.height, userLut.height - 1f));
                     context.command.BlitFullscreenTriangle(userLut, m_InternalLdrLut, lutSheet, (int)Pass.LutGenLDR);
+                }
+
                 context.command.EndSample("LdrColorGradingLut2D");
             }
 

PostProcessing/Runtime/ParameterOverride.cs

@@ -215,18 +215,73 @@ public override void Interp(Spline from, Spline to, float t)
         }
     }
 
+    public enum TextureParameterDefault
+    {
+        None,
+        Black,
+        White,
+        Transparent,
+        Lut2D
+    }
+
     [Serializable]
     public sealed class TextureParameter : ParameterOverride<Texture>
     {
+        public TextureParameterDefault defaultState = TextureParameterDefault.Black;
+
         public override void Interp(Texture from, Texture to, float t)
         {
-            if (from == null || to == null)
+            // Both are null, do nothing
+            if (from == null && to == null)
             {
-                base.Interp(from, to, t);
+                value = null;
+                return;
+            }
+
+            // Both aren't null we're ready to blend
+            if (from != null && to != null)
+            {
+                value = TextureLerper.instance.Lerp(from, to, t);
                 return;
             }
 
-            value = TextureLerper.instance.Lerp(from, to, t);
+            // One of them is null, blend to/from a default value is applicable
+            {
+                Texture defaultTexture;
+
+                switch (defaultState)
+                {
+                    case TextureParameterDefault.Black:
+                        defaultTexture = RuntimeUtilities.blackTexture;
+                        break;
+                    case TextureParameterDefault.White:
+                        defaultTexture = RuntimeUtilities.whiteTexture;
+                        break;
+                    case TextureParameterDefault.Transparent:
+                        defaultTexture = RuntimeUtilities.transparentTexture;
+                        break;
+                    case TextureParameterDefault.Lut2D:
+                        // Find the current lut size
+                        int size = from != null ? from.height : to.height;
+                        defaultTexture = RuntimeUtilities.GetLutStrip(size);
+                        break;
+                    default:
+                        defaultTexture = null;
+                        break;
+                }
+
+                if (from == null) from = defaultTexture;
+                if (to == null) to = defaultTexture;
+
+                // defaultState could have been explicitly set to None
+                if (from == null || to == null)
+                {
+                    base.Interp(from, to, t);
+                    return;
+                }
+
+                value = TextureLerper.instance.Lerp(from, to, t);
+            }
         }
     }
 }

PostProcessing/Runtime/Utils/RuntimeUtilities.cs

@@ -26,7 +26,7 @@ public static Texture2D whiteTexture
             {
                 if (m_WhiteTexture == null)
                 {
-                    m_WhiteTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
+                    m_WhiteTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false) { name = "White Texture" };
                     m_WhiteTexture.SetPixel(0, 0, Color.white);
                     m_WhiteTexture.Apply();
                 }
@@ -42,7 +42,7 @@ public static Texture2D blackTexture
             {
                 if (m_BlackTexture == null)
                 {
-                    m_BlackTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
+                    m_BlackTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false) { name = "Black Texture" };
                     m_BlackTexture.SetPixel(0, 0, Color.black);
                     m_BlackTexture.Apply();
                 }
@@ -58,7 +58,7 @@ public static Texture2D transparentTexture
             {
                 if (m_TransparentTexture == null)
                 {
-                    m_TransparentTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false);
+                    m_TransparentTexture = new Texture2D(1, 1, TextureFormat.ARGB32, false) { name = "Transparent Texture" };
                     m_TransparentTexture.SetPixel(0, 0, Color.clear);
                     m_TransparentTexture.Apply();
                 }
@@ -67,6 +67,55 @@ public static Texture2D transparentTexture
             }
         }
 
+        static Dictionary<int, Texture2D> m_LutStrips = new Dictionary<int, Texture2D>();
+
+        public static Texture2D GetLutStrip(int size)
+        {
+            Texture2D texture;
+            if (!m_LutStrips.TryGetValue(size, out texture))
+            {
+                int width = size * size;
+                int height = size;
+                var pixels = new Color[width * height];
+                float inv = 1f / (size - 1f);
+
+                for (int z = 0; z < size; z++)
+                {
+                    var offset = z * size;
+                    var b = z * inv;
+
+                    for (int y = 0; y < size; y++)
+                    {
+                        var g = y * inv;
+
+                        for (int x = 0; x < size; x++)
+                        {
+                            var r = x * inv;
+                            pixels[y * width + offset + x] = new Color(r, g, b);
+                        }
+                    }
+                }
+
+                var format = TextureFormat.RGBAHalf;
+                if (!format.IsSupported())
+                    format = TextureFormat.ARGB32;
+                    
+                texture = new Texture2D(size * size, size, format, false, true)
+                {
+                    name = "Strip Lut" + size,
+                    hideFlags = HideFlags.DontSave,
+                    filterMode = FilterMode.Bilinear,
+                    wrapMode = TextureWrapMode.Clamp,
+                    anisoLevel = 0
+                };
+                texture.SetPixels(pixels);
+                texture.Apply();
+                m_LutStrips.Add(size, texture);
+            }
+
+            return texture;
+        }
+
         #endregion
 
         #region Rendering

PostProcessing/Runtime/Utils/ShaderIDs.cs

@@ -100,6 +100,7 @@ static class ShaderIDs
         internal static readonly int Lut3D                           = Shader.PropertyToID("_Lut3D");
         internal static readonly int Lut3D_Params                    = Shader.PropertyToID("_Lut3D_Params");
         internal static readonly int Lut2D_Params                    = Shader.PropertyToID("_Lut2D_Params");
+        internal static readonly int UserLut2D_Params                = Shader.PropertyToID("_UserLut2D_Params");
         internal static readonly int PostExposure                    = Shader.PropertyToID("_PostExposure");
         internal static readonly int ColorBalance                    = Shader.PropertyToID("_ColorBalance");
         internal static readonly int ColorFilter                     = Shader.PropertyToID("_ColorFilter");

PostProcessing/Runtime/Utils/TextureFormatUtilities.cs

@@ -9,6 +9,7 @@ public static class TextureFormatUtilities
     {
         static Dictionary<int, RenderTextureFormat> s_FormatAliasMap;
         static Dictionary<int, bool> s_SupportedRenderTextureFormats;
+        static Dictionary<int, bool> s_SupportedTextureFormats;
 
         static TextureFormatUtilities()
         {
@@ -70,13 +71,30 @@ static TextureFormatUtilities()
 
             // In 2018.1 SystemInfo.SupportsRenderTextureFormat() generates garbage so we need to
             // cache its calls to avoid that...
-            s_SupportedRenderTextureFormats = new Dictionary<int, bool>();
-            var values = Enum.GetValues(typeof(RenderTextureFormat));
+            {
+                s_SupportedRenderTextureFormats = new Dictionary<int, bool>();
+                var values = Enum.GetValues(typeof(RenderTextureFormat));
+
+                foreach (var format in values)
+                {
+                    bool supported = SystemInfo.SupportsRenderTextureFormat((RenderTextureFormat)format);
+                    s_SupportedRenderTextureFormats.Add((int)format, supported);
+                }
+            }
 
-            foreach (var format in values)
+            // Same for TextureFormat
             {
-                bool supported = SystemInfo.SupportsRenderTextureFormat((RenderTextureFormat)format);
-                s_SupportedRenderTextureFormats.Add((int)format, supported);
+                s_SupportedTextureFormats = new Dictionary<int, bool>();
+                var values = Enum.GetValues(typeof(TextureFormat));
+
+                foreach (var format in values)
+                {
+                    if ((int)format < 0) // Crashes the runtime otherwise (!)
+                        continue;
+
+                    bool supported = SystemInfo.SupportsTextureFormat((TextureFormat)format);
+                    s_SupportedTextureFormats.Add((int)format, supported);
+                }
             }
         }
 
@@ -107,5 +125,12 @@ internal static bool IsSupported(this RenderTextureFormat format)
             s_SupportedRenderTextureFormats.TryGetValue((int)format, out supported);
             return supported;
         }
+
+        internal static bool IsSupported(this TextureFormat format)
+        {
+            bool supported;
+            s_SupportedTextureFormats.TryGetValue((int)format, out supported);
+            return supported;
+        }
     }
 }

PostProcessing/Runtime/Utils/TextureLerper.cs

@@ -109,8 +109,9 @@ internal Texture Lerp(Texture from, Texture to, float t)
             bool is3d = to is Texture3D
                     || (to is RenderTexture && ((RenderTexture)to).volumeDepth > 1);
 
-            RenderTexture rt = null;
+            RenderTexture rt;
 
+            // 3D texture blending is a special case and only works on compute enabled platforms
             if (is3d)
             {
                 int size = to.width;
@@ -126,18 +127,24 @@ internal Texture Lerp(Texture from, Texture to, float t)
                 int groupSizeXY = Mathf.CeilToInt(size / 8f);
                 int groupSizeZ = Mathf.CeilToInt(size / (RuntimeUtilities.isAndroidOpenGL ? 2f : 8f));
                 m_Command.DispatchCompute(compute, kernel, groupSizeXY, groupSizeXY, groupSizeZ);
+                return rt;
             }
-            else
-            {
-                var format = TextureFormatUtilities.GetUncompressedRenderTextureFormat(to);
-                rt = Get(format, to.width, to.height);
 
-                var sheet = m_PropertySheets.Get(m_Resources.shaders.texture2dLerp);
-                sheet.properties.SetTexture(ShaderIDs.To, to);
-                sheet.properties.SetFloat(ShaderIDs.Interp, t);
-
-                m_Command.BlitFullscreenTriangle(from, rt, sheet, 0);
-            }
+            // 2D texture blending
+            // We could handle textures with different sizes by picking the biggest one to avoid
+            // popping effects. This would work in most cases but will still pop if one texture is
+            // wider but shorter than the other. Generally speaking you're expected to use same-size
+            // textures anyway so we decided not to handle this case at the moment, especially since
+            // it would waste a lot of texture memory as soon as you start using bigger textures
+            // (snow ball effect).
+            var format = TextureFormatUtilities.GetUncompressedRenderTextureFormat(to);
+            rt = Get(format, to.width, to.height);
+
+            var sheet = m_PropertySheets.Get(m_Resources.shaders.texture2dLerp);
+            sheet.properties.SetTexture(ShaderIDs.To, to);
+            sheet.properties.SetFloat(ShaderIDs.Interp, t);
+
+            m_Command.BlitFullscreenTriangle(from, rt, sheet, 0);
 
             return rt;
         }

PostProcessing/Shaders/Builtins/Lut2DBaker.shader

@@ -9,6 +9,7 @@ Shader "Hidden/PostProcessing/Lut2DBaker"
 
         TEXTURE2D_SAMPLER2D(_MainTex, sampler_MainTex);
         float4 _Lut2D_Params;
+        float3 _UserLut2D_Params;
 
         float3 _ColorBalance;
         float3 _ColorFilter;
@@ -97,7 +98,9 @@ Shader "Hidden/PostProcessing/Lut2DBaker"
 
         float4 FragLDR(VaryingsDefault i) : SV_Target
         {
-            float3 colorLinear = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord).rgb;
+            // Note: user luts may not have the same size as the internal one
+            float3 neutralColorLinear = GetLutStripValue(i.texcoordStereo, _Lut2D_Params);
+            float3 colorLinear = ApplyLut2D(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), neutralColorLinear, _UserLut2D_Params);
             float3 graded = ColorGradeLDR(colorLinear);
             return float4(graded, 1.0);
         }