Reduce number of variant by bring back FPTL/CLuster choice with dynamic branch for forward

- Make selection between FPTL/Cluster in forward dynamic (with
_UseTileLightList)
- Remove USE_CLUSTERED_LIGHTLIST define, only use USE_FPTL_LIGHTLIST
- Remove #pragma multi_compile USE_FPTL_LIGHTLIST
USE_CLUSTERED_LIGHTLIST from LitXXX shader

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

 
             #define LIGHTLOOP_TILE_PASS
 
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+            #pragma multi_compile _ USE_FPTL_LIGHTLIST
             #pragma multi_compile SHOW_LIGHT_CATEGORIES SHOW_FEATURE_VARIANTS
 
             //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 #pragma kernel DeferredDirectionalShadow_Contact_Normals	DEFERRED_DIRECTIONAL=DeferredDirectionalShadow_Contact_Normals  ENABLE_CONTACT_SHADOWS ENABLE_NORMALS
 
 #ifdef ENABLE_NORMALS
-#   define LIGHTLOOP_TILE_PASS 1
-#   define USE_FPTL_LIGHTLIST  1 // deferred opaque always use FPTL
+#   define LIGHTLOOP_TILE_PASS
+#   define USE_FPTL_LIGHTLIST // deferred opaque always use FPTL
 #   define UNITY_MATERIAL_LIT
 #else
 #   define SHADOW_USE_ONLY_VIEW_BASED_BIASING 1   // Enable only light view vector based biasing. If undefined, biasing will be based on the normal and calling code must provide a valid normal.
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../ShaderVariables.hlsl"
-#include "Lighting.hlsl" 
+#include "Lighting.hlsl"
 
 #pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 	float2 startUV = rayStartCS.xy * 0.5f + 0.5f;
 	startUV.y = 1.0 - startUV.y;
 
-	// Pixel to light ray in 
+	// Pixel to light ray in
 	float2 rayUV = rayCS.xy * 0.5f;
 	rayUV.y = -rayUV.y;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Forward.hlsl

 // #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS -> can't use a pragma from include... (for now)
 // For forward transparent are always cluster and opaque can be either cluster or fptl (sadly we have no to do multicompile only if opaque)
 // Moreover, we would like to do it only for LIGHTLOOP_TILE_PASS variant...
-// #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+// #pragma multi_compile _ USE_FPTL_LIGHTLIST

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

 #pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
 
 
-#define LIGHTLOOP_TILE_PASS 1
+#define LIGHTLOOP_TILE_PASS
-#define USE_FPTL_LIGHTLIST 1
+#define USE_FPTL_LIGHTLIST
 
 //#pragma enable_d3d11_debug_symbols
 

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

                     m_lightList.bounds.AddRange(m_lightList.rightEyeBounds);
                     m_lightList.lightVolumes.AddRange(m_lightList.rightEyeLightVolumes);
                 }
-                
+
                 UpdateDataBuffers();
 
                 return m_enableBakeShadowMask;
                     // say that we want to use tile of single loop
                     cmd.EnableShaderKeyword("LIGHTLOOP_TILE_PASS");
                     cmd.DisableShaderKeyword("LIGHTLOOP_SINGLE_PASS");
-                    CoreUtils.SetKeyword(cmd, "USE_FPTL_LIGHTLIST", useFptl);
-                    CoreUtils.SetKeyword(cmd, "USE_CLUSTERED_LIGHTLIST", !useFptl);
+                    cmd.SetGlobalFloat(HDShaderIDs._UseTileLightList, useFptl ? 1 : 0); // leaving this as a dynamic toggle to keep shader variants down.
                     cmd.SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, useFptl ? s_LightList : s_PerVoxelLightLists);
                 }
             }
                             m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_TileList, s_TileList);
                             m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
                             m_DebugViewTilesMaterial.EnableKeyword("USE_FPTL_LIGHTLIST");
-                            m_DebugViewTilesMaterial.DisableKeyword("USE_CLUSTERED_LIGHTLIST");
                             m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
                             m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
                             cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
                         m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileClusterDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, HDUtils.GetMouseCoordinates(hdCamera));
                         m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_vLightListGlobal, bUseClustered ? s_PerVoxelLightLists : s_LightList);
-                        m_DebugViewTilesMaterial.EnableKeyword(bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                        m_DebugViewTilesMaterial.DisableKeyword(!bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                        if (bUseClustered)
+                            m_DebugViewTilesMaterial.DisableKeyword("USE_FPTL_LIGHTLIST");
+                        else
+                            m_DebugViewTilesMaterial.EnableKeyword("USE_FPTL_LIGHTLIST");
                         m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
                         m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
 

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

 
 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
-//#ifdef USE_CLUSTERED_LIGHTLIST
+//#ifndef USE_FPTL_LIGHTLIST
 float4x4 g_mInvScrProjection;
 
 float g_fClustScale;
 int g_iLog2NumClusters; // We need to always define these to keep constant buffer layouts compatible
 
 uint g_isLogBaseBufferEnabled;
-//#endif
+uint _UseTileLightList;
-//#ifdef USE_CLUSTERED_LIGHTLIST
 uint _NumTileClusteredX;
 uint _NumTileClusteredY;
 CBUFFER_END
 
             color.rgb = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, 0).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 (g_vLightListGlobal[DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1)] >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff;
 }
 
-#elif defined(USE_CLUSTERED_LIGHTLIST)
+#else
-    return TILE_SIZE_CLUSTERED;
+    if (_UseTileLightList)
+        return TILE_SIZE_FPTL;
+    else
+        return TILE_SIZE_CLUSTERED;
 }
 
 float GetLightClusterMinLinearDepth(uint2 tileIndex, uint clusterIndex)
 
 void GetCountAndStart(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
 {
-    GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
+    if (_UseTileLightList)
+        GetCountAndStartTile(posInput, lightCategory, start, lightCount);
+    else
+        GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
-    return g_vLightListGlobal[tileOffset + lightIndex];
+    uint offset = tileOffset + lightIndex;
+    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
+
+    if (_UseTileLightList)
+        offset = DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1);
+
+    // Avoid generated HLSL bytecode to always access g_vLightListGlobal with
+    // two different offsets, fixes out of bounds issue
+    uint value = g_vLightListGlobal[offset];
+
+    // Light index are store on 16bit
+    return (_UseTileLightList ? ((value >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff) : value);
 }
 
 #endif // USE_FPTL_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

 
 #pragma kernel VolumetricLightingAllLights       VolumetricLighting=VolumetricLightingAllLights       ENABLE_REPROJECTION=0 LIGHTLOOP_SINGLE_PASS
 #pragma kernel VolumetricLightingAllLightsReproj VolumetricLighting=VolumetricLightingAllLightsReproj ENABLE_REPROJECTION=1 LIGHTLOOP_SINGLE_PASS
-#pragma kernel VolumetricLightingClustered       VolumetricLighting=VolumetricLightingClustered       ENABLE_REPROJECTION=0 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
-#pragma kernel VolumetricLightingClusteredReproj VolumetricLighting=VolumetricLightingClusteredReproj ENABLE_REPROJECTION=1 LIGHTLOOP_TILE_PASS   USE_CLUSTERED_LIGHTLIST
+#pragma kernel VolumetricLightingClustered       VolumetricLighting=VolumetricLightingClustered       ENABLE_REPROJECTION=0 LIGHTLOOP_TILE_PASS
+#pragma kernel VolumetricLightingClusteredReproj VolumetricLighting=VolumetricLightingClusteredReproj ENABLE_REPROJECTION=1 LIGHTLOOP_TILE_PASS
 
 // #pragma enable_d3d11_debug_symbols
 
         float3 scattering = _GlobalScattering;
         float  extinction = max(_GlobalExtinction, FLT_MIN); // Avoid NaNs
         float  asymmetry  = _GlobalAsymmetry;
-        
+
         // TODO: define a function ComputeGlobalFogCoefficients(float3 centerWS),
         // which allows procedural definition of extinction and scattering.
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             // In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             // In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             #include "../../ShaderVariables.hlsl"
             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             // In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             #include "../../ShaderVariables.hlsl"
             // #include "../../Lighting/Forward.hlsl"
             //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
             #define LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             // In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)