Added debug overlays

Author: Chman

PostProcessing/Editor/PostProcessDebugEditor.cs

@@ -1,4 +1,4 @@
-using UnityEngine;
+using UnityEngine;
 using UnityEngine.Rendering.PostProcessing;
 
 namespace UnityEditor.Rendering.PostProcessing
@@ -11,12 +11,17 @@ public sealed class PostProcessDebugEditor : BaseEditor<PostProcessDebug>
         SerializedProperty m_HistogramEnabled;
         SerializedProperty m_WaveformEnabled;
         SerializedProperty m_VectorscopeEnabled;
+        SerializedProperty m_Overlay;
+
+        SerializedObject m_LayerObject;
 
-        SerializedObject m_Monitors;
         SerializedProperty m_LightMeterShowCurves;
         SerializedProperty m_HistogramChannel;
         SerializedProperty m_WaveformExposure;
         SerializedProperty m_VectorscopeExposure;
+        
+        SerializedProperty m_MotionColorIntensity;
+        SerializedProperty m_MotionGridSize;
 
         void OnEnable()
         {
@@ -25,6 +30,7 @@ void OnEnable()
             m_HistogramEnabled = FindProperty(x => x.histogram);
             m_WaveformEnabled = FindProperty(x => x.waveform);
             m_VectorscopeEnabled = FindProperty(x => x.vectorscope);
+            m_Overlay = FindProperty(x => x.debugOverlay);
 
             if (m_PostProcessLayer.objectReferenceValue != null)
                 RebuildProperties();
@@ -35,12 +41,15 @@ void RebuildProperties()
             if (m_PostProcessLayer.objectReferenceValue == null)
                 return;
 
-            m_Monitors = new SerializedObject(m_Target.postProcessLayer);
+            m_LayerObject = new SerializedObject(m_Target.postProcessLayer);
+
+            m_LightMeterShowCurves = m_LayerObject.FindProperty("debugLayer.lightMeter.showCurves");
+            m_HistogramChannel = m_LayerObject.FindProperty("debugLayer.histogram.channel");
+            m_WaveformExposure = m_LayerObject.FindProperty("debugLayer.waveform.exposure");
+            m_VectorscopeExposure = m_LayerObject.FindProperty("debugLayer.vectorscope.exposure");
 
-            m_LightMeterShowCurves = m_Monitors.FindProperty("monitors.lightMeter.showCurves");
-            m_HistogramChannel = m_Monitors.FindProperty("monitors.histogram.channel");
-            m_WaveformExposure = m_Monitors.FindProperty("monitors.waveform.exposure");
-            m_VectorscopeExposure = m_Monitors.FindProperty("monitors.vectorscope.exposure");
+            m_MotionColorIntensity = m_LayerObject.FindProperty("debugLayer.overlaySettings.motionColorIntensity");
+            m_MotionGridSize = m_LayerObject.FindProperty("debugLayer.overlaySettings.motionGridSize");
         }
 
         public override void OnInspectorGUI()
@@ -50,21 +59,41 @@ public override void OnInspectorGUI()
             using (var changed = new EditorGUI.ChangeCheckScope())
             {
                 EditorGUILayout.PropertyField(m_PostProcessLayer);
+                serializedObject.ApplyModifiedProperties(); // Needed to rebuild properties after a change
+                serializedObject.Update();
 
                 if (changed.changed)
                     RebuildProperties();
             }
 
             if (m_PostProcessLayer.objectReferenceValue != null)
             {
-                m_Monitors.Update();
+                m_LayerObject.Update();
+                
+                // Overlays
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField(EditorUtilities.GetContent("Overlay"), EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(m_Overlay);
+                DoOverlayGUI(DebugOverlay.MotionVectors, m_MotionColorIntensity, m_MotionGridSize);
+
+                // Special cases
+                if (m_Overlay.intValue == (int)DebugOverlay.NANTracker && m_Target.postProcessLayer.stopNaNPropagation)
+                    EditorGUILayout.HelpBox("Disable \"Stop NaN Propagation\" in the Post-process layer or NaNs will be overwritten!", MessageType.Warning);
 
+                EditorGUI.indentLevel--;
+
+                // Monitors
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField(EditorUtilities.GetContent("Monitors"), EditorStyles.boldLabel);
+                EditorGUI.indentLevel++;
                 DoMonitorGUI(EditorUtilities.GetContent("Light Meter"), m_LightMeterEnabled, m_LightMeterShowCurves);
                 DoMonitorGUI(EditorUtilities.GetContent("Histogram"), m_HistogramEnabled, m_HistogramChannel);
                 DoMonitorGUI(EditorUtilities.GetContent("Waveform"), m_WaveformEnabled, m_WaveformExposure);
                 DoMonitorGUI(EditorUtilities.GetContent("Vectoscope"), m_VectorscopeEnabled, m_VectorscopeExposure);
+                EditorGUI.indentLevel--;
 
-                m_Monitors.ApplyModifiedProperties();
+                m_LayerObject.ApplyModifiedProperties();
             }
 
             serializedObject.ApplyModifiedProperties();
@@ -83,8 +112,19 @@ void DoMonitorGUI(GUIContent content, SerializedProperty prop, params Serialized
                 foreach (var p in settings)
                     EditorGUILayout.PropertyField(p);
                 EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
             }
         }
+
+        void DoOverlayGUI(DebugOverlay overlay, params SerializedProperty[] settings)
+        {
+            if (m_Overlay.intValue != (int)overlay)
+                return;
+
+            if (settings == null || settings.Length == 0)
+                return;
+
+            foreach (var p in settings)
+                EditorGUILayout.PropertyField(p);
+        }
     }
 }

PostProcessing/PostProcessResources.asset

@@ -53,7 +53,10 @@ enum Pass
             Downsample13,
             Downsample4,
             UpsampleTent,
-            UpsampleBox
+            UpsampleBox,
+            DebugOverlayThreshold,
+            DebugOverlayTent,
+            DebugOverlayBox
         }
 
         // [down,up]
@@ -146,12 +149,20 @@ public override void Render(PostProcessRenderContext context)
                 last = mipUp;
             }
 
-            var shaderSettings = new Vector4(
-                sampleScale,
-                RuntimeUtilities.Exp2(settings.intensity.value / 10f) - 1f,
-                settings.lensIntensity.value,
-                iterations
-            );
+            var linearColor = settings.color.value.linear;
+            float intensity = RuntimeUtilities.Exp2(settings.intensity.value / 10f) - 1f;
+            var shaderSettings = new Vector4(sampleScale, intensity, settings.lensIntensity.value, iterations);
+
+            // Debug overlays
+            if (context.IsDebugOverlayEnabled(DebugOverlay.BloomThreshold))
+            {
+                context.PushDebugOverlay(cmd, context.source, sheet, (int)Pass.DebugOverlayThreshold);
+            }
+            else if (context.IsDebugOverlayEnabled(DebugOverlay.BloomBuffer))
+            {
+                sheet.properties.SetVector(ShaderIDs.ColorIntensity, new Vector4(linearColor.r, linearColor.g, linearColor.b, intensity));
+                context.PushDebugOverlay(cmd, m_Pyramid[0].up, sheet, (int)Pass.DebugOverlayTent + qualityOffset);
+            }
 
             // Lens dirtiness
             // Keep the aspect ratio correct & center the dirt texture, we don't want it to be
@@ -180,7 +191,7 @@ public override void Render(PostProcessRenderContext context)
             uberSheet.EnableKeyword("BLOOM");
             uberSheet.properties.SetVector(ShaderIDs.Bloom_DirtTileOffset, dirtTileOffset);
             uberSheet.properties.SetVector(ShaderIDs.Bloom_Settings, shaderSettings);
-            uberSheet.properties.SetColor(ShaderIDs.Bloom_Color, settings.color.value.linear);
+            uberSheet.properties.SetColor(ShaderIDs.Bloom_Color, linearColor);
             uberSheet.properties.SetTexture(ShaderIDs.Bloom_DirtTex, dirtTexture);
             cmd.SetGlobalTexture(ShaderIDs.BloomTex, m_Pyramid[0].up);
 

PostProcessing/Runtime/Effects/Bloom.cs

@@ -44,7 +44,8 @@ enum Pass
             BokehLargeKernel,
             BokehVeryLargeKernel,
             PostFilter,
-            Combine
+            Combine,
+            DebugOverlay
         }
 
         // Ping-pong between two history textures as we can't read & write the same target in the
@@ -165,6 +166,10 @@ public override void Render(PostProcessRenderContext context)
             cmd.BlitFullscreenTriangle(ShaderIDs.DepthOfFieldTemp, ShaderIDs.DepthOfFieldTex, sheet, (int)Pass.PostFilter);
             cmd.ReleaseTemporaryRT(ShaderIDs.DepthOfFieldTemp);
 
+            // Debug overlay pass
+            if (context.IsDebugOverlayEnabled(DebugOverlay.DepthOfField))
+                context.PushDebugOverlay(cmd, context.source, sheet, (int)Pass.DebugOverlay);
+
             // Combine pass
             cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, (int)Pass.Combine);
             cmd.ReleaseTemporaryRT(ShaderIDs.DepthOfFieldTex);

PostProcessing/Runtime/Effects/DepthOfField.cs

@@ -38,7 +38,8 @@ enum Pass
         {
             DepthCopy,
             CompositionDeferred,
-            CompositionForward
+            CompositionForward,
+            DebugOverlay
         }
 
         PropertySheet m_PropertySheet;
@@ -311,6 +312,9 @@ void RebuildCommandBuffers(PostProcessRenderContext context)
             PushUpsampleCommands(context, cmd, m_LowDepth3, m_Combined3, m_LowDepth2, m_Occlusion2, m_Combined2);
             PushUpsampleCommands(context, cmd, m_LowDepth2, m_Combined2, m_LowDepth1, m_Occlusion1, m_Combined1);
             PushUpsampleCommands(context, cmd, m_LowDepth1, m_Combined1, m_LinearDepth, null, m_Result);
+
+            if (context.IsDebugOverlayEnabled(DebugOverlay.AmbientOcclusion))
+                context.PushDebugOverlay(cmd, m_Result.id, m_PropertySheet, (int)Pass.DebugOverlay);
         }
 
         // Calculate values in _ZBuferParams (built-in shader variable)

PostProcessing/Runtime/Effects/MultiScaleVO.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace UnityEngine.Rendering.PostProcessing
 {
@@ -48,7 +48,8 @@ enum Pass
             HorizontalBlurDeferred,
             VerticalBlur,
             CompositionForward,
-            CompositionDeferred
+            CompositionDeferred,
+            DebugOverlay
         }
 
         public DepthTextureMode GetCameraFlags()
@@ -147,6 +148,9 @@ void Render(PostProcessRenderContext context, CommandBuffer cmd, int occlusionSo
             // Separable blur (vertical pass)
             cmd.BlitFullscreenTriangle(rtBlur, m_Result, sheet, (int)Pass.VerticalBlur);
             cmd.ReleaseTemporaryRT(rtBlur);
+
+            if (context.IsDebugOverlayEnabled(DebugOverlay.AmbientOcclusion))
+                context.PushDebugOverlay(cmd, m_Result, sheet, (int)Pass.DebugOverlay);
         }
 
         public void RenderAfterOpaque(PostProcessRenderContext context)

PostProcessing/Runtime/Effects/ScalableAO.cs

@@ -1,40 +1,113 @@
-namespace UnityEngine.Rendering.PostProcessing
+namespace UnityEngine.Rendering.PostProcessing
 {
     [ExecuteInEditMode]
     public sealed class PostProcessDebug : MonoBehaviour
     {
         public PostProcessLayer postProcessLayer;
+        PostProcessLayer m_PreviousPostProcessLayer;
 
         public bool lightMeter;
         public bool histogram;
         public bool waveform;
         public bool vectorscope;
 
+        public DebugOverlay debugOverlay = DebugOverlay.None;
+
+        Camera m_CurrentCamera;
+        CommandBuffer m_CmdAfterEverything;
+        
+        void OnEnable()
+        {
+            m_CmdAfterEverything = new CommandBuffer { name = "Post-processing Debug Overlay" };
+
+#if UNITY_EDITOR
+            // Update is only called on object change when ExecuteInEditMode is set, but we need it
+            // to execute on every frame no matter what when not in play mode, so we'll use the
+            // editor update loop instead...
+            UnityEditor.EditorApplication.update += UpdateStates;
+#endif
+        }
+
+        void OnDisable()
+        {
+#if UNITY_EDITOR
+            UnityEditor.EditorApplication.update -= UpdateStates;
+#endif
+
+            if (m_CurrentCamera != null)
+                m_CurrentCamera.RemoveCommandBuffer(CameraEvent.AfterEverything, m_CmdAfterEverything);
+
+            m_CurrentCamera = null;
+            m_PreviousPostProcessLayer = null;
+        }
+        
+#if !UNITY_EDITOR
+        void Update()
+        {
+            UpdateStates();
+        }
+#endif
+
         void Reset()
         {
             postProcessLayer = GetComponent<PostProcessLayer>();
         }
 
-        void Update()
+        void UpdateStates()
         {
-            if (lightMeter) postProcessLayer.monitors.RequestMonitorPass(MonitorType.LightMeter);
-            if (histogram) postProcessLayer.monitors.RequestMonitorPass(MonitorType.Histogram);
-            if (waveform) postProcessLayer.monitors.RequestMonitorPass(MonitorType.Waveform);
-            if (vectorscope) postProcessLayer.monitors.RequestMonitorPass(MonitorType.Vectorscope);
+            if (m_PreviousPostProcessLayer != postProcessLayer)
+            {
+                // Remove cmdbuffer from previously set camera
+                if (m_CurrentCamera != null)
+                {
+                    m_CurrentCamera.RemoveCommandBuffer(CameraEvent.AfterEverything, m_CmdAfterEverything);
+                    m_CurrentCamera = null;
+                }
+
+                m_PreviousPostProcessLayer = postProcessLayer;
+
+                // Add cmdbuffer to the currently set camera
+                if (postProcessLayer != null)
+                {
+                    m_CurrentCamera = postProcessLayer.GetComponent<Camera>();
+                    m_CurrentCamera.AddCommandBuffer(CameraEvent.AfterEverything, m_CmdAfterEverything);
+                }
+            }
+
+            if (postProcessLayer == null || !postProcessLayer.enabled)
+                return;
+
+            // Monitors
+            if (lightMeter) postProcessLayer.debugLayer.RequestMonitorPass(MonitorType.LightMeter);
+            if (histogram) postProcessLayer.debugLayer.RequestMonitorPass(MonitorType.Histogram);
+            if (waveform) postProcessLayer.debugLayer.RequestMonitorPass(MonitorType.Waveform);
+            if (vectorscope) postProcessLayer.debugLayer.RequestMonitorPass(MonitorType.Vectorscope);
+
+            // Overlay
+            postProcessLayer.debugLayer.RequestDebugOverlay(debugOverlay);
+        }
+
+        void OnPostRender()
+        {
+            m_CmdAfterEverything.Clear();
+
+            if (postProcessLayer == null || !postProcessLayer.enabled || !postProcessLayer.debugLayer.debugOverlayActive)
+                return;
+
+            m_CmdAfterEverything.Blit(postProcessLayer.debugLayer.debugOverlayTarget, BuiltinRenderTextureType.CameraTarget);
         }
 
         void OnGUI()
         {
             if (postProcessLayer == null || !postProcessLayer.enabled)
                 return;
 
-            var monitors = postProcessLayer.monitors;
             var rect = new Rect(5, 5, 0, 0);
-
-            DrawMonitor(ref rect, monitors.lightMeter, lightMeter);
-            DrawMonitor(ref rect, monitors.histogram, histogram);
-            DrawMonitor(ref rect, monitors.waveform, waveform);
-            DrawMonitor(ref rect, monitors.vectorscope, vectorscope);
+            var debugLayer = postProcessLayer.debugLayer;
+            DrawMonitor(ref rect, debugLayer.lightMeter, lightMeter);
+            DrawMonitor(ref rect, debugLayer.histogram, histogram);
+            DrawMonitor(ref rect, debugLayer.waveform, waveform);
+            DrawMonitor(ref rect, debugLayer.vectorscope, vectorscope);
         }
 
         void DrawMonitor(ref Rect rect, Monitor monitor, bool enabled)
@@ -49,4 +122,3 @@ void DrawMonitor(ref Rect rect, Monitor monitor, bool enabled)
         }
     }
 }
-