** Increasing HDRP fined prunned light tile count to 64. **

kecho · kecho · commit 76b444364a02 · 2021-10-15T11:43:05.000-04:00
* Missing offset

* Adding the light counter as a centralized parameter in ShaderConfig.cs

* Extra in comment

* Making bit allocation of clustered size / counter be automatically packed from new config

* Fixing some bugs with min / max

* Extra comment on configuration for 8k rendering

* Fixing flags for contact shadows and other review items from feedback

* Changelog

* Updated features and new doc for ShaderConfig light limit setting

* Adding upgrade guide and what's new

* Merging changes from fast PrepareLightsForGPU
diff --git a/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs b/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs
@@ -4,6 +4,12 @@
 
 namespace UnityEngine.Rendering.HighDefinition
 {
+    internal enum FPTLMaxLightSizes
+    {
+        Small = 31,
+        High = 63
+    }
+
     /// <summary>
     /// Project-wide shader configuration options.
     /// </summary>
@@ -36,6 +42,13 @@ public enum ShaderOptions
 
         /// <summary>Support to apply a global mip bias on all texture samplers of HDRP.</summary>
         GlobalMipBias = 1,
+
+        /// <summary>
+        /// Maximum number of lights for a fine pruned light tile. This number can only be 3 prespecified possibilities, 23, 31 or 63.
+        /// The reserved index is there for the count of the fined prunned tile list. The lower the count, some memory savings will occur for the tile light list.
+        /// Note: For any rendering bigger than 4k (in native) it is recommended to use Medium or Small light counts per tile, to avoid possible artifacts.
+        /// </summary>
+        FPTLMaxLightCount = FPTLMaxLightSizes.High
     };
 
     // Note: #define can't be use in include file in C# so we chose this way to configure both C# and hlsl
@@ -73,5 +86,8 @@ public class ShaderConfig
         /// <summary>Indicates whether to support application of global mip bias on all texture samplers of hdrp.</summary>
         ///<seealso cref="ShaderOptions.GlobalMipBias"/>
         public static bool s_GlobalMipBias = (int)ShaderOptions.GlobalMipBias != 0;
+        /// <summary>Indicates the maximum number of lights available for Fine Prunning Tile Lighting.</summary>
+        /// <seealso cref="ShaderOptions.FPTLMaxLightCount"/>
+        public static int FPTLMaxLightCount = (int)ShaderOptions.FPTLMaxLightCount;
     }
 }
diff --git a/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs.hlsl b/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs.hlsl
@@ -15,6 +15,7 @@
 #define SHADEROPTIONS_AREA_LIGHTS (1)
 #define SHADEROPTIONS_BARN_DOOR (0)
 #define SHADEROPTIONS_GLOBAL_MIP_BIAS (1)
+#define SHADEROPTIONS_FPTLMAX_LIGHT_COUNT (63)
 
 
 #endif
diff --git a/com.unity.render-pipelines.high-definition/CHANGELOG.md b/com.unity.render-pipelines.high-definition/CHANGELOG.md
@@ -45,6 +45,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 - Added public API to edit materials from script at runtime.
+- Added new configuration ShderOptions.FPTLMaxLightCount in ShaderConfig.cs for maximum light count per fine pruned tile.
 
 ### Fixed
 - Fixed impossibility to release the cursor in the template.
@@ -104,6 +105,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Path-traced volumetric scattering now takes fog color into account, adding scattered contribution on top of the non-scattered result (cases 1346105, 1358783).
 - Fixed minor readability issues in the ray tracing code.
 - PrepareLightsForGPU CPU Light loop performance improvement (40% to 70% faster), utilizing burst and optimized. Utilizing better sorting, distributing work in jobs and improving cache access of light data.
+- Maximum light count per fine prunned tile (opaque deferred) is now 63 instead of 23.
 
 ## [12.0.0] - 2021-01-11
 
diff --git a/com.unity.render-pipelines.high-definition/Documentation~/HDRP-Features.md b/com.unity.render-pipelines.high-definition/Documentation~/HDRP-Features.md
@@ -318,6 +318,11 @@ Real time raytracing effect are currently in Preview and behavior could change i
 
 <a name="Camera"></a>
 
+### Light count limit
+
+HDRP has a maximum limit on the number of lights a single pixel can get influence from. This setting can be configured through the ShaderConfig.cs file as the FPTLMaxLightCount. By default, HDRP's maximum light count per pixel is 64.
+The only two possible values HDRP supports are 32 and 64. For more information on how to configure this setting, please see [HDRP Config package](HDRP-Config-Package.md).
+
 ## Camera
 
 ### Post-processing
diff --git a/com.unity.render-pipelines.high-definition/Documentation~/Upgrading-from-2021.1-to-2021.2.md b/com.unity.render-pipelines.high-definition/Documentation~/Upgrading-from-2021.1-to-2021.2.md
@@ -34,6 +34,7 @@ The algorithm to calculate the contribution of ambient occlusion and specular oc
 ### Light list
 
 The previous `g_vLightListGlobal` uniform have been rename to explicit `g_vLightListTile` and `g_vLightListCluster` light list name. This work required to fix a wrong behavior on console.
+Added a new setting in ShaderConfig.cs, FPTLMaxLightCount. This setting can now set the maximum number of lights per tile on the GPU. A new Shader config project must be generated to upgrade. See the [HDRP-Config-Package](HDRP-Config-Package.md) guide for information on how to upgrade.
 
 ## Density Volumes
 
diff --git a/com.unity.render-pipelines.high-definition/Documentation~/whats-new-12.md b/com.unity.render-pipelines.high-definition/Documentation~/whats-new-12.md
@@ -60,6 +60,9 @@ From HDRP 12.0, HDRP includes a new [Light Anchor](light-anchor.md) component. Y
 ![](Images/LightAnchor0.png)
 
 
+### Maximum light count for gpu
+The new default maximum light count per pixel for Fine Prunning Tile List is now 64.
+Added a new setting in ShaderConfig.cs, FPTLMaxLightCount. This setting can now set the maximum number of lights per tile on the GPU. A new Shader config project must be generated to upgrade. See the [HDRP-Config-Package](HDRP-Config-Package.md) guide for information on how to upgrade.
 
 ## New upsampling methods
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs b/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.cs
@@ -1534,7 +1534,7 @@ void RegisterLightingDebug()
                                     data.fullScreenContactShadowLightIndex = value;
                                 },
                                 min = () => - 1, // -1 will display all contact shadow
-                                max = () => LightDefinitions.s_LightListMaxPrunedEntries - 1
+                                max = () => ShaderConfig.FPTLMaxLightCount - 1
                             },
                         }
                     });
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugViewTiles.shader b/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugViewTiles.shader
@@ -190,7 +190,7 @@ Shader "Hidden/HDRP/DebugViewTiles"
 
 #ifdef DISABLE_TILE_MODE
                 // Tile debug mode is not supported in MSAA (only cluster)
-                int maxLights = 32;
+                int maxLights = (LIGHT_CLUSTER_PACKING_COUNT_MASK + 1);
                 const int textSize = 23;
                 const int text[textSize] = {'N', 'o', 't', ' ', 's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'M', 'S', 'A', 'A'};
                 if (input.positionCS.y < DEBUG_FONT_TEXT_HEIGHT)
@@ -209,7 +209,7 @@ Shader "Hidden/HDRP/DebugViewTiles"
                 // Tile overlap counter
                 if (n >= 0)
                 {
-                    const uint maxLightsPerTile = 31;
+                    const uint maxLightsPerTile = SHADEROPTIONS_FPTLMAX_LIGHT_COUNT;
                     const float opacity = 0.3f;
                     result = OverlayHeatMap(int2(posInput.positionSS.xy), GetTileSize(), n, maxLightsPerTile, opacity);
                 }
@@ -224,8 +224,8 @@ Shader "Hidden/HDRP/DebugViewTiles"
                 }
 
                 // Print light lists for selected tile at the bottom of the screen
-                int maxLights = 32;
-                if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
+                int maxAreaWidth = SHADEROPTIONS_FPTLMAX_LIGHT_COUNT + 4;
+                if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxAreaWidth)
                 {
                     float depthMouse = GetTileDepth(_MousePixelCoord.xy);
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/Light/HDGpuLightsBuilder.LightLoop.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/Light/HDGpuLightsBuilder.LightLoop.cs
@@ -221,7 +221,7 @@ private void GetContactShadowMask(HDAdditionalLightData hdAdditionalLightData, B
             // If contact shadows are not enabled or we already reached the manimal number of contact shadows
             // or this is not rasterization
             if ((!hdAdditionalLightData.useContactShadow.Value(contactShadowEnabled))
-                || m_ContactShadowIndex >= LightDefinitions.s_LightListMaxPrunedEntries)
+                || m_ContactShadowIndex >= LightDefinitions.s_ContactShadowMaskMask)
                 return;
 
             // Evaluate the contact shadow index of this light
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs
@@ -107,9 +107,16 @@ class LightDefinitions
 
         // light list limits
         public static int s_LightListMaxCoarseEntries = 64;
-        public static int s_LightListMaxPrunedEntries = 24;
         public static int s_LightClusterMaxCoarseEntries = 128;
 
+        // We have room for ShaderConfig.FPTLMaxLightCount lights, plus 1 implicit value for length.
+        // We allocate only 16 bits per light index & length, thus we divide by 2, and store in a word buffer.
+        public static int s_LightDwordPerFptlTile = ((ShaderConfig.FPTLMaxLightCount + 1)) / 2;
+        public static int s_LightClusterPackingCountBits = (int)Mathf.Ceil(Mathf.Log(Mathf.NextPowerOfTwo(ShaderConfig.FPTLMaxLightCount), 2));
+        public static int s_LightClusterPackingCountMask = (1 << s_LightClusterPackingCountBits) - 1;
+        public static int s_LightClusterPackingOffsetBits = 32 - s_LightClusterPackingCountBits;
+        public static int s_LightClusterPackingOffsetMask = (1 << s_LightClusterPackingOffsetBits) - 1;
+
         // Following define the maximum number of bits use in each feature category.
         public static uint s_LightFeatureMaskFlags = 0xFFF000;
         public static uint s_LightFeatureMaskFlagsOpaque = 0xFFF000 & ~((uint)LightFeatureFlags.SSRefraction); // Opaque don't support screen space refraction
@@ -121,6 +128,13 @@ class LightDefinitions
         public static uint s_ScreenSpaceColorShadowFlag = 0x100;
         public static uint s_InvalidScreenSpaceShadow = 0xff;
         public static uint s_ScreenSpaceShadowIndexMask = 0xff;
+
+        //Contact shadow bit definitions
+        public static int s_ContactShadowFadeBits = 8;
+        public static int s_ContactShadowMaskBits = 32 - s_ContactShadowFadeBits;
+        public static int s_ContactShadowFadeMask = (1 << s_ContactShadowFadeBits) - 1;
+        public static int s_ContactShadowMaskMask = (1 << s_ContactShadowMaskBits) - 1;
+
     }
 
     [GenerateHLSL]
@@ -2130,14 +2144,15 @@ bool WillRenderContactShadow()
 
         // The first rendered 24 lights that have contact shadow enabled have a mask used to select the bit that contains
         // the contact shadow shadowed information (occluded or not). Otherwise -1 is written
+        // 8 bits are reserved for the fading.
         void GetContactShadowMask(HDAdditionalLightData hdAdditionalLightData, BoolScalableSetting contactShadowEnabled, HDCamera hdCamera, bool isRasterization, ref int contactShadowMask, ref float rayTracingShadowFlag)
         {
             contactShadowMask = 0;
             rayTracingShadowFlag = 0.0f;
             // If contact shadows are not enabled or we already reached the manimal number of contact shadows
             // or this is not rasterization
             if ((!hdAdditionalLightData.useContactShadow.Value(contactShadowEnabled))
-                || m_ContactShadowIndex >= LightDefinitions.s_LightListMaxPrunedEntries
+                || m_ContactShadowIndex >= LightDefinitions.s_ContactShadowMaskMask
                 || !isRasterization)
                 return;
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs.hlsl b/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs.hlsl
@@ -48,8 +48,12 @@
 #define TILE_INDEX_SHIFT_EYE (30)
 #define NUM_FEATURE_VARIANTS (29)
 #define LIGHT_LIST_MAX_COARSE_ENTRIES (64)
-#define LIGHT_LIST_MAX_PRUNED_ENTRIES (24)
 #define LIGHT_CLUSTER_MAX_COARSE_ENTRIES (128)
+#define LIGHT_DWORD_PER_FPTL_TILE (32)
+#define LIGHT_CLUSTER_PACKING_COUNT_BITS (6)
+#define LIGHT_CLUSTER_PACKING_COUNT_MASK (63)
+#define LIGHT_CLUSTER_PACKING_OFFSET_BITS (26)
+#define LIGHT_CLUSTER_PACKING_OFFSET_MASK (67108863)
 #define LIGHT_FEATURE_MASK_FLAGS (16773120)
 #define LIGHT_FEATURE_MASK_FLAGS_OPAQUE (16642048)
 #define LIGHT_FEATURE_MASK_FLAGS_TRANSPARENT (16510976)
@@ -58,6 +62,10 @@
 #define SCREEN_SPACE_COLOR_SHADOW_FLAG (256)
 #define INVALID_SCREEN_SPACE_SHADOW (255)
 #define SCREEN_SPACE_SHADOW_INDEX_MASK (255)
+#define CONTACT_SHADOW_FADE_BITS (8)
+#define CONTACT_SHADOW_MASK_BITS (24)
+#define CONTACT_SHADOW_FADE_MASK (255)
+#define CONTACT_SHADOW_MASK_MASK (16777215)
 
 //
 // UnityEngine.Rendering.HighDefinition.ClusterDebugMode:  static fields
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl b/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl
@@ -4,8 +4,6 @@
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.cs.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/CookieSampling.hlsl"
 
-#define DWORD_PER_TILE 16 // See dwordsPerTile in LightLoop.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)
-
 // Some file may not required HD shadow context at all. In this case provide an empty one
 // Note: if a double defintion error occur it is likely have include HDShadow.hlsl (and so HDShadowContext.hlsl) after lightloopdef.hlsl
 #ifndef HAVE_HD_SHADOW_CONTEXT
@@ -192,7 +190,7 @@ void GetCountAndStartTile(PositionInputs posInput, uint lightCategory, out uint
 #endif
 
     // The first entry inside a tile is the number of light for lightCategory (thus the +0)
-    lightCount = g_vLightListTile[DWORD_PER_TILE * tileOffset + 0] & 0xffff;
+    lightCount = g_vLightListTile[LIGHT_DWORD_PER_FPTL_TILE * tileOffset + 0] & 0xffff;
     start = tileOffset;
 }
 
@@ -212,7 +210,7 @@ uint FetchIndex(uint tileOffset, uint lightOffset)
 {
     const uint lightOffsetPlusOne = lightOffset + 1; // Add +1 as first slot is reserved to store number of light
     // Light index are store on 16bit
-    return (g_vLightListTile[DWORD_PER_TILE * tileOffset + (lightOffsetPlusOne >> 1)] >> ((lightOffsetPlusOne & 1) * DWORD_PER_TILE)) & 0xffff;
+    return (g_vLightListTile[LIGHT_DWORD_PER_FPTL_TILE * tileOffset + (lightOffsetPlusOne >> 1)] >> ((lightOffsetPlusOne & 1) * 16)) & 0xffff;
 }
 
 #elif defined(USE_CLUSTERED_LIGHTLIST)
@@ -236,15 +234,20 @@ uint GetLightClusterIndex(uint2 tileIndex, float linearDepth)
     return SnapToClusterIdxFlex(linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
 }
 
+void UnpackClusterLayeredOffset(uint packedValue, out uint offset, out uint count)
+{
+    offset = packedValue & LIGHT_CLUSTER_PACKING_OFFSET_MASK;
+    count = packedValue >> LIGHT_CLUSTER_PACKING_OFFSET_BITS;
+}
+
 void GetCountAndStartCluster(uint2 tileIndex, uint clusterIndex, uint lightCategory, out uint start, out uint lightCount)
 {
     int nrClusters = (1 << g_iLog2NumClusters);
 
     const int idx = GenerateLayeredOffsetBufferIndex(lightCategory, tileIndex, clusterIndex, _NumTileClusteredX, _NumTileClusteredY, nrClusters, unity_StereoEyeIndex);
 
     uint dataPair = g_vLayeredOffsetsBuffer[idx];
-    start = dataPair & 0x7ffffff;
-    lightCount = (dataPair >> 27) & 31;
+    UnpackClusterLayeredOffset(dataPair, start, lightCount);
 }
 
 void GetCountAndStartCluster(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
@@ -346,16 +349,17 @@ EnvLightData FetchEnvLight(uint index)
     return _EnvLightDatas[index];
 }
 
-// In the first 8 bits of the target we store the max fade of the contact shadows as a byte
+// In the first bits of the target we store the max fade of the contact shadows as a byte.
+//By default its 8 bits for the fade and 24 for the mask, please check the LightLoop.cs definitions.
 void UnpackContactShadowData(uint contactShadowData, out float fade, out uint mask)
 {
-    fade = float(contactShadowData >> 24) / 255.0;
-    mask = contactShadowData & 0xFFFFFF; // store only the first 24 bits which represent
+    fade = float(contactShadowData >> CONTACT_SHADOW_MASK_BITS) / ((float)CONTACT_SHADOW_FADE_MASK);
+    mask = contactShadowData & CONTACT_SHADOW_MASK_MASK; // store only the first 24 bits which represent
 }
 
 uint PackContactShadowData(float fade, uint mask)
 {
-    uint fadeAsByte = (uint(saturate(fade) * 255) << 24);
+    uint fadeAsByte = (uint(saturate(fade) * CONTACT_SHADOW_FADE_MASK) << CONTACT_SHADOW_MASK_BITS);
 
     return fadeAsByte | mask;
 }
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/lightlistbuild-clustered.compute b/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/lightlistbuild-clustered.compute
@@ -45,7 +45,6 @@ StructuredBuffer<SFiniteLightBound> g_data : register( t3 );
 StructuredBuffer<uint> g_vBigTileLightList : register( t4 );        // don't support Buffer yet in unity
 #endif
 
-
 #ifdef PLATFORM_LANE_COUNT                                          // We can infer the size of a wave. This is currently not possible on non-consoles, so we have to fallback to a sensible default in those cases.
 #define NR_THREADS              PLATFORM_LANE_COUNT
 #else
@@ -72,6 +71,11 @@ groupshared uint lightOffs;
 groupshared int categoryListCountScratch[NR_THREADS * LIGHTCATEGORY_COUNT];
 groupshared int shiftIndexScratch[NR_THREADS * LIGHTCATEGORY_COUNT];
 
+uint PackClusterLayeredOffset(uint offset, uint count)
+{
+    return (offset & LIGHT_CLUSTER_PACKING_OFFSET_MASK) | (min(count, LIGHT_CLUSTER_PACKING_COUNT_MASK) << LIGHT_CLUSTER_PACKING_OFFSET_BITS);
+}
+
 void ZeroCategoryListCountAndShiftIndex(uint threadIdx)
 {
     for (int i = 0; i < LIGHTCATEGORY_COUNT; ++i)
@@ -445,12 +449,12 @@ void LIGHTLISTGEN(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
     offs = GenerateLayeredOffsetBufferIndex(0, tileIDX, i, nrTilesX, nrTilesY, nrClusters, eyeIndex);
     for(int category=0; category<LIGHTCATEGORY_COUNT; category++)
     {
-        int numLights = min(ReadCategoryListCount(t, category),31);        // only allow 5 bits
+        int numLights = ReadCategoryListCount(t, category);
         if(i<nrClusters)
         {
-            g_LayeredOffset[offs] = (start+localOffs) | (((uint) numLights)<<27);
+            g_LayeredOffset[offs] = PackClusterLayeredOffset((start+localOffs), (uint)numLights);
             offs += (nrClusters*nrTilesX*nrTilesY);
-            localOffs += ReadCategoryListCount(t, category);       // use unclamped count for localOffs
+            localOffs += numLights;// use unclamped count for localOffs
         }
     }
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/lightlistbuild.compute b/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/lightlistbuild.compute
@@ -328,7 +328,7 @@ void TileLightListGen(uint3 dispatchThreadId : SV_DispatchThreadID, uint threadI
     for(int category=0; category<CATEGORY_LIST_SIZE; category++)
     {
         int nrLightsFinal = ldsCategoryListCount[category];
-        int nrLightsFinalClamped = nrLightsFinal<LIGHT_LIST_MAX_PRUNED_ENTRIES ? nrLightsFinal : LIGHT_LIST_MAX_PRUNED_ENTRIES;
+        int nrLightsFinalClamped = nrLightsFinal<SHADEROPTIONS_FPTLMAX_LIGHT_COUNT ? nrLightsFinal : SHADEROPTIONS_FPTLMAX_LIGHT_COUNT;
 
         const int nrDWords = ((nrLightsFinalClamped+1)+1)>>1;
         for(int l=(int) t; l<(int) nrDWords; l += NR_THREADS)
@@ -337,7 +337,7 @@ void TileLightListGen(uint3 dispatchThreadId : SV_DispatchThreadID, uint threadI
             uint uLow = l==0 ? nrLightsFinalClamped : prunedList[max(0,2 * l - 1 + localOffs)] - shiftIndex[category];
             uint uHigh = prunedList[2 * l + 0 + localOffs] - shiftIndex[category];
 
-            g_vLightList[16*offs + l] = (uLow&0xffff) | (uHigh<<16);
+            g_vLightList[LIGHT_DWORD_PER_FPTL_TILE*offs + l] = (uLow&0xffff) | (uHigh<<16);
         }
 
         localOffs += nrLightsFinal;
diff --git a/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.LightLoop.cs b/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/HDRenderPipeline.LightLoop.cs
@@ -589,15 +589,13 @@ unsafe void PrepareBuildGPULightListPassData(
             var nrTilesX = (m_MaxCameraWidth + LightDefinitions.s_TileSizeFptl - 1) / LightDefinitions.s_TileSizeFptl;
             var nrTilesY = (m_MaxCameraHeight + LightDefinitions.s_TileSizeFptl - 1) / LightDefinitions.s_TileSizeFptl;
             var nrTiles = nrTilesX * nrTilesY * m_MaxViewCount;
-            const int capacityUShortsPerTile = 32;
-            const int dwordsPerTile = (capacityUShortsPerTile + 1) >> 1; // room for 31 lights and a nrLights value.
 
             if (tileAndClusterData.hasTileBuffers)
             {
                 // note that nrTiles include the viewCount in allocation below
                 // Tile buffers
                 passData.output.lightList = builder.WriteComputeBuffer(
-                    renderGraph.CreateComputeBuffer(new ComputeBufferDesc((int)LightCategory.Count * dwordsPerTile * nrTiles, sizeof(uint)) { name = "LightList" }));
+                    renderGraph.CreateComputeBuffer(new ComputeBufferDesc((int)LightCategory.Count * LightDefinitions.s_LightDwordPerFptlTile * nrTiles, sizeof(uint)) { name = "LightList" }));
                 passData.output.tileList = builder.WriteComputeBuffer(
                     renderGraph.CreateComputeBuffer(new ComputeBufferDesc(LightDefinitions.s_NumFeatureVariants * nrTiles, sizeof(uint)) { name = "TileList" }));
                 passData.output.tileFeatureFlags = builder.WriteComputeBuffer(

Original file line number	Diff line number	Diff line change
`@@ -1534,7 +1534,7 @@ void RegisterLightingDebug()`
`1534`	`1534`	`data.fullScreenContactShadowLightIndex = value;`
`1535`	`1535`	`},`
`1536`	`1536`	`min = () => - 1, // -1 will display all contact shadow`
`1537`		`- max = () => LightDefinitions.s_LightListMaxPrunedEntries - 1`
	`1537`	`+ max = () => ShaderConfig.FPTLMaxLightCount - 1`
`1538`	`1538`	`},`
`1539`	`1539`	`}`
`1540`	`1540`	`});`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ Shader "Hidden/HDRP/DebugViewTiles"`
`190`	`190`
`191`	`191`	`#ifdef DISABLE_TILE_MODE`
`192`	`192`	`// Tile debug mode is not supported in MSAA (only cluster)`
`193`		`- int maxLights = 32;`
	`193`	`+ int maxLights = (LIGHT_CLUSTER_PACKING_COUNT_MASK + 1);`
`194`	`194`	`const int textSize = 23;`
`195`	`195`	`const int text[textSize] = {'N', 'o', 't', ' ', 's', 'u', 'p', 'p', 'o', 'r', 't', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ', 'M', 'S', 'A', 'A'};`
`196`	`196`	`if (input.positionCS.y < DEBUG_FONT_TEXT_HEIGHT)`
`@@ -209,7 +209,7 @@ Shader "Hidden/HDRP/DebugViewTiles"`
`209`	`209`	`// Tile overlap counter`
`210`	`210`	`if (n >= 0)`
`211`	`211`	`{`
`212`		`- const uint maxLightsPerTile = 31;`
	`212`	`+ const uint maxLightsPerTile = SHADEROPTIONS_FPTLMAX_LIGHT_COUNT;`
`213`	`213`	`const float opacity = 0.3f;`
`214`	`214`	`result = OverlayHeatMap(int2(posInput.positionSS.xy), GetTileSize(), n, maxLightsPerTile, opacity);`
`215`	`215`	`}`
`@@ -224,8 +224,8 @@ Shader "Hidden/HDRP/DebugViewTiles"`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`// Print light lists for selected tile at the bottom of the screen`
`227`		`- int maxLights = 32;`
`228`		`- if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)`
	`227`	`+ int maxAreaWidth = SHADEROPTIONS_FPTLMAX_LIGHT_COUNT + 4;`
	`228`	`+ if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxAreaWidth)`
`229`	`229`	`{`
`230`	`230`	`float depthMouse = GetTileDepth(_MousePixelCoord.xy);`
`231`	`231`