HDRenderPipeline: Fix shader and C# warning + re-arrange lightloop for env

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

 
     return max(0.5 * log2(d), 0.0);
 }
-
+
-    float2 ddy_ = ddy(uv);
+    float2 ddy_ = ddy(uv);
-}
+}
 
 // x contains width, w contains height
 float ComputeTextureLOD(float2 uv, float2 texelSize)
 {
 	uint topBit = vertexID >> 1;
 	uint botBit = (vertexID & 1);
-	float u = topBit; 
+	float u = topBit;
 	float v = (topBit + botBit) & 1; // produces 0 for indices 0,3 and 1 for 1,2
 #if UNITY_UV_STARTS_AT_TOP
 	v = 1.0 - v;
 	uint botBit = (vertexID & 1);
 	float x = topBit;
 	float y = 1 - (topBit + botBit) & 1; // produces 1 for indices 0,3 and 0 for 1,2
-	return float4(x, y, z, 1.0); 
+	return float4(x, y, z, 1.0);
 }
 
 #if !defined(SHADER_API_GLES)
 
     // We want to have a symmetry between 0..0.5 ditherFactor and 0.5..1 so no pixels are transparent during the transition
     // this is handled by this test which reverse the pattern
-    // TODO: replace the test (ditherFactor >= 0.5) with (isLod0) to avoid the distracting pattern flip around 0.5.  
+    // TODO: replace the test (ditherFactor >= 0.5) with (isLod0) to avoid the distracting pattern flip around 0.5.
     p = (ditherFactor >= 0.5) ? p : 1 - p;
     clip(ditherFactor - p);
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.cs

 
         public static string k_PanelScreenSpaceTracing = "Screen Space Tracing";
 
-        static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
+        //static readonly string[] k_HiZIntersectionKind = { "None", "Depth", "Cell" };
 
         DebugUI.Widget[] m_DebugDisplayStatsItems;
         DebugUI.Widget[] m_DebugMaterialItems;

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

         }
     }
 
-    float reflectionHierarchyWeight = 0.0; // Max: 1.0
-    float refractionHierarchyWeight = 0.0; // Max: 1.0
-
-    // First loop iteration is:
-    //  1. Screen Space Refraction / Reflection
-    //  2. Environment Reflection / Refraction
-    //  3. Sky Reflection / Refraction
-    //
-    // Following loop iterations are:
-    //  1. Environment Reflection / Refraction
-    //  2. Sky Reflection / Refraction
-
-    // Common variable for all iterations
-#ifdef LIGHTLOOP_TILE_PASS
-    uint envLightStart;
-# define FETCHINDEX(index) FetchIndex(envLightStart, index);
-#else
-# define FETCHINDEX(index) index
-#endif
-    uint envLightCount;
-
-#define EVALUATE_BSDF_ENV(envLightData, TYPE, type) {\
-    IndirectLighting lighting = EvaluateBSDF_Env(   context, V, posInput, preLightData, envLightData, bsdfData, \
-    envLightData.influenceShapeType, \
-    MERGE_NAME (GPUIMAGEBASEDLIGHTINGTYPE_, TYPE), MERGE_NAME (type, HierarchyWeight)); \
-    AccumulateIndirectLighting(lighting, aggregateLighting);\
-}
+#define EVALUATE_BSDF_ENV(envLightData, TYPE, type) \
+    IndirectLighting lighting = EvaluateBSDF_Env(context, V, posInput, preLightData, envLightData, bsdfData, envLightData.influenceShapeType, MERGE_NAME(GPUIMAGEBASEDLIGHTINGTYPE_, TYPE), MERGE_NAME(type, HierarchyWeight)); \
+    AccumulateIndirectLighting(lighting, aggregateLighting);
-    if (featureFlags & (
-              LIGHTFEATUREFLAGS_ENV 
-            | LIGHTFEATUREFLAGS_SKY
-            | LIGHTFEATUREFLAGS_SSREFRACTION
-            | LIGHTFEATUREFLAGS_SSREFLECTION
-        )
-    )
+    if (featureFlags & (LIGHTFEATUREFLAGS_ENV | LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_SSREFRACTION | LIGHTFEATUREFLAGS_SSREFLECTION))
+        float reflectionHierarchyWeight = 0.0; // Max: 1.0
+        float refractionHierarchyWeight = 0.0; // Max: 1.0
+
+        uint envLightStart, envLightCount;
+
+    #ifdef LIGHTLOOP_TILE_PASS
+        GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
+    #else
+        envLightCount = _EnvLightCount;
+        envLightStart = 0;
+    #endif
+
+        // Reflection / Refraction hierarchy is
+        //  1. Screen Space Refraction / Reflection
+        //  2. Environment Reflection / Refraction
+        //  3. Sky Reflection / Refraction
-        ZERO_INITIALIZE(EnvLightData, envLightData);
+        if (envLightCount > 0)
-            #ifdef LIGHTLOOP_TILE_PASS
-                GetCountAndStart(posInput, LIGHTCATEGORY_ENV, envLightStart, envLightCount);
-            #else
-                envLightCount = _EnvLightCount;
-            #endif
-            if (envLightCount > 0)
-            {
-                uint envLightIndex = FETCHINDEX(0);
-                envLightData = _EnvLightDatas[envLightIndex];
-            }
-            else
-                envLightData = InitSkyEnvLightData(0);
+            envLightData = FetchEnvLight(envLightStart, 0);
-
-        if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
+        else
-            IndirectLighting lighting = EvaluateBSDF_SSLighting(    context, V, posInput, preLightData, bsdfData, envLightData,
-                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION, refractionHierarchyWeight);
-            AccumulateIndirectLighting(lighting, aggregateLighting);
+            envLightData = InitSkyEnvLightData(0);
         }
 
         if (featureFlags & LIGHTFEATUREFLAGS_SSREFLECTION)
             AccumulateIndirectLighting(lighting, aggregateLighting);
         }
 
-        if ((featureFlags & LIGHTFEATUREFLAGS_ENV) && envLightCount > 0)
+        if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-            
-            EVALUATE_BSDF_ENV(envLightData, REFLECTION, reflection);
-
-            if (featureFlags & LIGHTFEATUREFLAGS_SSREFRACTION)
-                EVALUATE_BSDF_ENV(envLightData, REFRACTION, refraction);
+            IndirectLighting lighting = EvaluateBSDF_SSLighting(    context, V, posInput, preLightData, bsdfData, envLightData,
+                                                                    GPUIMAGEBASEDLIGHTINGTYPE_REFRACTION, refractionHierarchyWeight);
+            AccumulateIndirectLighting(lighting, aggregateLighting);
-    }
-    // Following loop iterations
-    if (featureFlags & LIGHTFEATUREFLAGS_ENV || featureFlags & LIGHTFEATUREFLAGS_SKY)
-    {
         // Reflection probes are sorted by volume (in the increasing order).
         if (featureFlags & LIGHTFEATUREFLAGS_ENV)
         {
-            for (i = 1; i < envLightCount && reflectionHierarchyWeight < 1.0; ++i)
+            for (i = 0; i < envLightCount && reflectionHierarchyWeight < 1.0; ++i)
-                uint envLightIndex = FETCHINDEX(i);
-                EVALUATE_BSDF_ENV(_EnvLightDatas[envLightIndex], REFLECTION, reflection);
+                EVALUATE_BSDF_ENV(FetchEnvLight(envLightStart, i), REFLECTION, reflection);
             }
 
             // Refraction probe and reflection probe will process exactly the same weight. It will be good for performance to be able to share this computation
-            // We reuse LIGHTFEATUREFLAGS_SSREFRACTION flag as refraction is mainly base on the screen. Would be aa waste to not use screen and only cubemap.
+            // We reuse LIGHTFEATUREFLAGS_SSREFRACTION flag as refraction is mainly base on the screen. Would be a waste to not use screen and only cubemap.
-                for (i = 1; i < envLightCount && refractionHierarchyWeight < 1.0; ++i)
+                for (i = 0; i < envLightCount && refractionHierarchyWeight < 1.0; ++i)
-                    uint envLightIndex = FETCHINDEX(i);
-                    EVALUATE_BSDF_ENV(_EnvLightDatas[envLightIndex], REFRACTION, refraction);
+                    EVALUATE_BSDF_ENV(FetchEnvLight(envLightStart, i), REFRACTION, refraction);
-        if (featureFlags & LIGHTFEATUREFLAGS_SKY && _EnvLightSkyEnabled)
+        if ((featureFlags & LIGHTFEATUREFLAGS_SKY) && _EnvLightSkyEnabled)
+            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+
+            // The sky data are generated on the fly so the compiler can optimize the code
+            EnvLightData envLightSky = InitSkyEnvLightData(0);
+
-                // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-                context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-
-                // The sky data are generated on the fly so the compiler can optimize the code
-                EnvLightData envLightSky = InitSkyEnvLightData(0);
                 EVALUATE_BSDF_ENV(envLightSky, REFLECTION, reflection);
             }
 
                 {
-                    // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-                    context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-                    
-                    // The sky data are generated on the fly so the compiler can optimize the code
-                    EnvLightData envLightSky = InitSkyEnvLightData(0);
                     EVALUATE_BSDF_ENV(envLightSky, REFRACTION, refraction);
                 }
             }
-#undef FETCHINDEX
 
     // Also Apply indiret diffuse (GI)
     // PostEvaluateBSDF will perform any operation wanted by the material and sum everything into diffuseLighting and specularLighting

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

 
             color.rgb = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, lod).rgb;
             color.a = any(ndc.xyz < 0) || any(ndc.xyz > 1) ? 0.0 : 1.0;
-            
+
 #ifdef DEBUG_DISPLAY
             if (_DebugLightingMode == DEBUGLIGHTINGMODE_ENVIRONMENT_SAMPLE_COORDINATES)
                 color = float4(ndc.xy, 0, color.a);
 
     return _LightDatas[j];
 }
+
+EnvLightData FetchEnvLight(uint start, uint i)
+{
+    int j = FetchIndex(start, i);
+
+    return _EnvLightDatas[j];
+}