Begin to fix the color picker intensity for luxmeter (not enough precision right now)

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

             SAMPLER(sampler_DebugColorPickerTexture);
 
             float4 _ColorPickerParam; // 4 increasing threshold
-            int _ColorPickerMode;
             float3 _ColorPickerFontColor;
             float _ApplyLinearToSRGB;
             float _RequireToFlipInputTexture;
 
                 float4 result = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, input.texcoord);
 
-                float4 mousePixelCoord = _MousePixelCoord;
-                if (_RequireToFlipInputTexture > 0.0)
-                {
-                    mousePixelCoord.y = _ScreenSize.y - mousePixelCoord.y;
-                    // Note: We must not flip the mousePixelCoord.w coordinate
-                }
-
-                float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, mousePixelCoord.zw);
-                // Reverse debug exposure in order to display the real values.
-                // _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);
+                if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER && _ColorPickerMode != COLORPICKERDEBUGMODE_NONE)
+                    result.rgb = exp2(result.rgb) - 2;
-                
-                float4 finalResult = result;
-                    finalResult = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                {
+                    float4 mousePixelCoord = _MousePixelCoord;
+                    if (_RequireToFlipInputTexture > 0.0)
+                    {
+                        mousePixelCoord.y = _ScreenSize.y - mousePixelCoord.y;
+                        // Note: We must not flip the mousePixelCoord.w coordinate
+                    }
-                return finalResult;
+                    float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, mousePixelCoord.zw);
+                    // Reverse debug exposure in order to display the real values.
+                    // _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);
+                    
+                    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+                        mouseResult = exp2(mouseResult) - 2;
+
+                    result = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                }
+
+                return result;
             }
 
             ENDHLSL

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

             return mipMapDebugSettings.debugMipMapMode;
         }
 
+        public ColorPickerDebugMode GetDebugColorPickerMode()
+        {
+            return colorPickerDebugSettings.colorPickerMode;
+        }
+
         public bool IsDebugDisplayEnabled()
         {
             return materialDebugSettings.IsDebugDisplayEnabled() || lightingDebugSettings.IsDebugDisplayEnabled() || mipMapDebugSettings.IsDebugDisplayEnabled() || IsDebugFullScreenEnabled();

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

 int _DebugLightingSubMode;
 int _DebugViewMaterial; // Contain the id (define in various materialXXX.cs.hlsl) of the property to display
 int _DebugMipMapMode; // Match enum DebugMipMapMode
+int _ColorPickerMode; // Match enum ColorPickerDebugMode
 int _DebugStep;
 float4 _DebugLightingAlbedo; // x == bool override, yzw = albedo for diffuse
 float4 _DebugLightingSmoothness; // x == bool override, y == override value

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

         {
         case DEBUGLIGHTINGMODE_LUX_METER:
             diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
+
+            if (_ColorPickerMode != COLORPICKERDEBUGMODE_NONE)
+                diffuseLighting = log2(diffuseLighting + 2);
+            
             specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
             break;
 

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

                 cmd.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingMode());
                 cmd.SetGlobalInt(HDShaderIDs._DebugLightingSubMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingSubMode());
                 cmd.SetGlobalInt(HDShaderIDs._DebugMipMapMode, (int)m_CurrentDebugDisplaySettings.GetDebugMipMapMode());
+                cmd.SetGlobalInt(HDShaderIDs._ColorPickerMode, (int)m_CurrentDebugDisplaySettings.GetDebugColorPickerMode());
 
                 cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
                 cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
                     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);
-                    m_DebugColorPicker.SetInt(HDShaderIDs._ColorPickerMode, (int)colorPickerDebugSettings.colorPickerMode);
                     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,