Revert "HLSLcc: fix out of bounds issues on Metal/iOS, HLSL bytecode being the root cause before Metal generated shaders"

This reverts commit 72893e261ba44cbf88087255f4a57116f9e9f76a.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild-clustered.compute

 
 	//////////// cell specific code
 	{
-		int pad = iNrCoarseLights & 1;
-		for(int l=(int) t; l<((iNrCoarseLights+pad)>>1); l += NR_THREADS)
+		for(int l=(int) t; l<((iNrCoarseLights+1)>>1); l += NR_THREADS)
-			const int l0 = coarseList[2*l+0], l1 = coarseList[min(2*l+1,iNrCoarseLights-pad)];
+			const int l0 = coarseList[2*l+0], l1 = coarseList[min(2*l+1,iNrCoarseLights)];
 			const unsigned int clustIdxMi0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0].z), suggestedBase));
 			const unsigned int clustIdxMa0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0+g_iNrVisibLights].z), suggestedBase));
 			const unsigned int clustIdxMi1 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1].z), suggestedBase));
 	{
 		int offs = 0;
 		for(int l=0; l<iNrCoarseLights; l++)
-		{
-			if(coarseList[l]!=0xffffffff)
-				coarseList[offs++] = coarseList[l];
-		}
+		{	if(coarseList[l]!=0xffffffff) coarseList[offs++] = coarseList[l]; }
 		lightOffsSph = offs;
 	}
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Resources/lightlistbuild.compute

 		for(int l=(int) t; l<(int) nrDWords; l += NR_THREADS)
 		{
 			// We remap the prunedList index to the original LightData / EnvLightData indices
-			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[max(0,2 * l - 1 + localOffs)] - shiftIndex[category];
+			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[2 * l - 1 + localOffs] - shiftIndex[category];
 			uint uHigh = prunedList[2 * l + 0 + localOffs] - shiftIndex[category];
 
 			g_vLightList[16*offs + l] = (uLow&0xffff) | (uHigh<<16);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

     start = tileOffset;
 }
 
+uint FetchIndexTile(uint tileOffset, uint lightIndex)
+{
+    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
+    // Light index are store on 16bit
+    return (g_vLightListGlobal[DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1)] >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff;
+}
+
 #ifdef USE_FPTL_LIGHTLIST
 
 uint GetTileSize()
 
 uint FetchIndex(uint tileOffset, uint lightIndex)
 {
-    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
-    // Light index are store on 16bit
-    return (g_vLightListGlobal[DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1)] >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff;
+    return FetchIndexTile(tileOffset, lightIndex);
 }
 
 #elif defined(USE_CLUSTERED_LIGHTLIST)
     lightCount = (dataPair >> 27) & 31;
 }
 
+uint FetchIndexCluster(uint tileOffset, uint lightIndex)
+{
+    return g_vLightListGlobal[tileOffset + lightIndex];
+}
+
 void GetCountAndStart(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
 {
     if (_UseTileLightList)
 
 uint FetchIndex(uint tileOffset, uint lightIndex)
 {
-    uint offset = tileOffset + lightIndex;
-    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
-
-        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);
+        return FetchIndexTile(tileOffset, lightIndex);
+    else
+        return FetchIndexCluster(tileOffset, lightIndex);
 }
 
 #endif
 
 #else // LIGHTLOOP_SINGLE_PASS
 
-uint GetTileSize()
-{
-    return 1;
-}
+uint GetTileSize()
+{
+    return 1;
+}
 
 
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)

Assets/ScriptableRenderPipeline/fptl/TiledLightingUtils.hlsl

     uStart = tileOffs;
 }
 
+uint FetchIndexOpaque(const uint tileOffs, const uint l)
+{
+    const uint l1 = l+1;
+    return (g_vLightListGlobal[ 16*tileOffs + (l1>>1)]>>((l1&1)*16))&0xffff;
+}
+
 #ifdef OPAQUES_ONLY
 
 void GetCountAndStart(out uint uStart, out uint uNrLights, uint2 pixCoord, float linDepth, uint model)
 
 uint FetchIndex(const uint tileOffs, const uint l)
 {
-    const uint l1 = l+1;
-    return (g_vLightListGlobal[ 16*tileOffs + (l1>>1)]>>((l1&1)*16))&0xffff;
+    return FetchIndexOpaque(tileOffs, l);
 }
 
 #else
 
 uint FetchIndex(const uint tileOffs, const uint l)
 {
-    uint offs = tileOffs+l;
-    const uint l1 = l+1;
-
-        offs = 16*tileOffs + (l1>>1);
-
-    // Avoid generated HLSL bytecode to always access g_vLightListGlobal with
-    // two different offsets, fixes out of bounds issue
-    uint value = g_vLightListGlobal[offs];
-    return (g_isOpaquesOnlyEnabled ? ((value >>((l1&1)*16))&0xffff) : value);
+        return FetchIndexOpaque(tileOffs, l);
+    else
+        return g_vLightListGlobal[ tileOffs+l ];
 }
 
 #endif

Assets/ScriptableRenderPipeline/fptl/lightlistbuild-clustered.compute

 
 	//////////// cell specific code
 	{
-		int pad = iNrCoarseLights & 1;
-		for(int l=(int) t; l<((iNrCoarseLights+pad)>>1); l += NR_THREADS)
+		for(int l=(int) t; l<((iNrCoarseLights+1)>>1); l += NR_THREADS)
-			const int l0 = coarseList[2*l+0], l1 = coarseList[min(2*l+1,iNrCoarseLights-pad)];
+			const int l0 = coarseList[2*l+0], l1 = coarseList[min(2*l+1,iNrCoarseLights)];
 			const unsigned int clustIdxMi0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0].z), suggestedBase));
 			const unsigned int clustIdxMa0 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l0+g_iNrVisibLights].z), suggestedBase));
 			const unsigned int clustIdxMi1 = (const unsigned int) min(255,SnapToClusterIdx(GetLinearDepth(g_vBoundsBuffer[l1].z), suggestedBase));
 	{
 		int offs = 0;
 		for(int l=0; l<iNrCoarseLights; l++)
-		{
-			if(coarseList[l]!=0xffffffff)
-				coarseList[offs++] = coarseList[l];
-		}
+		{	if(coarseList[l]!=0xffffffff) coarseList[offs++] = coarseList[l]; }
 		lightOffsSph = offs;
 	}
 

Assets/ScriptableRenderPipeline/fptl/lightlistbuild.compute

 		const int nrDWords = ((nrLightsFinalClamped+1)+1)>>1;
 		for(int l=(int) t; l<(int) nrDWords; l += NR_THREADS)
 		{
-			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[max(0,2 * l - 1 + localOffs)];
+			uint uLow = l==0 ? nrLightsFinalClamped : prunedList[2 * l - 1 + localOffs];
 			uint uHigh = prunedList[2 * l + 0 + localOffs];
 
 			g_vLightList[16*offs + l] = (uLow&0xffff) | (uHigh<<16);