Debug fixes

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

         public static string k_PanelScreenSpaceTracing = "Screen Space Tracing";
         public static string k_PanelDecals = "Decals";
 
-        //static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
+        static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
 
         DebugUI.Widget[] m_DebugDisplayStatsItems;
         DebugUI.Widget[] m_DebugMaterialItems;
                                     new DebugUI.Value { displayName = "Mip Level", getter = () => screenSpaceTracingDebugData.iterationMipLevel },
                                     new DebugUI.Value { displayName = "Cell Id", getter = () => screenSpaceTracingDebugData.iterationCellId },
                                     new DebugUI.Value { displayName = "Cell Size", getter = () => screenSpaceTracingDebugData.iterationCellSize },
+                                    new DebugUI.Value { displayName = "Intersection Kind", getter = () => k_HiZIntersectionKind[(int)screenSpaceTracingDebugData.iterationIntersectionKind] },
                                 }
                             }
                         );

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ScreenSpaceTracing.hlsl

     // Settings
     int settingRayLevel,                    // Mip level to use to ray march depth buffer
     uint settingsRayMaxIterations,          // Maximum number of iterations (= max number of depth samples)
-    int settingsDebuggedAlgorithm,          // currently debugged algorithm (see PROJECTIONMODEL defines)
+    int settingsDebuggedAlgorithm,          // currently debugged algorithm (see PROJECTIONMODEL defines)
     // Precomputed properties
     float3 startPositionSS,                 // Start position in Screen Space (x in pixel, y in pixel, z = 1/linearDepth)
     float3 raySS,                           // Ray direction in Screen Space (dx in pixel, dy in pixel, z = 1/endPointLinearDepth - 1/startPointLinearDepth)
         // Settings
         settingRayLevel,
         settingsRayMaxIterations,
-        settingsDebuggedAlgorithm,
+        settingsDebuggedAlgorithm,
         // Precomputed properties
         startPositionSS,
         raySS,
             settingsRayLevel,
             settingsRayMaxLinearIterations,
             settingsRayDepthSuccessBias,
-#ifdef DEBUG_DISPLAY
-#else
-            PROJECTIONMODEL_NONE,
-#endif
             // precomputed
             startPositionSS,
             raySS,
         input,
         // Settings
 #if DEBUG_DISPLAY
-        SSRT_SETTING(DebuggedAlgorithm, SSRTID),
+        int(SSRT_SETTING(DebuggedAlgorithm, SSRTID)),
 #else
         int(PROJECTIONMODEL_NONE),
 #endif

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

     int projectionModel = PROJECTIONMODEL_NONE;
 #if HAS_REFRACTION
     if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION)
-        {
+    {
     #if defined(_REFRACTION_SSRAY_HIZ)
         projectionModel = PROJECTIONMODEL_HI_Z;
     #elif defined(_REFRACTION_SSRAY_PROXY)
 
     if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION)
     {
-            // Refraction process:
-            //  1. Depending on the shape model, we calculate the refracted point in world space and the optical depth
-            //  2. We calculate the screen space position of the refracted point
-            //  3. If this point is available (ie: in color buffer and point is not in front of the object)
-            //    a. Get the corresponding color depending on the roughness from the gaussian pyramid of the color buffer
-            //    b. Multiply by the transmittance for absorption (depends on the optical depth)
+        // Refraction process:
+        //  1. Depending on the shape model, we calculate the refracted point in world space and the optical depth
+        //  2. We calculate the screen space position of the refracted point
+        //  3. If this point is available (ie: in color buffer and point is not in front of the object)
+        //    a. Get the corresponding color depending on the roughness from the gaussian pyramid of the color buffer
+        //    b. Multiply by the transmittance for absorption (depends on the optical depth)
 
         rayOriginWS             = preLightData.transparentPositionWS;
         rayDirWS                = preLightData.transparentRefractV;
     }
 
 #if DEBUG_DISPLAY
-            bool debug              = _DebugLightingMode == debugMode
-                && !any(int2(_MouseClickPixelCoord.xy) - int2(posInput.positionSS));
+    bool debug                  = _DebugLightingMode == debugMode
+                                && !any(int2(_MouseClickPixelCoord.xy) - int2(posInput.positionSS));
 #endif
 
     // -------------------------------
             hitSuccessful = ScreenSpaceHiZRaymarchReflection(ssRayInput, hit);
     }
 
-            // Debug screen space tracing
+    // Debug screen space tracing
-            if (_DebugLightingMode == debugMode
-                && _DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-            {
-                float weight = 1.0;
-                UpdateLightingHierarchyWeights(hierarchyWeight, weight);
+    if (_DebugLightingMode == debugMode
+        && _DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+    {
+        float weight = 1.0;
+        UpdateLightingHierarchyWeights(hierarchyWeight, weight);
-                lighting.specularTransmitted = hit.debugOutput;
+            lighting.specularTransmitted = hit.debugOutput;
-                return lighting;
-            }
+        return lighting;
+    }
-            if (!hitSuccessful)
-                return lighting;
+    if (!hitSuccessful)
+        return lighting;
-            weightNDC = weightNDC * weightNDC * (3 - 2 * weightNDC);
-            float weight = weightNDC.x * weightNDC.y;
+    weightNDC = weightNDC * weightNDC * (3 - 2 * weightNDC);
+    float weight = weightNDC.x * weightNDC.y;
-            float hitDeviceDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, hit.positionSS, 0).r;
-            float hitLinearDepth = LinearEyeDepth(hitDeviceDepth, _ZBufferParams);
+    float hitDeviceDepth = LOAD_TEXTURE2D_LOD(_DepthPyramidTexture, hit.positionSS, 0).r;
+    float hitLinearDepth = LinearEyeDepth(hitDeviceDepth, _ZBufferParams);
-            // Exit if texel is out of color buffer
-            // Or if the texel is from an object in front of the object
-            if (hitLinearDepth < posInput.linearDepth
-                || weight == 0)
-            {
-                // Do nothing and don't update the hierarchy weight so we can fall back on refraction probe
-                return lighting;
-            }
+    // Exit if texel is out of color buffer
+    // Or if the texel is from an object in front of the object
+    if (hitLinearDepth < posInput.linearDepth
+        || weight == 0)
+    {
+        // Do nothing and don't update the hierarchy weight so we can fall back on refraction probe
+        return lighting;
+    }
-            UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hierarchy priority
+    UpdateLightingHierarchyWeights(hierarchyWeight, weight); // Shouldn't be needed, but safer in case we decide to change hierarchy priority
-            float3 preLD = SAMPLE_TEXTURE2D_LOD(
-                _ColorPyramidTexture,
-                s_trilinear_clamp_sampler,
-                hit.positionNDC * _ColorPyramidScale.xy,
+    float3 preLD = SAMPLE_TEXTURE2D_LOD(
+        _ColorPyramidTexture,
+        s_trilinear_clamp_sampler,
+        hit.positionNDC * _ColorPyramidScale.xy,
-            ).rgb;
+    ).rgb;
-            float3 F = preLightData.specularFGD;
+    float3 F = preLightData.specularFGD;
-            lighting.specularTransmitted = (1.0 - F) * preLD.rgb * preLightData.transparentTransmittance * weight;
+        lighting.specularTransmitted = (1.0 - F) * preLD.rgb * preLightData.transparentTransmittance * weight;
     else if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
         lighting.specularReflected = F * preLD.rgb * weight;