Add Lux meter debug mode

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)
 
     // Can't calculate without original mip count - return magenta
     return float3(1.0, 0.0, 1.0);
-}
+}
+
+// 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)
+{
+    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 };
-#ifdef DEBUG_DISPLAY
-float3 GetTextureDataDebug(uint paramId, float2 uv, Texture2D tex, float4 texelSize, float4 mipInfo, float3 originalColor)
-{
-    switch (paramId)
+    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 static string kOverrideSmoothnessDebug = "Override Smoothness";
         public static string kOverrideSmoothnessValueDebug = "Override Smoothness Value";
         public static string kDebugLightingAlbedo = "Debug Lighting Albedo";
+        public static string kLuxMeterThreshold0Debug = "Lux Range Threshold 0";
+        public static string kLuxMeterThreshold1Debug = "Lux Range Threshold 1";
+        public static string kLuxMeterThreshold2Debug = "Lux Range Threshold 2";
+        public static string kLuxMeterThreshold3Debug = "Lux Range Threshold 3";
         public static string kFullScreenDebugMode = "Fullscreen Debug Mode";
         public static string kFullScreenDebugMip = "Fullscreen Debug Mip";
         public static string kDisplaySkyReflectionDebug = "Display Sky Reflection";
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, bool>(kOverrideSmoothnessDebug, () => lightingDebugSettings.overrideSmoothness, (value) => lightingDebugSettings.overrideSmoothness = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kOverrideSmoothnessValueDebug, () => lightingDebugSettings.overrideSmoothnessValue, (value) => lightingDebugSettings.overrideSmoothnessValue = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, Color>(kDebugLightingAlbedo, () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kLuxMeterThreshold0Debug, () => lightingDebugSettings.kLuxMeterThreshold0Debug, (value) => lightingDebugSettings.kLuxMeterThreshold0Debug = (float)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kLuxMeterThreshold1Debug, () => lightingDebugSettings.kLuxMeterThreshold1Debug, (value) => lightingDebugSettings.kLuxMeterThreshold1Debug = (float)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kLuxMeterThreshold2Debug, () => lightingDebugSettings.kLuxMeterThreshold2Debug, (value) => lightingDebugSettings.kLuxMeterThreshold2Debug = (float)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kLuxMeterThreshold3Debug, () => lightingDebugSettings.kLuxMeterThreshold3Debug, (value) => lightingDebugSettings.kLuxMeterThreshold3Debug = (float)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Lighting", kDisplaySkyReflectionDebug, () => lightingDebugSettings.displaySkyReflection, (value) => lightingDebugSettings.displaySkyReflection = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, LightLoop.TileClusterDebug>(kTileClusterDebug,() => lightingDebugSettings.tileClusterDebug, (value) => lightingDebugSettings.tileClusterDebug = (LightLoop.TileClusterDebug)value);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 #ifndef UNITY_DEBUG_DISPLAY_INCLUDED
 #define UNITY_DEBUG_DISPLAY_INCLUDED
 
+#include "CoreRP/ShaderLibrary/Debug.hlsl"
 #include "DebugDisplay.cs.hlsl"
 #include "MaterialDebug.cs.hlsl"
 #include "LightingDebug.cs.hlsl"
 int _DebugViewMaterial; // Contain the id (define in various materialXXX.cs.hlsl) of the property to display
 int _DebugMipMapMode; // Match enum DebugMipMapMode
 float4 _DebugLightingAlbedo; // xyz = albedo for diffuse, w unused
+float4 _DebugLuxMeterParam; // 4 increasing threshold
 float4 _DebugLightingSmoothness; // x == bool override, y == override value
 
 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;
 }
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/LightingDebug.cs

         None,
         DiffuseLighting,
         SpecularLighting,
+        LuxMeter,
         VisualizeCascade,
         IndirectDiffuseOcclusionFromSsao,
         IndirectDiffuseGtaoFromSsao,
         public bool                 overrideSmoothness = false;
         public float                overrideSmoothnessValue = 0.5f;
         public Color                debugLightingAlbedo = new Color(0.5f, 0.5f, 0.5f);
+        public float                kLuxMeterThreshold0Debug = 0.0f;
+        public float                kLuxMeterThreshold1Debug = 200.0f;
+        public float                kLuxMeterThreshold2Debug = 9000.0f;
+        public float                kLuxMeterThreshold3Debug = 10000.0f;
 
         public bool                 displaySkyReflection = false;
         public float                skyReflectionMipmap = 0.0f;

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/Debug/LightingDebugPanel.cs

                     m_DebugPanel.GetDebugItem(DebugDisplaySettings.kDebugLightingAlbedo).handler.OnEditorGUI();
                     EditorGUI.indentLevel--;
                 }
+                else if ((DebugLightingMode)lightingDebugModeItem.GetValue() == DebugLightingMode.LuxMeter)
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kLuxMeterThreshold0Debug).handler.OnEditorGUI();
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kLuxMeterThreshold1Debug).handler.OnEditorGUI();
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kLuxMeterThreshold2Debug).handler.OnEditorGUI();
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kLuxMeterThreshold3Debug).handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
 
                 var fullScreenDebugModeHandler = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kFullScreenDebugMode);
                 fullScreenDebugModeHandler.handler.OnEditorGUI();

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             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 luxMeterParam = new Vector4(lightingDebugSettings.kLuxMeterThreshold0Debug, lightingDebugSettings.kLuxMeterThreshold1Debug, lightingDebugSettings.kLuxMeterThreshold2Debug, lightingDebugSettings.kLuxMeterThreshold3Debug);
+            cmd.SetGlobalVector(HDShaderIDs._DebugLuxMeterParam, luxMeterParam);
             cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
         public static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
         public static readonly int _DebugLightingAlbedo = Shader.PropertyToID("_DebugLightingAlbedo");
+        public static readonly int _DebugLuxMeterParam = Shader.PropertyToID("_DebugLuxMeterParam");
         public static readonly int _DebugLightingSmoothness = Shader.PropertyToID("_DebugLightingSmoothness");
         public static readonly int _AmbientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
         public static readonly int _DebugMipMapMode = Shader.PropertyToID("_DebugMipMapMode");

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 = GetColorCodeFunction(Luminance(diffuseLighting).xxx, _DebugLuxMeterParam);
+    }
     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