[JIRA # UUM-65155] Fixing stencil compiler bug for subsurface scattering on scarlett

Fix coarse stencil bug computation race condition caused by a compiler bug in DXC.
The issue manifests itself as flickering tiles on sub surface scatter pixels. This issue is caused because the DXC compiler does not make the branches using a groupThreadId vector comparison a scalar. Changing this to use the group index instead (preflattened) triggers the compiler to recognize the branch as a scalar instead.

Author: kecho

Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ResolveStencilBuffer.compute

@@ -46,52 +46,45 @@ RWStructuredBuffer<uint>    _CoarseStencilBuffer;
 groupshared uint coarseStencilValue;
 #endif
 
-[numthreads(8, 8, 1)]
-void Main(uint3 groupId          : SV_GroupID,
-                 uint3 groupThreadId    : SV_GroupThreadID,
-                 uint3 dispatchThreadID : SV_DispatchThreadID)
+[numthreads(64, 1, 1)]
+void Main(uint3 groupId : SV_GroupID, uint  groupThreadIndex : SV_GroupIndex)
 {
-    UNITY_XR_ASSIGN_VIEW_INDEX(dispatchThreadID.z);
+    UNITY_XR_ASSIGN_VIEW_INDEX(groupId.z);
 
     // The best shot at resolving is being overly conservative, hence the OR operator. This is by nature inaccurate, but there is no way to blend MSAA sub-samples properly and we need to pick the lesser evil.
     uint resolvedStencil = 0;
+    uint2 pixelCoord = (groupId.xy << 3) + uint2(groupThreadIndex & 0x7, groupThreadIndex >> 3);
 
-    if (dispatchThreadID.x < (uint)_ScreenSize.x && dispatchThreadID.y < (uint)_ScreenSize.y)
+    if (pixelCoord.x < (uint)_ScreenSize.x && pixelCoord.y < (uint)_ScreenSize.y)
     {
         UNITY_UNROLL
         for (uint i = 0; i < NUM_SAMPLES; i++)
         {
             uint2 sampledStencil;
 #ifndef MSAA
-            sampledStencil = LOAD_TEXTURE2D_X(_StencilTexture, dispatchThreadID.xy);
+            sampledStencil = LOAD_TEXTURE2D_X(_StencilTexture, pixelCoord.xy);
 #else
-            sampledStencil = LOAD_TEXTURE2D_X_MSAA(_StencilTexture, dispatchThreadID.xy, i);
+            sampledStencil = LOAD_TEXTURE2D_X_MSAA(_StencilTexture, pixelCoord.xy, i);
 #endif
             resolvedStencil |= GetStencilValue(sampledStencil); // In not MSAA cases the | is the same as assigning given that NUM_SAMPLES is 1
         }
     }
 #if defined(RESOLVE) && defined(MSAA)
-    _OutputStencilBuffer[COORD_TEXTURE2D_X(dispatchThreadID.xy)] = uint2(resolvedStencil, resolvedStencil);
+    _OutputStencilBuffer[COORD_TEXTURE2D_X(pixelCoord.xy)] = uint2(resolvedStencil, resolvedStencil);
 #endif
 
 #ifdef COARSE_STENCIL
 
 #if USE_INTRINSICS
 
     // Need to workaround a warning incorrectly triggered when on Xbox One, so instead of using WaveIsFirstLane()
-    // we check the groupThreadId as in the non intrinsic version.
-    //bool isFirstThread = WaveIsFirstLane();
-    bool isFirstThread = groupThreadId.x == 0 && groupThreadId.y == 0;
+    // we check the groupThreadIndex as in the non intrinsic version.
     uint coarseStencilValue = WaveActiveBitOr(resolvedStencil);
 
-
 #else
 
-    bool isFirstThread = groupThreadId.x == 0 && groupThreadId.y == 0;
-    if (isFirstThread)
-    {
+    if (groupThreadIndex == 0)
         coarseStencilValue = 0;
-    }
 
     GroupMemoryBarrierWithGroupSync();
 
@@ -101,11 +94,11 @@ void Main(uint3 groupId          : SV_GroupID,
 
 #endif
 
-    //This temp is needed outside the if(isFirstThread) condition to workaround a DXC DXIL codegen
+    //This temp is needed outside the if(groupThreadIndex == 0) condition to workaround a DXC DXIL codegen
     // issue https://github.com/microsoft/DirectXShaderCompiler/issues/2743 until it's fixed
     uint perThreadCoarseStencilValue = coarseStencilValue;
 
-    if (isFirstThread)
+    if (groupThreadIndex == 0)
     {
         uint addressIndex = Get1DAddressFromPixelCoord(groupId.xy, _CoarseStencilBufferSize.xy, groupId.z);
         _CoarseStencilBuffer[addressIndex] = perThreadCoarseStencilValue;