Merge pull request #1497 from Unity-Technologies/FalseColorMode

Added false color debug mode

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/Common.hlsl

     return (x * x) * (x * x);
 }
 
+TEMPLATE_3_FLT(RangeRemap, min, max, t, return saturate((t - min) / (max - min)))
+
 // ----------------------------------------------------------------------------
 // Texture utilities
 // ----------------------------------------------------------------------------

com.unity.render-pipelines.high-definition/CHANGELOG.md

 
 ## [2018.2 / next ]
 - Add Light -> Planar Reflection Probe command
+- Added a false color mode in rendering debug
 
 ### Improvements
 

com.unity.render-pipelines.high-definition/HDRP/Debug/ColorPickerDebug.cs

         public ColorPickerDebugMode colorPickerMode = ColorPickerDebugMode.None;
         public Color fontColor = new Color(1.0f, 0.0f, 0.0f);
 
-        public float colorThreshold0 = 0.0f;
-        public float colorThreshold1 = 200.0f;
-        public float colorThreshold2 = 9000.0f;
-        public float colorThreshold3 = 10000.0f;
-
         public void OnValidate()
         {
         }

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugColorPicker.shader

             float3 _ColorPickerFontColor;
             float _ApplyLinearToSRGB;
             float _RequireToFlipInputTexture;
+            int _FalseColor;
+            float4 _FalseColorThresholds; // 4 increasing threshold
 
             struct Attributes
             {
                 output.texcoord = GetNormalizedFullScreenTriangleTexCoord(input.vertexID);
 
                 return output;
+            }
+
+            float3 FasleColorRemap(float lum, float4 thresholds)
+            {
+                //Gradient from 0 to 240 deg of HUE gradient
+                const float l = DegToRad(240) / TWO_PI;
+
+                float t = lerp(0.0, l / 3, RangeRemap(thresholds.x, thresholds.y, lum))
+                        + lerp(0.0, l / 3, RangeRemap(thresholds.y, thresholds.z, lum))
+                        + lerp(0.0, l / 3, RangeRemap(thresholds.z, thresholds.w, lum));
+
+                return HsvToRgb(float3(l - t, 1, 1));
             }
 
             float4 DisplayPixelInformationAtMousePosition(Varyings input, float4 result, float4 mouseResult, float4 mousePixelCoord)
                 }
 
                 float4 result = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, input.texcoord);
-                //result.rgb = GetColorCodeFunction(result.x, _ColorPickerParam);
 
                 float4 mousePixelCoord = _MousePixelCoord;
                 if (_RequireToFlipInputTexture > 0.0)
                 // _DebugExposure will be set to zero if the debug view does not need it so we don't need to make a special case here. It's handled in only one place in C#
                 mouseResult = mouseResult / exp2(_DebugExposure);
 
-                float4 finalResult = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                if (_FalseColor)
+                    result.rgb = FasleColorRemap(Luminance(result.rgb), _FalseColorThresholds);
+                
+                float4 finalResult = result;
+
+                if (_ColorPickerMode != COLORPICKERDEBUGMODE_NONE)
+                    finalResult = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+
                 return finalResult;
             }
 

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.cs

         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
         public MipMapDebugSettings mipMapDebugSettings = new MipMapDebugSettings();
         public ColorPickerDebugSettings colorPickerDebugSettings = new ColorPickerDebugSettings();
+        public FalseColorDebugSettings falseColorDebugSettings = new FalseColorDebugSettings();
         public DecalsDebugSettings decalsDebugSettings = new DecalsDebugSettings();
 
         public static GUIContent[] lightingFullScreenDebugStrings = null;
             RegisterDecalsDebug();
         }
 
+        void RefreshRenderingDebug<T>(DebugUI.Field<T> field, T value)
+        {
+            UnregisterDebugItems(k_PanelRendering, m_DebugRenderingItems);
+            RegisterRenderingDebug();
+        }
+
         public void RegisterLightingDebug()
         {
             var list = new List<DebugUI.Widget>();
 
         public void RegisterRenderingDebug()
         {
-            m_DebugRenderingItems = new DebugUI.Widget[]
+            var widgetList = new List<DebugUI.Widget>();
+
+            widgetList.AddRange(new DebugUI.Widget[]
             {
                 new DebugUI.EnumField { displayName = "Fullscreen Debug Mode", getter = () => (int)fullScreenDebugMode, setter = value => fullScreenDebugMode = (FullScreenDebugMode)value, enumNames = renderingFullScreenDebugStrings, enumValues = renderingFullScreenDebugValues },
                 new DebugUI.EnumField { displayName = "MipMaps", getter = () => (int)mipMapDebugSettings.debugMipMapMode, setter = value => SetMipMapMode((DebugMipMapMode)value), autoEnum = typeof(DebugMipMapMode) },
                     children =
                     {
                         new DebugUI.EnumField  { displayName = "Debug Mode", getter = () => (int)colorPickerDebugSettings.colorPickerMode, setter = value => colorPickerDebugSettings.colorPickerMode = (ColorPickerDebugMode)value, autoEnum = typeof(ColorPickerDebugMode) },
-                        new DebugUI.FloatField { displayName = "Range Threshold 0", getter = () => colorPickerDebugSettings.colorThreshold0, setter = value => colorPickerDebugSettings.colorThreshold0 = value },
-                        new DebugUI.FloatField { displayName = "Range Threshold 1", getter = () => colorPickerDebugSettings.colorThreshold1, setter = value => colorPickerDebugSettings.colorThreshold1 = value },
-                        new DebugUI.FloatField { displayName = "Range Threshold 2", getter = () => colorPickerDebugSettings.colorThreshold2, setter = value => colorPickerDebugSettings.colorThreshold2 = value },
-                        new DebugUI.FloatField { displayName = "Range Threshold 3", getter = () => colorPickerDebugSettings.colorThreshold3, setter = value => colorPickerDebugSettings.colorThreshold3 = value },
-            };
+            });
+            
+            widgetList.Add(new DebugUI.BoolField  { displayName = "False Color Mode", getter = () => falseColorDebugSettings.falseColor, setter = value => falseColorDebugSettings.falseColor = value, onValueChanged = RefreshRenderingDebug });
+            if (falseColorDebugSettings.falseColor)
+            {
+                widgetList.Add(new DebugUI.Container{
+                    flags = DebugUI.Flags.EditorOnly,
+                    children = 
+                    {
+                        new DebugUI.FloatField { displayName = "Range Threshold 0", getter = () => falseColorDebugSettings.colorThreshold0, setter = value => falseColorDebugSettings.colorThreshold0 = Mathf.Min(value, falseColorDebugSettings.colorThreshold1) },
+                        new DebugUI.FloatField { displayName = "Range Threshold 1", getter = () => falseColorDebugSettings.colorThreshold1, setter = value => falseColorDebugSettings.colorThreshold1 = Mathf.Clamp(value, falseColorDebugSettings.colorThreshold0, falseColorDebugSettings.colorThreshold2) },
+                        new DebugUI.FloatField { displayName = "Range Threshold 2", getter = () => falseColorDebugSettings.colorThreshold2, setter = value => falseColorDebugSettings.colorThreshold2 = Mathf.Clamp(value, falseColorDebugSettings.colorThreshold1, falseColorDebugSettings.colorThreshold3) },
+                        new DebugUI.FloatField { displayName = "Range Threshold 3", getter = () => falseColorDebugSettings.colorThreshold3, setter = value => falseColorDebugSettings.colorThreshold3 = Mathf.Max(value, falseColorDebugSettings.colorThreshold2) },
+                    }
+                });
+            }
+            m_DebugRenderingItems = widgetList.ToArray();
             var panel = DebugManager.instance.GetPanel(k_PanelRendering, true);
             panel.children.Add(m_DebugRenderingItems);
         }

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

 
         public void PushColorPickerDebugTexture(CommandBuffer cmd, RTHandleSystem.RTHandle textureID, HDCamera hdCamera)
         {
-            if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+            if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None || m_DebugDisplaySettings.falseColorDebugSettings.falseColor)
             {
                 using (new ProfilingSample(cmd, "Push To Color Picker"))
                 {
         // TODO TEMP: Not sure I want to keep this special case. Gotta see how to get rid of it (not sure it will work correctly for non-full viewports.
         public void PushColorPickerDebugTexture(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier textureID)
         {
-            if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+            if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None || m_DebugDisplaySettings.falseColorDebugSettings.falseColor)
             {
                 using (new ProfilingSample(cmd, "Push To Color Picker"))
                 {
 
                 DecalSystem.instance.RenderDebugOverlay(hdCamera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, hdCamera.actualWidth);
 
-                if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+                if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None || m_CurrentDebugDisplaySettings.falseColorDebugSettings.falseColor)
+                    FalseColorDebugSettings falseColorDebugSettings = m_CurrentDebugDisplaySettings.falseColorDebugSettings;
+                    var falseColorThresholds = new Vector4(falseColorDebugSettings.colorThreshold0, falseColorDebugSettings.colorThreshold1, falseColorDebugSettings.colorThreshold2, falseColorDebugSettings.colorThreshold3);
 
                     // Here we have three cases:
                     // - Material debug is enabled, this is the buffer we display
                     cmd.SetGlobalTexture(HDShaderIDs._DebugColorPickerTexture, m_DebugColorPickerBuffer); // No SetTexture with RenderTarget identifier... so use SetGlobalTexture
                     // TODO: Replace with command buffer call when available
                     m_DebugColorPicker.SetColor(HDShaderIDs._ColorPickerFontColor, colorPickerDebugSettings.fontColor);
-                    var colorPickerParam = new Vector4(colorPickerDebugSettings.colorThreshold0, colorPickerDebugSettings.colorThreshold1, colorPickerDebugSettings.colorThreshold2, colorPickerDebugSettings.colorThreshold3);
-                    m_DebugColorPicker.SetVector(HDShaderIDs._ColorPickerParam, colorPickerParam);
+                    m_DebugColorPicker.SetInt(HDShaderIDs._FalseColorEnabled, falseColorDebugSettings.falseColor ? 1 : 0);
+                    m_DebugColorPicker.SetVector(HDShaderIDs._FalseColorThresholds, falseColorThresholds);
                     // The material display debug perform sRGBToLinear conversion as the final blit currently hardcode a linearToSrgb conversion. As when we read with color picker this is not done,
                     // we perform it inside the color picker shader. But we shouldn't do it for HDR buffer.
                     m_DebugColorPicker.SetFloat(HDShaderIDs._ApplyLinearToSRGB, m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled() ? 1.0f : 0.0f);

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDStringConstants.cs

         public static readonly int _DepthPyramidScale = Shader.PropertyToID("_DepthPyramidScale");
 
         public static readonly int _DebugColorPickerTexture = Shader.PropertyToID("_DebugColorPickerTexture");
-        public static readonly int _ColorPickerParam = Shader.PropertyToID("_ColorPickerParam");
+        public static readonly int _FalseColorEnabled = Shader.PropertyToID("_FalseColor");
+        public static readonly int _FalseColorThresholds = Shader.PropertyToID("_FalseColorThresholds");
 
         public static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
         public static readonly int _BlitTexture = Shader.PropertyToID("_BlitTexture");

com.unity.shadergraph/Editor/Data/Nodes/Utility/Logic/IsFrontFaceNode.cs

-using UnityEngine;
-using UnityEditor.Graphing;
-
-namespace UnityEditor.ShaderGraph
-{
-	[Title("Utility", "Logic", "Is Front Face")]
-	public class IsFrontFaceNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireFaceSign
-	{
-		public IsFrontFaceNode()
-		{
-			name = "Is Front Face";
-			UpdateNodeAfterDeserialization();
-		}
-
-		public override string documentationURL
-		{
-			get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Is-Front-Face-Node"; }
-		}
-
-		public override bool hasPreview { get { return false; } }
-
-		public const int OutputSlotId = 0;
-        private const string kOutputSlotName = "Out";
-
-		public override void UpdateNodeAfterDeserialization()
-        {
-            AddSlot(new BooleanMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, true, ShaderStageCapability.Fragment));
-            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
-        }
-
-        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            visitor.AddShaderChunk(string.Format("{0} {1} = max(0, IN.{2});", precision, GetVariableNameForSlot(OutputSlotId), ShaderGeneratorNames.FaceSign), true);
-        }
-
-		public bool RequiresFaceSign(ShaderStageCapability stageCapability = ShaderStageCapability.Fragment)
-		{
-			return true;
-		}
-	}
-}
+using UnityEngine;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+	[Title("Utility", "Logic", "Is Front Face")]
+	public class IsFrontFaceNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireFaceSign
+	{
+		public IsFrontFaceNode()
+		{
+			name = "Is Front Face";
+			UpdateNodeAfterDeserialization();
+		}
+
+		public override string documentationURL
+		{
+			get { return "https://github.com/Unity-Technologies/ShaderGraph/wiki/Is-Front-Face-Node"; }
+		}
+
+		public override bool hasPreview { get { return false; } }
+
+		public const int OutputSlotId = 0;
+        private const string kOutputSlotName = "Out";
+
+		public override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new BooleanMaterialSlot(OutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, true, ShaderStageCapability.Fragment));
+            RemoveSlotsNameNotMatching(new[] { OutputSlotId });
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            visitor.AddShaderChunk(string.Format("{0} {1} = max(0, IN.{2});", precision, GetVariableNameForSlot(OutputSlotId), ShaderGeneratorNames.FaceSign), true);
+        }
+
+		public bool RequiresFaceSign(ShaderStageCapability stageCapability = ShaderStageCapability.Fragment)
+		{
+			return true;
+		}
+	}
+}

com.unity.render-pipelines.high-definition/HDRP/Debug/FalseColorDebug.cs

+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class FalseColorDebugSettings
+    {
+        public bool falseColor = false;
+
+        public float colorThreshold0 = 0.0f;
+        public float colorThreshold1 = 2.0f;
+        public float colorThreshold2 = 10.0f;
+        public float colorThreshold3 = 20.0f;
+
+        public void OnValidate()
+        {
+        }
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Debug/FalseColorDebug.cs.meta

+fileFormatVersion: 2
+guid: 8fc313e69425fb44c8fa18af3761ec24
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: