Merge pull request #811 from Unity-Technologies/Add-physical-Light-unit-2

Add color picker debug mode

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

         {
             // We should have the option to clear mip maps here, but since RenderTargetIdentifier, we can't know the number to clear...
             // So for now, we won't do it.
-            for(int i = 0; i < 6; ++i)
+            for (int i = 0; i < 6; ++i)
                 SetRenderTarget(cmd, buffer, ClearFlag.Color, clearColor, 0, (CubemapFace)i);
         }
 
 
             for (int i = 0; i < 6; ++i)
             {
-                for (int mip = 0; mip < mipCount; ++ mip )
+                for (int mip = 0; mip < mipCount; ++mip)
                 {
                     SetRenderTarget(cmd, new RenderTargetIdentifier(renderTexture), ClearFlag.Color, clearColor, mip, (CubemapFace)i);
                 }
                     {
                         innerTypes = t.GetTypes();
                     }
-                    catch {}
+                    catch { }
                     return innerTypes;
                 });
         }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Color.hlsl

 // with rgb in linear space with sRGB primaries and D65 white point
 real Luminance(real3 linearRgb)
 {
-    return dot(linearRgb, real3(0.2126729f, 0.7151522f, 0.0721750f));
+    return dot(linearRgb, real3(0.2126729, 0.7151522, 0.0721750));
 }
 
 real Luminance(real4 linearRgba)

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

 
     float4 colors[6] = {
         float4(0.0, 0.0, 1.0, 0.8), // 0 BLUE = too little texture detail
-        float4(0.0, 0.5, 1.0, 0.4), // 1 
+        float4(0.0, 0.5, 1.0, 0.4), // 1
         float4(1.0, 1.0, 1.0, 0.0), // 2 = optimal level
         float4(1.0, 0.7, 0.0, 0.2), // 3 (YELLOW tint)
         float4(1.0, 0.3, 0.0, 0.6), // 4 (clamped mipLevel 4.9999)
     return float3(1.0, 0.0, 1.0);
 }
 
-#ifdef DEBUG_DISPLAY
-float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
+// Convert an arbitrary range to color base on threshold provide to the function, threshold must be in growing order
+real3 GetColorCodeFunction(real value, real4 threshold)
-    switch (paramId)
+    const real3 red = { 1.0, 0.0, 0.0 };
+    const real3 lightGreen = { 0.5, 1.0, 0.5 };
+    const real3 darkGreen = { 0.1, 1.0, 0.1 };
+    const real3 yellow = { 1.0, 1.0, 0.0 };
+
+    real3 outColor = red;
+    if (value < threshold[0])
+    {
+        outColor = red;
+    }
+    else if (value >= threshold[0] && value < threshold[1])
+    {
+        real scale = (value - threshold[0]) / (threshold[1] - threshold[0]);
+        outColor = lerp(red, darkGreen, scale);
+    }
+    else if (value >= threshold[1] && value < threshold[2])
+    {
+        real scale = (value - threshold[1]) / (threshold[2] - threshold[1]);
+        outColor = lerp(darkGreen, lightGreen, scale);
+    }
+    else if (value >= threshold[2] && value < threshold[3])
-    case DEBUGMIPMAPMODE_MIP_RATIO:
-        return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
-    case DEBUGMIPMAPMODE_MIP_COUNT:
-        return GetDebugMipCountColor(originalColor, tex);
-    case DEBUGMIPMAPMODE_MIP_COUNT_REDUCTION:
-        return GetDebugMipReductionColor(tex, mipInfo);
-    case DEBUGMIPMAPMODE_STREAMING_MIP_BUDGET:
-        return GetDebugStreamingMipColor(tex, mipInfo);
-    case DEBUGMIPMAPMODE_STREAMING_MIP:
-        return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
+        real scale = (value - threshold[2]) / (threshold[2] - threshold[2]);
+        outColor = lerp(lightGreen, yellow, scale);
+    }
+    else
+    {
+        outColor = yellow;
-    return originalColor;
+    return outColor;
-#endif // DEBUG_DISPLAY
 
 #endif // UNITY_DEBUG_INCLUDED

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

     public enum FullScreenDebugMode
     {
         None,
+
         // Lighting
         MinLightingFullScreenDebug,
         SSAO,
         public MaterialDebugSettings materialDebugSettings = new MaterialDebugSettings();
         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
         public MipMapDebugSettings mipMapDebugSettings = new MipMapDebugSettings();
+        public ColorPickerDebugSettings colorPickerDebugSettings = new ColorPickerDebugSettings();
 
         public static GUIContent[] lightingFullScreenDebugStrings = null;
         public static int[] lightingFullScreenDebugValues = null;
 
             DebugMenuManager.instance.AddDebugItem<int>("Rendering", kFullScreenDebugMode, () => (int)fullScreenDebugMode, (value) => fullScreenDebugMode = (FullScreenDebugMode)value, DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.renderingFullScreenDebugStrings, DebugDisplaySettings.renderingFullScreenDebugValues));
             DebugMenuManager.instance.AddDebugItem<DebugMipMapMode>("Rendering", "MipMaps", () => mipMapDebugSettings.debugMipMapMode, (value) => SetMipMapMode((DebugMipMapMode)value));
+
+            DebugMenuManager.instance.AddDebugItem<ColorPickerDebugMode>("Rendering", ColorPickerDebugSettings.kColorPickerDebugMode, () => (int)colorPickerDebugSettings.colorPickerMode, (value) => colorPickerDebugSettings.colorPickerMode = (ColorPickerDebugMode)value);
+            DebugMenuManager.instance.AddDebugItem<float>("Rendering", ColorPickerDebugSettings.kColorPickerThreshold0Debug, () => colorPickerDebugSettings.colorThreshold0, (value) => colorPickerDebugSettings.colorThreshold0 = (float)value);
+            DebugMenuManager.instance.AddDebugItem<float>("Rendering", ColorPickerDebugSettings.kColorPickerThreshold1Debug, () => colorPickerDebugSettings.colorThreshold1, (value) => colorPickerDebugSettings.colorThreshold1 = (float)value);
+            DebugMenuManager.instance.AddDebugItem<float>("Rendering", ColorPickerDebugSettings.kColorPickerThreshold2Debug, () => colorPickerDebugSettings.colorThreshold2, (value) => colorPickerDebugSettings.colorThreshold2 = (float)value);
+            DebugMenuManager.instance.AddDebugItem<float>("Rendering", ColorPickerDebugSettings.kColorPickerThreshold3Debug, () => colorPickerDebugSettings.colorThreshold3, (value) => colorPickerDebugSettings.colorThreshold3 = (float)value);
+            DebugMenuManager.instance.AddDebugItem<Color>("Rendering", ColorPickerDebugSettings.kColorPickerFontColor, () => colorPickerDebugSettings.fontColor, (value) => colorPickerDebugSettings.fontColor = (Color)value);
+
         }
 
         public void OnValidate()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 #ifndef UNITY_DEBUG_DISPLAY_INCLUDED
 #define UNITY_DEBUG_DISPLAY_INCLUDED
 
+#include "CoreRP/ShaderLibrary/Debug.hlsl"
+#include "ColorPickerDebug.cs.hlsl"
 
 // Set of parameters available when switching to debug shader mode
 int _DebugLightingMode; // Match enum DebugLightingMode
 float4 _DebugLightingSmoothness; // x == bool override, y == override value
+float4 _MousePixelCoord;  // xy unorm, zw norm
+
+TEXTURE2D(_DebugFont); // Debug font to write string in shader
 
 void GetPropertiesDataDebug(uint paramId, inout float3 result, inout bool needLinearToSRGB)
 {
             break;
 
     }
+}
+
+float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
+{
+    switch (paramId)
+    {
+    case DEBUGMIPMAPMODE_MIP_RATIO:
+        return GetDebugMipColorIncludingMipReduction(originalColor, tex, texelSize, uv, mipInfo);
+    case DEBUGMIPMAPMODE_MIP_COUNT:
+        return GetDebugMipCountColor(originalColor, tex);
+    case DEBUGMIPMAPMODE_MIP_COUNT_REDUCTION:
+        return GetDebugMipReductionColor(tex, mipInfo);
+    case DEBUGMIPMAPMODE_STREAMING_MIP_BUDGET:
+        return GetDebugStreamingMipColor(tex, mipInfo);
+    case DEBUGMIPMAPMODE_STREAMING_MIP:
+        return GetDebugStreamingMipColorBlended(originalColor, tex, mipInfo);
+    }
+
+    return originalColor;
+}
+
+// DebugFont code assume black and white font with texture size 256x128 with bloc of 16x16
+#define DEBUG_FONT_TEXT_WIDTH	16
+#define DEBUG_FONT_TEXT_HEIGHT	16
+#define DEBUG_FONT_TEXT_COUNT_X	16
+#define DEBUG_FONT_TEXT_COUNT_Y	8
+#define DEBUG_FONT_TEXT_ASCII_START 32
+
+// Only support ASCII symbol from DEBUG_FONT_TEXT_ASCII_START to 126
+// return black or white depends if we hit font character or not
+// currentUnormCoord is current unormalized screen position
+// fixedUnormCoord is the position where we want to draw something, this will be incremented by block font size in provided direction
+// color is current screen color
+// color of the font to use
+// direction is 1 or -1 and indicate fixedUnormCoord block shift
+void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color, int direction)
+{
+    // Are we inside a font display block on the screen ?
+    uint2 localCharCoord = currentUnormCoord - fixedUnormCoord;
+    if (localCharCoord.x >= 0 && localCharCoord.x < DEBUG_FONT_TEXT_WIDTH && localCharCoord.y >= 0 && localCharCoord.y < DEBUG_FONT_TEXT_HEIGHT)
+    {
+        #if UNITY_UV_STARTS_AT_TOP
+        localCharCoord.y = DEBUG_FONT_TEXT_HEIGHT - localCharCoord.y;
+        #endif
+
+        asciiValue -= DEBUG_FONT_TEXT_ASCII_START; // Our font start at ASCII table 32;
+        uint2 asciiCoord = uint2(asciiValue % DEBUG_FONT_TEXT_COUNT_X, asciiValue / DEBUG_FONT_TEXT_COUNT_X);
+        // Unorm coordinate inside the font texture
+        uint2 unormTexCoord = asciiCoord * uint2(DEBUG_FONT_TEXT_WIDTH, DEBUG_FONT_TEXT_HEIGHT) + localCharCoord;
+        // normalized coordinate
+        float2 normTexCoord = float2(unormTexCoord) / float2(DEBUG_FONT_TEXT_WIDTH * DEBUG_FONT_TEXT_COUNT_X, DEBUG_FONT_TEXT_HEIGHT * DEBUG_FONT_TEXT_COUNT_Y);
+
+        #if UNITY_UV_STARTS_AT_TOP
+        normTexCoord.y = 1.0 - normTexCoord.y;
+        #endif
+
+        float charColor = SAMPLE_TEXTURE2D_LOD(_DebugFont, s_point_clamp_sampler, normTexCoord, 0).r;
+        color = color * (1.0 - charColor) + charColor * fontColor;
+    }
+
+    fixedUnormCoord.x += DEBUG_FONT_TEXT_WIDTH * direction;
+}
+
+// Shortcut to not have to file direction
+void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+{
+    DrawCharacter(asciiValue, fontColor, currentUnormCoord, fixedUnormCoord, color, 1);
+}
+
+// Draw a signed integer
+// Can't display more than 16 digit
+void DrawInteger(int intValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+{
+    const uint maxStringSize = 16;
+
+    int absIntValue = abs(intValue);
+
+    // 1. Get size of the number of display
+    int numEntries = min((intValue == 0 ? 0 : log10(absIntValue)) + (intValue < 0 ? 1 : 0), maxStringSize);
+
+    // 2. Shift curseur to last location as we will go reverse
+    fixedUnormCoord.x += numEntries * DEBUG_FONT_TEXT_WIDTH;
+
+    // 3. Display the number
+    for (uint i = 0; i < maxStringSize; ++i)
+    {
+        // Numeric value incurrent font start on the second row at 0
+        DrawCharacter((absIntValue % 10) + '0', fontColor, currentUnormCoord, fixedUnormCoord, color, -1);
+        if (absIntValue  < 10)
+            break;
+        absIntValue /= 10;
+    }
+
+    // 4. Display sign
+    if (intValue < 0)
+    {
+        DrawCharacter('-', fontColor, currentUnormCoord, fixedUnormCoord, color, -1);
+    }
+
+    // 5. Reset cursor at end location
+    fixedUnormCoord.x += (numEntries + 2) * DEBUG_FONT_TEXT_WIDTH;
+}
+
+void DrawFloat(float floatValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+{
+    int intValue = int(floatValue);
+    DrawInteger(intValue, fontColor, currentUnormCoord, fixedUnormCoord, color);
+    DrawCharacter('.', fontColor, currentUnormCoord, fixedUnormCoord, color);
+    int fracValue = int(frac(floatValue) * 1e6); // 6 digit
+    DrawInteger(fracValue, fontColor, currentUnormCoord, fixedUnormCoord, color);
 }
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

             #pragma fragment Frag
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
-            #include "../Debug/DebugDisplay.cs.hlsl"
+            #include "../Debug/DebugDisplay.cs.hlsl"
 
             TEXTURE2D(_DebugFullScreenTexture);
             SAMPLER(sampler_DebugFullScreenTexture);
             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID);
+                output.texcoord = GetFullScreenTriangleTexCoord(input.vertexID);
 
                 return output;
             }
                 }
                 if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_NAN_TRACKER)
                 {
-                #if UNITY_UV_STARTS_AT_TOP
+                    #if UNITY_UV_STARTS_AT_TOP
-                #endif
+                    #endif
 
                     float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

 
             uint _ViewTilesFlags;
             uint _NumTiles;
-            float2 _MousePixelCoord;
+            float4 _MousePixelCoord; // xy unorm, zw norm
 
             StructuredBuffer<uint> g_TileList;
             Buffer<uint> g_DispatchIndirectBuffer;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs

         None,
         DiffuseLighting,
         SpecularLighting,
+        LuxMeter,
         VisualizeCascade,
         IndirectDiffuseOcclusionFromSsao,
         IndirectDiffuseGtaoFromSsao,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs.hlsl

 #define DEBUGLIGHTINGMODE_NONE (0)
 #define DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING (1)
 #define DEBUGLIGHTINGMODE_SPECULAR_LIGHTING (2)
-#define DEBUGLIGHTINGMODE_VISUALIZE_CASCADE (3)
-#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO (4)
-#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_GTAO_FROM_SSAO (5)
-#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION_FROM_SSAO (6)
-#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO (7)
+#define DEBUGLIGHTINGMODE_LUX_METER (3)
+#define DEBUGLIGHTINGMODE_VISUALIZE_CASCADE (4)
+#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO (5)
+#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_GTAO_FROM_SSAO (6)
+#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION_FROM_SSAO (7)
+#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO (8)
 
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");
                 newAsset.defaultShader = Load<Shader>(HDRenderPipelinePath + "Material/Lit/Lit.shader");
 
+                newAsset.debugFontTexture = Load<Texture2D>(HDRenderPipelinePath + "RenderPipelineResources/DebugFont.tga");
+                newAsset.debugColorPickerShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugColorPicker.Shader");
 
                 newAsset.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
                 newAsset.gaussianPyramidCS = Load<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.Styles.cs

     {
         sealed class Styles
         {
-            // Base
+            // Base (copy from LightEditor.cs)
             public readonly GUIContent cookieSizeX = new GUIContent("Size X", "Controls the size of the cookie mask currently assigned to the light.");
             public readonly GUIContent cookieSizeY = new GUIContent("Size Y", "Controls the size of the cookie mask currently assigned to the light.");
             public readonly GUIContent shadowBias = new GUIContent("Bias", "Controls the distance at which the shadows will be pushed away from the light. Useful for avoiding false self-shadowing artifacts.");
             public readonly GUIContent bakedShadowAngle = new GUIContent("Baked Shadow Angle", "Controls the amount of artificial softening applied to the edges of shadows cast by directional lights.");
+            public readonly GUIContent lightBounceIntensity = new GUIContent("Indirect Multiplier", "Controls the intensity of indirect light being contributed to the scene. A value of 0 will cause Realtime lights to be removed from realtime global illumination and Baked and Mixed lights to no longer emit indirect lighting. Has no effect when both Realtime and Baked Global Illumination are disabled.");
+            public readonly GUIContent indirectBounceShadowWarning = new GUIContent("Realtime indirect bounce shadowing is not supported for Spot and Point lights.");
+
             public readonly GUIContent maxSmoothness = new GUIContent("Max Smoothness", "Very low cost way of faking spherical area lighting. This will modify the roughness of the material lit. This is useful when the specular highlight is too small or too sharp.");
             public readonly GUIContent affectDiffuse = new GUIContent("Affect Diffuse", "This will disable diffuse lighting for this light. Doesn't save performance, diffuse lighting is still computed.");
             public readonly GUIContent affectSpecular = new GUIContent("Affect Specular", "This will disable specular lighting for this light. Doesn't save performance, specular lighting is still computed.");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 using System;
 using System.Diagnostics;
 using UnityEngine.Rendering.PostProcessing;
         };
 
         static readonly RenderQueueRange k_RenderQueue_PreRefraction = new RenderQueueRange { min = (int)HDRenderQueue.PreRefraction, max = (int)HDRenderQueue.Transparent - 1 };
-        static readonly RenderQueueRange k_RenderQueue_Transparent = new RenderQueueRange { min = (int)HDRenderQueue.Transparent, max = (int)HDRenderQueue.Overlay - 1};
+        static readonly RenderQueueRange k_RenderQueue_Transparent = new RenderQueueRange { min = (int)HDRenderQueue.Transparent, max = (int)HDRenderQueue.Overlay - 1 };
         static readonly RenderQueueRange k_RenderQueue_AllTransparent = new RenderQueueRange { min = (int)HDRenderQueue.PreRefraction, max = (int)HDRenderQueue.Overlay - 1 };
 
         readonly HDRenderPipelineAsset m_Asset;
         Material m_currentDebugViewMaterialGBuffer;
         Material m_DebugDisplayLatlong;
         Material m_DebugFullScreen;
+        Material m_DebugColorPicker;
         Material m_Blit;
         Material m_ErrorMaterial;
 
         RenderTargetIdentifier m_CameraStencilBufferCopyRT;
 
         // The pass "SRPDefaultUnlit" is a fall back to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
-        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName};
-        ShaderPassName[] m_ForwardOnlyPassNames = { new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName};
+        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
+        ShaderPassName[] m_ForwardOnlyPassNames = { new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
 
         ShaderPassName[] m_AllTransparentPassNames = {  HDShaderPassNames.s_TransparentBackfaceName,
                                                         HDShaderPassNames.s_ForwardOnlyName,
         [Flags]
         public enum StencilBitMask
         {
-            Clear          = 0,              // 0x0
-            LightingMask   = 7,              // 0x7  - 3 bit
-            ObjectVelocity = 128,            // 0x80 - 1 bit
-            All            = 255             // 0xFF - 8 bit
+            Clear           = 0,             // 0x0
+            LightingMask    = 7,             // 0x7  - 3 bit
+            ObjectVelocity  = 128,           // 0x80 - 1 bit
+            All             = 255            // 0xFF - 8 bit
         }
 
         RenderStateBlock m_DepthStateOpaque;
 
         FrameSettings m_FrameSettings; // Init every frame
 
+        // For debug
+        int m_DebugColorPickerRT;
         int m_DebugFullScreenTempRT;
         bool m_FullScreenDebugPushed;
 
             // whereas it work. Don't know what is happening, DebugDisplay use the same code and name is correct there.
             // Debug.Assert(m_DeferredMaterial != null);
 
-            m_CameraColorBuffer                = HDShaderIDs._CameraColorTexture;
-            m_CameraColorBufferRT              = new RenderTargetIdentifier(m_CameraColorBuffer);
-            m_CameraSssDiffuseLightingBuffer   = HDShaderIDs._CameraSssDiffuseLightingBuffer;
+            m_CameraColorBuffer = HDShaderIDs._CameraColorTexture;
+            m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
+            m_CameraSssDiffuseLightingBuffer = HDShaderIDs._CameraSssDiffuseLightingBuffer;
             m_CameraSssDiffuseLightingBufferRT = new RenderTargetIdentifier(m_CameraSssDiffuseLightingBuffer);
 
             m_SSSBufferManager.Build(asset);
 
             m_DebugDisplaySettings.RegisterDebug();
             FrameSettings.RegisterDebug("Default Camera", m_Asset.GetFrameSettings());
+
+            m_DebugColorPickerRT = HDShaderIDs._DebugColorPickerTexture;
+
+            // For debugging
+            MousePositionDebug.instance.Build();
 
             InitializeRenderStateBlocks();
         }
             m_DebugViewMaterialGBufferShadowMask.EnableKeyword("SHADOWS_SHADOWMASK");
             m_DebugDisplayLatlong = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugDisplayLatlongShader);
             m_DebugFullScreen = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugFullScreenShader);
+            m_DebugColorPicker = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugColorPickerShader);
             m_Blit = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.blit);
             m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
         }
 
             m_LightLoop.Cleanup();
 
+            // For debugging
+            MousePositionDebug.instance.Cleanup();
+
             m_MaterialList.ForEach(material => material.Cleanup());
 
             CoreUtils.Destroy(m_CopyStencilForNoLighting);
             CoreUtils.Destroy(m_DebugViewMaterialGBufferShadowMask);
             CoreUtils.Destroy(m_DebugDisplayLatlong);
             CoreUtils.Destroy(m_DebugFullScreen);
+            CoreUtils.Destroy(m_DebugColorPicker);
             CoreUtils.Destroy(m_Blit);
             CoreUtils.Destroy(m_ErrorMaterial);
 
         {
             // For now we consider only PS4 to be able to read from a bound depth buffer.
             // TODO: test/implement for other platforms.
-            return  SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
+            return SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
                     SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
                     SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12;
         }
                         using (new ProfilingSample(cmd, "Volume Update", CustomSamplerId.VolumeUpdate.GetSampler()))
                         {
                             LayerMask layerMask = -1;
-                            if(additionalCameraData != null)
+                            if (additionalCameraData != null)
                             {
                                 layerMask = additionalCameraData.volumeLayerMask;
                             }
                                 // This is arbitrary and should be editable in the scene view somehow.
-                                if(camera.cameraType == CameraType.SceneView)
+                                if (camera.cameraType == CameraType.SceneView)
                                 {
                                     layerMask = (-1 & ~m_Asset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask);
                                 }
                     }
 
-                    ApplyDebugDisplaySettings(cmd);
+                    var postProcessLayer = camera.GetComponent<PostProcessLayer>();
+                    var hdCamera = HDCamera.Get(camera, postProcessLayer, m_FrameSettings);
+
+                    Resize(hdCamera);
+
+
+                    ApplyDebugDisplaySettings(hdCamera, cmd);
                     UpdateShadowSettings();
 
                     // TODO: Float HDCamera setup higher in order to pass stereo into GetCullingParameters
                         continue;
                     }
 
-                    m_LightLoop.UpdateCullingParameters( ref cullingParams );
+                    m_LightLoop.UpdateCullingParameters(ref cullingParams);
 
 #if UNITY_EDITOR
                     // emit scene view UI
                     }
 #endif
                     // decal system needs to be updated with current camera
-					if (m_FrameSettings.enableDBuffer)
-						DecalSystem.instance.BeginCull(camera);
+                    if (m_FrameSettings.enableDBuffer)
+                        DecalSystem.instance.BeginCull(camera);
-                        CullResults.Cull(ref cullingParams, renderContext,ref m_CullResults);
+                        CullResults.Cull(ref cullingParams, renderContext, ref m_CullResults);
                     }
 
                     m_DbufferManager.vsibleDecalCount = 0;
                         DecalSystem.instance.EndCull();
                     }
 
-                    var postProcessLayer = camera.GetComponent<PostProcessLayer>();
-                    var hdCamera = HDCamera.Get(camera, postProcessLayer, m_FrameSettings);
-
-                    Resize(hdCamera);
-
                     if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                     {
                         m_CurrentDebugDisplaySettings.UpdateMaterials();
                     }
                     ConfigureForShadowMask(enableBakeShadowMask, cmd);
 
-	                InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
+                    InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
 
                     bool forcePrepassForDecals = m_DbufferManager.vsibleDecalCount > 0;
                     RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, forcePrepassForDecals);
                     if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
                     {
                         RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext, cmd);
+
+                        PushColorPickerDebugTexture(cmd, m_CameraColorBufferRT, hdCamera);
                     }
                     else
                     {
                             cmd.ReleaseTemporaryRT(m_DeferredShadowBuffer);
                             CoreUtils.CreateCmdTemporaryRT(cmd, m_DeferredShadowBuffer, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, true);
                             m_LightLoop.RenderDeferredDirectionalShadow(hdCamera, m_DeferredShadowBufferRT, GetDepthTexture(), cmd);
-                            PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera, renderContext, FullScreenDebugMode.DeferredShadows);
+                            PushFullScreenDebugTexture(cmd, m_DeferredShadowBuffer, hdCamera, FullScreenDebugMode.DeferredShadows);
-  	                    // TODO: Move this code inside LightLoop
+                        // TODO: Move this code inside LightLoop
                         if (m_LightLoop.GetFeatureVariantsEnabled())
                         {
                             // For material classification we use compute shader and so can't read into the stencil, so prepare it.
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
                         RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.PreRefraction);
 
-                        RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.PreRefractionColorPyramid);
+                        RenderGaussianPyramidColor(camera, cmd, renderContext, true);
 
                         // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         RenderTransparentDepthPostpass(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);
 
-                        PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, renderContext, FullScreenDebugMode.NanTracker);
+                        PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, FullScreenDebugMode.NanTracker);
-                        RenderGaussianPyramidColor(camera, cmd, renderContext, FullScreenDebugMode.FinalColorPyramid);
+                        RenderGaussianPyramidColor(camera, cmd, renderContext, false);
+                        PushColorPickerDebugTexture(cmd, m_CameraColorBufferRT, hdCamera);
+
                         // Final blit
                         if (m_FrameSettings.enablePostprocess && CoreUtils.IsPostProcessingActive(postProcessLayer))
                         {
             } // For each camera
         }
 
-        void RenderOpaqueRenderList(CullResults             cull,
-                                    Camera                  camera,
+        void RenderOpaqueRenderList(CullResults cull,
+                                    Camera camera,
-                                    CommandBuffer           cmd,
-                                    ShaderPassName          passName,
-                                    RendererConfiguration   rendererConfiguration = 0,
-                                    RenderQueueRange?       inRenderQueueRange = null,
-                                    RenderStateBlock?       stateBlock = null,
-                                    Material                overrideMaterial = null)
+                                    CommandBuffer cmd,
+                                    ShaderPassName passName,
+                                    RendererConfiguration rendererConfiguration = 0,
+                                    RenderQueueRange? inRenderQueueRange = null,
+                                    RenderStateBlock? stateBlock = null,
+                                    Material overrideMaterial = null)
-        void RenderOpaqueRenderList(CullResults             cull,
-                                    Camera                  camera,
+        void RenderOpaqueRenderList(CullResults cull,
+                                    Camera camera,
-                                    CommandBuffer           cmd,
-                                    ShaderPassName[]        passNames,
-                                    RendererConfiguration   rendererConfiguration = 0,
-                                    RenderQueueRange?       inRenderQueueRange = null,
-                                    RenderStateBlock?       stateBlock = null,
-                                    Material                overrideMaterial = null)
+                                    CommandBuffer cmd,
+                                    ShaderPassName[] passNames,
+                                    RendererConfiguration rendererConfiguration = 0,
+                                    RenderQueueRange? inRenderQueueRange = null,
+                                    RenderStateBlock? stateBlock = null,
+                                    Material overrideMaterial = null)
         {
             if (!m_FrameSettings.enableOpaqueObjects)
                 return;
                 renderQueueRange = inRenderQueueRange == null ? RenderQueueRange.opaque : inRenderQueueRange.Value
             };
 
-            if(stateBlock == null)
+            if (stateBlock == null)
-        void RenderTransparentRenderList(CullResults             cull,
-                                         Camera                  camera,
+        void RenderTransparentRenderList(CullResults cull,
+                                         Camera camera,
-                                         CommandBuffer           cmd,
-                                         ShaderPassName          passName,
-                                         RendererConfiguration   rendererConfiguration = 0,
-                                         RenderQueueRange?       inRenderQueueRange = null,
-                                         RenderStateBlock?       stateBlock = null,
-                                         Material                overrideMaterial = null)
+                                         CommandBuffer cmd,
+                                         ShaderPassName passName,
+                                         RendererConfiguration rendererConfiguration = 0,
+                                         RenderQueueRange? inRenderQueueRange = null,
+                                         RenderStateBlock? stateBlock = null,
+                                         Material overrideMaterial = null)
         {
             m_SinglePassName[0] = passName;
             RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName,
-        void RenderTransparentRenderList(CullResults             cull,
-                                         Camera                  camera,
+        void RenderTransparentRenderList(CullResults cull,
+                                         Camera camera,
-                                         CommandBuffer           cmd,
-                                         ShaderPassName[]        passNames,
-                                         RendererConfiguration   rendererConfiguration = 0,
-                                         RenderQueueRange?       inRenderQueueRange = null,
-                                         RenderStateBlock?       stateBlock = null,
-                                         Material                overrideMaterial = null
+                                         CommandBuffer cmd,
+                                         ShaderPassName[] passNames,
+                                         RendererConfiguration rendererConfiguration = 0,
+                                         RenderQueueRange? inRenderQueueRange = null,
+                                         RenderStateBlock? stateBlock = null,
+                                         Material overrideMaterial = null
                                          )
         {
             if (!m_FrameSettings.enableTransparentObjects)
                 renderQueueRange = inRenderQueueRange == null ? k_RenderQueue_AllTransparent : inRenderQueueRange.Value
             };
 
-            if(stateBlock == null)
+            if (stateBlock == null)
                 renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
             else
                 renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, stateBlock.Value);
             using (new ProfilingSample(cmd, addAlphaTestedOnly ? "Depth Prepass alpha test" : "Depth Prepass", CustomSamplerId.DepthPrepass.GetSampler()))
             {
                 CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
-				if (forcePrepass || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
+                if (forcePrepass || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
                 {
                     // We render first the opaque object as opaque alpha tested are more costly to render and could be reject by early-z (but not Hi-z as it is disable with clip instruction)
                     // This is handled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
                 {
                     if (m_FrameSettings.enableDepthPrepassWithDeferredRendering)
                     {
-                        var rangeOpaqueNoAlphaTest = new RenderQueueRange { min = (int)RenderQueue.Geometry,  max = (int)RenderQueue.AlphaTest - 1    };
-                        var rangeOpaqueAlphaTest   = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
+                        var rangeOpaqueNoAlphaTest = new RenderQueueRange { min = (int)RenderQueue.Geometry, max = (int)RenderQueue.AlphaTest - 1 };
+                        var rangeOpaqueAlphaTest = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
 
                         // When using depth prepass for opaque alpha test only we need to use regular depth test for normal opaque objects.
                         RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_FrameSettings.enableAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
                 cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
 
                 CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-				DecalSystem.instance.Render(renderContext, camera, cmd);
+                DecalSystem.instance.Render(renderContext, camera, cmd);
             }
         }
 
                     CoreUtils.CreateCmdTemporaryRT(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera.renderTextureDesc, 0, FilterMode.Bilinear, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, msaaSamples: 1, enableRandomWrite: true);
                     postProcessLayer.BakeMSVOMap(cmd, camera, HDShaderIDs._AmbientOcclusionTexture, GetDepthTexture(), true);
                     cmd.SetGlobalVector(HDShaderIDs._AmbientOcclusionParam, new Vector4(settings.color.value.r, settings.color.value.g, settings.color.value.b, settings.directLightingStrength.value));
-                    PushFullScreenDebugTexture(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera, renderContext, FullScreenDebugMode.SSAO);
+                    PushFullScreenDebugTexture(cmd, HDShaderIDs._AmbientOcclusionTexture, hdCamera, FullScreenDebugMode.SSAO);
                     return;
                 }
             }
 
         void UpdateSkyEnvironment(HDCamera hdCamera, CommandBuffer cmd)
         {
-            m_SkyManager.UpdateEnvironment(hdCamera,m_LightLoop.GetCurrentSunLight(), cmd);
+            m_SkyManager.UpdateEnvironment(hdCamera, m_LightLoop.GetCurrentSunLight(), cmd);
         }
 
         void RenderSky(HDCamera hdCamera, CommandBuffer cmd)
 
                 CoreUtils.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, m_CameraDepthStencilBufferRT, null, 0);
 
-                PushFullScreenDebugTexture(cmd, m_VelocityBuffer, hdcamera, renderContext, FullScreenDebugMode.MotionVectors);
+                PushFullScreenDebugTexture(cmd, m_VelocityBuffer, hdcamera, FullScreenDebugMode.MotionVectors);
-        void RenderGaussianPyramidColor(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        void RenderGaussianPyramidColor(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
-            if (debugMode == FullScreenDebugMode.PreRefractionColorPyramid)
+            if (isPreRefraction)
-            else if (debugMode == FullScreenDebugMode.FinalColorPyramid)
+            else
             {
                 // TODO: This final Gaussian pyramid can be reuse by Bloom and SSR in the future, so disable it only if there is no postprocess AND no distortion
                 if (!m_FrameSettings.enableDistortion && !m_FrameSettings.enablePostprocess && !m_FrameSettings.enableSSR)
                 var colorPyramidDesc = m_GaussianPyramidColorBufferDesc;
                 var pyramidSideSize = GetPyramidSize(colorPyramidDesc);
 
-                // The gaussian pyramid compute works in blocks of 8x8 so make sure the last lod has a
+                // The Gaussian pyramid compute works in blocks of 8x8 so make sure the last lod has a
                 // minimum size of 8x8
                 int lodCount = Mathf.FloorToInt(Mathf.Log(pyramidSideSize, 2f) - 3f);
                 if (lodCount > HDShaderIDs._GaussianPyramidColorMips.Length)
                     last = HDShaderIDs._GaussianPyramidColorMips[i + 1];
                 }
 
-                PushFullScreenDebugTextureMip(cmd, m_GaussianPyramidColorBufferRT, lodCount, m_GaussianPyramidColorBufferDesc, debugMode);
+                PushFullScreenDebugTextureMip(cmd, m_GaussianPyramidColorBufferRT, lodCount, m_GaussianPyramidColorBufferDesc, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
 
                 cmd.SetGlobalTexture(HDShaderIDs._GaussianPyramidColorTexture, m_GaussianPyramidColorBuffer);
 
         {
             using (new ProfilingSample(cmd, "Post-processing", CustomSamplerId.PostProcessing.GetSampler()))
             {
-                    // Note: Here we don't use GetDepthTexture() to get the depth texture but m_CameraDepthStencilBuffer as the Forward transparent pass can
-                    // write extra data to deal with DOF/MB
-                    cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, m_CameraDepthStencilBuffer);
-                    cmd.SetGlobalTexture(HDShaderIDs._CameraMotionVectorsTexture, m_VelocityBufferRT);
+                // Note: Here we don't use GetDepthTexture() to get the depth texture but m_CameraDepthStencilBuffer as the Forward transparent pass can
+                // write extra data to deal with DOF/MB
+                cmd.SetGlobalTexture(HDShaderIDs._CameraDepthTexture, m_CameraDepthStencilBuffer);
+                cmd.SetGlobalTexture(HDShaderIDs._CameraMotionVectorsTexture, m_VelocityBufferRT);
-                    var context = hdcamera.postprocessRenderContext;
-                    context.Reset();
-                    context.source = m_CameraColorBufferRT;
-                    context.destination = BuiltinRenderTextureType.CameraTarget;
-                    context.command = cmd;
-                    context.camera = hdcamera.camera;
-                    context.sourceFormat = RenderTextureFormat.ARGBHalf;
-                    context.flip = true;
+                var context = hdcamera.postprocessRenderContext;
+                context.Reset();
+                context.source = m_CameraColorBufferRT;
+                context.destination = BuiltinRenderTextureType.CameraTarget;
+                context.command = cmd;
+                context.camera = hdcamera.camera;
+                context.sourceFormat = RenderTextureFormat.ARGBHalf;
+                context.flip = true;
-                    layer.Render(context);
-                }
+                layer.Render(context);
+        }
-        public void ApplyDebugDisplaySettings(CommandBuffer cmd)
+        public void ApplyDebugDisplaySettings(HDCamera hdCamera, CommandBuffer cmd)
-            m_ShadowSettings.enabled = m_FrameSettings.enableShadow;
+            if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() || 
+                m_CurrentDebugDisplaySettings.fullScreenDebugMode != FullScreenDebugMode.None ||
+                m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+            {
+                m_ShadowSettings.enabled = m_FrameSettings.enableShadow;
+
+                var lightingDebugSettings = m_CurrentDebugDisplaySettings.lightingDebugSettings;
+                var debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
+                var debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
-            var lightingDebugSettings = m_CurrentDebugDisplaySettings.lightingDebugSettings;
-            var debugAlbedo = new Vector4(lightingDebugSettings.debugLightingAlbedo.r, lightingDebugSettings.debugLightingAlbedo.g, lightingDebugSettings.debugLightingAlbedo.b, 0.0f);
-            var debugSmoothness = new Vector4(lightingDebugSettings.overrideSmoothness ? 1.0f : 0.0f, lightingDebugSettings.overrideSmoothnessValue, 0.0f, 0.0f);
+                cmd.SetGlobalInt(HDShaderIDs._DebugViewMaterial, (int)m_CurrentDebugDisplaySettings.GetDebugMaterialIndex());
+                cmd.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingMode());
+                cmd.SetGlobalInt(HDShaderIDs._DebugMipMapMode, (int)m_CurrentDebugDisplaySettings.GetDebugMipMapMode());
+                cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
-            cmd.SetGlobalInt(HDShaderIDs._DebugViewMaterial, (int)m_CurrentDebugDisplaySettings.GetDebugMaterialIndex());
-            cmd.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingMode());
-            cmd.SetGlobalInt(HDShaderIDs._DebugMipMapMode, (int)m_CurrentDebugDisplaySettings.GetDebugMipMapMode());
-            cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
-            cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
+                cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
+
+                Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(hdCamera.screenSize.y);
+                var mouseParam = new Vector4(mousePixelCoord.x, mousePixelCoord.y, mousePixelCoord.x / hdCamera.screenSize.x, mousePixelCoord.y / hdCamera.screenSize.y);
+                cmd.SetGlobalVector(HDShaderIDs._MousePixelCoord, mouseParam);
+
+                cmd.SetGlobalTexture(HDShaderIDs._DebugFont, m_Asset.renderPipelineResources.debugFontTexture);
+            }
-        public void PushFullScreenDebugTexture(CommandBuffer cb, RenderTargetIdentifier textureID, HDCamera hdCamera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        public void PushColorPickerDebugTexture(CommandBuffer cmd, RenderTargetIdentifier textureID, HDCamera hdCamera)
+        {
+            if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+            {
+                cmd.ReleaseTemporaryRT(m_DebugColorPickerRT);
+                CoreUtils.CreateCmdTemporaryRT(cmd, m_DebugColorPickerRT, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                cmd.Blit(textureID, m_DebugColorPickerRT);
+            }
+        }
+
+        public void PushFullScreenDebugTexture(CommandBuffer cmd, RenderTargetIdentifier textureID, HDCamera hdCamera, FullScreenDebugMode debugMode)
-                m_FullScreenDebugPushed = true; // We need this flag because otherwise if no fullscreen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
-                cb.ReleaseTemporaryRT(m_DebugFullScreenTempRT);
-                CoreUtils.CreateCmdTemporaryRT(cb, m_DebugFullScreenTempRT, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
-                cb.Blit(textureID, m_DebugFullScreenTempRT);
+                m_FullScreenDebugPushed = true; // We need this flag because otherwise if no full screen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
+                cmd.ReleaseTemporaryRT(m_DebugFullScreenTempRT);
+                CoreUtils.CreateCmdTemporaryRT(cmd, m_DebugFullScreenTempRT, hdCamera.renderTextureDesc, 0, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                cmd.Blit(textureID, m_DebugFullScreenTempRT);
-            var mipIndex = Mathf.FloorToInt(m_CurrentDebugDisplaySettings.fullscreenDebugMip * (lodCount));
-                m_FullScreenDebugPushed = true; // We need this flag because otherwise if no fullscreen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
+                var mipIndex = Mathf.FloorToInt(m_CurrentDebugDisplaySettings.fullscreenDebugMip * (lodCount));
+
+                m_FullScreenDebugPushed = true; // We need this flag because otherwise if no full screen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
                 cmd.ReleaseTemporaryRT(m_DebugFullScreenTempRT);
 
                 desc.width = desc.width >> mipIndex;
         }
 
         void PushFullScreenDebugDepthMip(CommandBuffer cmd, RenderTargetIdentifier textureID, int lodCount, RenderTextureDescriptor desc, FullScreenDebugMode debugMode)
-        {
-            var mipIndex = Mathf.FloorToInt(m_CurrentDebugDisplaySettings.fullscreenDebugMip * (lodCount));
+        {            
+                var mipIndex = Mathf.FloorToInt(m_CurrentDebugDisplaySettings.fullscreenDebugMip * (lodCount));
+
                 m_FullScreenDebugPushed = true; // We need this flag because otherwise if no fullscreen debug is pushed, when we render the result in RenderDebug the temporary RT will not exist.
                 cmd.ReleaseTemporaryRT(m_DebugFullScreenTempRT);
 
             }
         }
 
-        public void PushFullScreenDebugTexture(CommandBuffer cb, int textureID, HDCamera hdCamera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        public void PushFullScreenDebugTexture(CommandBuffer cb, int textureID, HDCamera hdCamera, FullScreenDebugMode debugMode)
-            PushFullScreenDebugTexture(cb, new RenderTargetIdentifier(textureID), hdCamera, renderContext, debugMode);
+            PushFullScreenDebugTexture(cb, new RenderTargetIdentifier(textureID), hdCamera, debugMode);
-        void RenderDebug(HDCamera camera, CommandBuffer cmd)
+        void RenderDebug(HDCamera hdCamera, CommandBuffer cmd)
-            if (camera.camera.cameraType == CameraType.Reflection || camera.camera.cameraType == CameraType.Preview)
+            if (hdCamera.camera.cameraType == CameraType.Reflection || hdCamera.camera.cameraType == CameraType.Preview)
                 return;
 
             using (new ProfilingSample(cmd, "Render Debug", CustomSamplerId.RenderDebug.GetSampler()))
                 {
                     m_FullScreenDebugPushed = false;
                     cmd.SetGlobalTexture(HDShaderIDs._DebugFullScreenTexture, m_DebugFullScreenTempRT);
+                    // TODO: Replace with command buffer call when available
+
+                    PushColorPickerDebugTexture(cmd, m_DebugFullScreenTempRT, hdCamera);
-                float overlaySize = Math.Min(camera.camera.pixelHeight, camera.camera.pixelWidth) * overlayRatio;
-                float y = camera.camera.pixelHeight - overlaySize;
+                float overlaySize = Math.Min(hdCamera.camera.pixelHeight, hdCamera.camera.pixelWidth) * overlayRatio;
+                float y = hdCamera.camera.pixelHeight - overlaySize;
 
                 var lightingDebug = m_CurrentDebugDisplaySettings.lightingDebugSettings;
 
                     m_SharedPropertyBlock.SetFloat(HDShaderIDs._Mipmap, lightingDebug.skyReflectionMipmap);
                     cmd.SetViewport(new Rect(x, y, overlaySize, overlaySize));
                     cmd.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, m_SharedPropertyBlock);
-                    HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.camera.pixelWidth);
+                    HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, hdCamera.camera.pixelWidth);
-                m_LightLoop.RenderDebugOverlay(camera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
+                m_LightLoop.RenderDebugOverlay(hdCamera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, hdCamera.camera.pixelWidth);
+
+                if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
+                {
+                    ColorPickerDebugSettings colorPickerDebugSettings = m_CurrentDebugDisplaySettings.colorPickerDebugSettings;
+
+                    // Here we have three cases:
+                    // - Material debug is enabled, this is the buffer we display
+                    // - Otherwise we display the HDR buffer before postprocess and distortion
+                    // - If fullscreen debug is enabled we always use it
+
+                    cmd.SetGlobalTexture(HDShaderIDs._DebugColorPickerTexture, m_DebugColorPickerRT); // 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._ColorPickerMode, (int)colorPickerDebugSettings.colorPickerMode);
+
+                    CoreUtils.DrawFullScreen(cmd, m_DebugColorPicker, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
+                }
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

 
         public static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
         public static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
+        public static readonly int _DebugFont = Shader.PropertyToID("_DebugFont");
 
         public static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
         public static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
             Shader.PropertyToID("_DepthPyramidMip13"),
             Shader.PropertyToID("_DepthPyramidMip14"),
         };
+
+        public static readonly int _DebugColorPickerTexture = Shader.PropertyToID("_DebugColorPickerTexture");
+        public static readonly int _ColorPickerParam = Shader.PropertyToID("_ColorPickerParam");
+        public static readonly int _ColorPickerMode = Shader.PropertyToID("_ColorPickerMode");
+        public static readonly int _ColorPickerFontColor = Shader.PropertyToID("_ColorPickerFontColor");
+
         public static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
         public static readonly int _BlitTexture = Shader.PropertyToID("_BlitTexture");
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

             #define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
-            #include "../Debug/DebugDisplay.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
+            #include "../Debug/DebugDisplay.hlsl"
             #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 
             //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 #define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
-#include "../../Debug/DebugDisplay.hlsl"
 
 // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
 // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
+#include "../../Debug/DebugDisplay.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
 
 //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

-using UnityEngine.Rendering;
+using System;
-using System;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
             s_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
             s_DefaultTextureCube.Apply();
 
-#if UNITY_EDITOR
-            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
-            UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
-#endif
-
             InitShadowSystem(hdAsset.GetRenderPipelineSettings().shadowInitParams, shadowSettings);
         }
 
-
-#if UNITY_EDITOR
-            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
-#endif
 
             CoreUtils.SafeRelease(s_DirectionalLightDatas);
             CoreUtils.SafeRelease(s_LightDatas);
             }
         }
 
-#if UNITY_EDITOR
-        private Vector2 m_mousePosition = Vector2.zero;
-
-        private void OnSceneGUI(UnityEditor.SceneView sceneview)
-        {
-            m_mousePosition = Event.current.mousePosition;
-        }
-
-#endif
-
         public void RenderShadows(ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults)
         {
             // kick off the shadow jobs here
                     int numTilesY = (h + 15) / 16;
                     int numTiles = numTilesX * numTilesY;
 
-                    Vector2 mousePixelCoord = Input.mousePosition;
-#if UNITY_EDITOR
-                    if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
-                    {
-                        mousePixelCoord = m_mousePosition;
-                        mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
-                    }
-#endif
+                    Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(hdCamera.screenSize.y);
 
                     // Debug tiles
                     if (lightingDebug.tileClusterDebug == LightLoop.TileClusterDebug.MaterialFeatureVariants)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.hlsl

     {
         diffuseLighting = float3(0.0, 0.0, 0.0); // Disable diffuse lighting
     }
+    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+        // Take the luminance
+        diffuseLighting = Luminance(diffuseLighting).xxx;
+    }
     else if (_DebugLightingMode == DEBUGLIGHTINGMODE_VISUALIZE_CASCADE)
     {
         specularLighting = float3(0.0, 0.0, 0.0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

         bsdfData.diffuseColor = ApplySubsurfaceScatteringTexturingMode(bsdfData.diffuseColor, bsdfData.diffusionProfile);
     }
 
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // The lighting in SH or lightmap is assume to contain bounced light only (i.e no direct lighting), and is divide by PI (i.e Lambert is apply), so multiply by PI here to get back the illuminance
+        return builtinData.bakeDiffuseLighting * PI;
+    }
+#endif
+
     // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
     return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor;
 }
     attenuation *= INV_PI * F_Transm_Schlick(0, 0.5, NdotV) * F_Transm_Schlick(0, 0.5, abs(backNdotL));
 #endif
 
-    float intensity = max(0, attenuation * backNdotL); // Warning: attenuation can be greater than 1
+    float intensity = max(0, attenuation * backNdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
     return intensity * bsdfData.transmittance;
 }
     float attenuation;
     EvaluateLight_Directional(lightLoopContext, posInput, lightData, bakeLightingData, N, L, color, attenuation);
 
-    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
     // Note: We use NdotL here to early out, but in case of clear coat this is not correct. But we are ok with this
     [branch] if (intensity > 0.0)
     lighting.diffuse  *= color;
     lighting.specular *= color;
 
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        lighting.diffuse = color * intensity * lightData.diffuseScale;;
+    }
+#endif
+
     return lighting;
 }
 
     EvaluateLight_Punctual(lightLoopContext, posInput, lightData, bakeLightingData, N, L,
                            lightToSample, distances, color, attenuation);
 
-    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1
+    float intensity = max(0, attenuation * NdotL); // Warning: attenuation can be greater than 1 due to the inverse square attenuation (when position is close to light)
 
     // Note: We use NdotL here to early out, but in case of clear coat this is not correct. But we are ok with this
     [branch] if (intensity > 0.0)
     lighting.diffuse  *= color;
     lighting.specular *= color;
 
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        lighting.diffuse = color * intensity * lightData.diffuseScale;;
+    }
+#endif
+
     return lighting;
 }
 
     lighting.diffuse *= lightData.color;
     lighting.specular *= lightData.color;
 #endif // LIT_DISPLAY_REFERENCE_AREA
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        // Apply area light on lambert then multiply by PI to cancel Lambert
+        lighting.diffuse = LTCEvaluate(P1, P2, B, k_identity3x3);
+        lighting.diffuse *= PI * lightData.diffuseScale;
+    }
+#endif
 
     return lighting;
 }
     lighting.diffuse *= lightData.color;
     lighting.specular *= lightData.color;
 #endif // LIT_DISPLAY_REFERENCE_AREA
+
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // Only lighting, not BSDF
+        // Apply area light on lambert then multiply by PI to cancel Lambert
+        lighting.diffuse = PolygonIrradiance(mul(lightVerts, k_identity3x3));
+        lighting.diffuse *= PI * lightData.diffuseScale;
+    }
+#endif
 
     return lighting;
 }
     specularLighting *= 1.0 + bsdfData.fresnel0 * preLightData.energyCompensation;
 
 #ifdef DEBUG_DISPLAY
-    if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO)
+
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
+    }
+    else if (_DebugLightingMode == DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO)
     {
         diffuseLighting = indirectAmbientOcclusion;
         specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
     type: 2}
   defaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  debugFontTexture: {fileID: 2800000, guid: a3ad2df0e49aaa341a3b3a80f93b3f66, type: 3}
   debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba,
     type: 3}
   debugViewMaterialGBufferShader: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d,
   debugFullScreenShader: {fileID: 4800000, guid: e874aca2df8300a488258738c31f85cf,
+    type: 3}
+  debugColorPickerShader: {fileID: 4800000, guid: 8137b807709e178498f22ed710864bb0,
     type: 3}
   deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
   gaussianPyramidCS: {fileID: 7200000, guid: 6dba4103d23a7904fbc49099355aff3e, type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

         public Shader defaultShader;
 
         // Debug
+        public Texture2D debugFontTexture;
+        public Shader debugColorPickerShader;
 
         // Lighting resources
         public Shader deferredShader;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 
 // These are the samplers available in the HDRenderPipeline.
 // Avoid declaring extra samplers as they are 4x SGPR each on GCN.
+SAMPLER(s_point_clamp_sampler);
 SAMPLER(s_linear_clamp_sampler);
 SAMPLER(s_trilinear_clamp_sampler);
 

ScriptableRenderPipeline/Core/CoreRP/MousePositionDebug.cs

+using System;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class MousePositionDebug
+    {
+        // Singleton
+        private static MousePositionDebug s_Instance = null;
+
+        static public MousePositionDebug instance
+        {
+            get
+            {
+                if (s_Instance == null)
+                {
+                    s_Instance = new MousePositionDebug();
+                }
+
+                return s_Instance;
+            }
+        }
+
+        private Vector2 m_mousePosition = Vector2.zero;
+
+        private void OnSceneGUI(UnityEditor.SceneView sceneview)
+        {
+            m_mousePosition = Event.current.mousePosition;
+        }
+
+        public void Build()
+        {
+#if UNITY_EDITOR
+            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+            UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
+#endif
+        }
+
+        public void Cleanup()
+        {
+#if UNITY_EDITOR
+            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+#endif
+        }
+
+        public Vector2 GetMousePosition(float ScreenHeight)
+        {
+            Vector2 mousePixelCoord = Input.mousePosition;
+#if UNITY_EDITOR
+            if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                mousePixelCoord = m_mousePosition;
+                mousePixelCoord.y = (ScreenHeight - 1.0f) - mousePixelCoord.y;
+            }
+#endif
+            return mousePixelCoord;
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/MousePositionDebug.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/ColorPickerDebug.cs

+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [GenerateHLSL]
+    public enum ColorPickerDebugMode
+    {
+        None,
+        Byte,
+        Byte4,
+        Float,
+        Float4,
+    }
+
+    [Serializable]
+    public class ColorPickerDebugSettings
+    {
+        public static string kColorPickerFontColor = "Font Color";
+        public static string kColorPickerThreshold0Debug = "Color Range Threshold 0";
+        public static string kColorPickerThreshold1Debug = "Color Range Threshold 1";
+        public static string kColorPickerThreshold2Debug = "Color Range Threshold 2";
+        public static string kColorPickerThreshold3Debug = "Color Range Threshold 3";
+        public static string kColorPickerDebugMode = "Color Picker Debug Mode";
+
+        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()
+        {
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/ColorPickerDebug.cs.hlsl

+//
+// This file was automatically generated. Please don't edit by hand.
+//
+
+#ifndef COLORPICKERDEBUG_CS_HLSL
+#define COLORPICKERDEBUG_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.ColorPickerDebugMode:  static fields
+//
+#define COLORPICKERDEBUGMODE_NONE (0)
+#define COLORPICKERDEBUGMODE_BYTE (1)
+#define COLORPICKERDEBUGMODE_BYTE4 (2)
+#define COLORPICKERDEBUGMODE_FLOAT (3)
+#define COLORPICKERDEBUGMODE_FLOAT4 (4)
+
+
+#endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/ColorPickerDebug.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 122d2ddea1c1ddc4fab6264cd6004f50
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/ColorPickerDebug.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader

+Shader "Hidden/HDRenderPipeline/DebugColorPicker"
+{
+    SubShader
+    {
+        Pass
+        {
+            ZWrite Off
+            ZTest Always
+            Blend Off
+            Cull Off
+
+            HLSLPROGRAM
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "../ShaderVariables.hlsl"
+            #include "../Debug/DebugDisplay.cs.hlsl"
+            #include "../Debug/DebugDisplay.hlsl"
+
+            TEXTURE2D(_DebugColorPickerTexture);
+            SAMPLER(sampler_DebugColorPickerTexture);
+
+            float4 _ColorPickerParam; // 4 increasing threshold
+            int _ColorPickerMode;
+            float3 _ColorPickerFontColor;
+
+            struct Attributes
+            {
+                uint vertexID : SV_VertexID;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 texcoord : TEXCOORD0;
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                Varyings output;
+                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+                output.texcoord = GetFullScreenTriangleTexCoord(input.vertexID);
+
+                return output;
+            }
+
+            float4 DisplayPixelInformationAtMousePosition(Varyings input, float4 result, float4 mouseResult)
+            {
+                if (_MousePixelCoord.z >= 0.0 && _MousePixelCoord.z <= 1.0 && _MousePixelCoord.w >= 0 && _MousePixelCoord.w <= 1.0)
+                {
+                    // Display message offset:
+                    int displayTextOffsetX = 1.5 * DEBUG_FONT_TEXT_WIDTH;
+                    #if UNITY_UV_STARTS_AT_TOP
+                    int displayTextOffsetY = -DEBUG_FONT_TEXT_HEIGHT;
+                    #else
+                    int displayTextOffsetY = DEBUG_FONT_TEXT_HEIGHT;
+                    #endif
+
+                    uint2 displayUnormCoord = uint2(_MousePixelCoord.x + displayTextOffsetX, _MousePixelCoord.y + displayTextOffsetY);
+                    uint2 unormCoord = input.positionCS.xy;
+
+                    if (_ColorPickerMode == COLORPICKERDEBUGMODE_BYTE || _ColorPickerMode == COLORPICKERDEBUGMODE_BYTE4)
+                    {
+                        uint4 mouseValue = int4(mouseResult * 255.5);
+
+                        DrawInteger(mouseValue.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+
+                        if (_ColorPickerMode == COLORPICKERDEBUGMODE_BYTE4)
+                        {
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawInteger(mouseValue.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawInteger(mouseValue.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawInteger(mouseValue.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                        }
+                    }
+                    else // float
+                    {
+                        DrawFloat(mouseResult.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                        if (_ColorPickerMode == COLORPICKERDEBUGMODE_FLOAT4)
+                        {
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawFloat(mouseResult.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawFloat(mouseResult.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.y += displayTextOffsetY;
+                            DrawFloat(mouseResult.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                        }
+                    }
+                }
+
+                return result;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                float4 result = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, input.texcoord);
+                //result.rgb = GetColorCodeFunction(result.x, _ColorPickerParam);
+                float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, _MousePixelCoord.zw);
+
+                return DisplayPixelInformationAtMousePosition(input, result, mouseResult);
+            }
+
+            ENDHLSL
+        }
+
+    }
+    Fallback Off
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader.meta

+fileFormatVersion: 2
+guid: 8137b807709e178498f22ed710864bb0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DebugFont.tga.meta

+fileFormatVersion: 2
+guid: a3ad2df0e49aaa341a3b3a80f93b3f66
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: