Fix jittering artifact in Surface Cache caused by "rank flipping"

Author: urasmus

Packages/com.unity.render-pipelines.core/Runtime/Lighting/SurfaceCache/Estimation.hlsl

@@ -57,7 +57,7 @@ void ProcessAndStoreRadianceSample(RWStructuredBuffer<SphericalHarmonics::RGBL1>
     SphericalHarmonics::CosineConvolve(radianceSample);
 
     PatchUtil::PatchStatisticsSet oldStats = patchStatistics[patchIdx];
-    const uint oldUpdateCount = PatchUtil::GetUpdateCount(oldStats.patchCounters);
+    const uint oldUpdateCount = PatchUtil::GetUpdateCount(oldStats.counters);
     const uint newUpdateCount = min(oldUpdateCount + 1, PatchUtil::updateMax);
 
     const SphericalHarmonics::RGBL1 oldIrradiance = patchIrradiances[patchIdx];
@@ -79,9 +79,8 @@ void ProcessAndStoreRadianceSample(RWStructuredBuffer<SphericalHarmonics::RGBL1>
     PatchUtil::PatchStatisticsSet newStats;
     newStats.mean = newL0ShortIrradiance;
     newStats.variance = newVariance;
-    newStats.patchCounters = oldStats.patchCounters;
-    PatchUtil::SetUpdateCount(newStats.patchCounters, newUpdateCount);
-    newStats.rank = oldStats.rank;
+    newStats.counters = oldStats.counters;
+    PatchUtil::SetUpdateCount(newStats.counters, newUpdateCount);
     patchStatistics[patchIdx] = newStats;
 }
 
@@ -223,7 +222,7 @@ void Estimate(UnifiedRT::DispatchInfo dispatchInfo)
     QrngKronecker2D rng;
 
     const PatchUtil::PatchGeometry patchGeo = _PatchGeometries[patchIdx];
-    bool enablePatchAllocation = (_PatchStatistics[patchIdx].rank == 0);
+    bool enablePatchAllocation = (PatchUtil::GetRank(_PatchStatistics[patchIdx].counters) == 0);
 
     MaterialPoolParamSet matPoolParams;
     matPoolParams.materialEntries = _MaterialEntries;

Packages/com.unity.render-pipelines.core/Runtime/Lighting/SurfaceCache/Eviction.compute

@@ -11,41 +11,40 @@ RWStructuredBuffer<uint> _PatchCellIndices;
 
 uint _RingConfigOffset;
 uint _FrameIdx;
-
-uint ModuloDistance(uint a, uint b, uint modulo)
-{
-    int dif = abs(int(a) - int(b));
-    return min(dif, modulo - dif);
-}
+uint _BouncePatchAllocation;
 
 [numthreads(256, 1, 1)]
 void Evict(uint patchIdx : SV_DispatchThreadID)
 {
     if (!RingBuffer::IsPositionInUse(_RingConfigBuffer, _RingConfigOffset, patchIdx))
         return;
 
-    const uint evictionThreshold = _PatchStatistics[patchIdx].rank == 0 ? 60 * 4 : 60 * 1; // patches allocated from bounce hits are evicted sooner
-
-    // Reset all patches rank to 1 (that is not allowed to spawn more patches on bounces hit)
-    // Rank will be updated to 0 by the PatchAllocation.compute shader for patches that are seen from the camera
-    _PatchStatistics[patchIdx].rank = 1;
-
     const uint cellIdx = _PatchCellIndices[patchIdx];
     if (cellIdx == PatchUtil::invalidCellIndex)
         return;
 
-    const PatchUtil::PatchCounterSet counterSet = _PatchStatistics[patchIdx].patchCounters;
-    const uint lastAccessFrameIdx = PatchUtil::GetLastAccessFrame(counterSet);
+    PatchUtil::PatchStatisticsSet stats = _PatchStatistics[patchIdx];
 
-    // Here we take into account that last frame access index is in [0, 2^16-1].
-    // We use that the last frame index can never be later than current frame index.
-    const uint modulo = 65536; // 2^16
-    const uint frameSinceLastUse = ModuloDistance(_FrameIdx % modulo, lastAccessFrameIdx, modulo);
+    const uint frameSinceLastAccess = PatchUtil::GetFramesSinceLastAccess(_FrameIdx, PatchUtil::GetLastAccessFrame(stats.counters));
 
-    if (evictionThreshold < frameSinceLastUse)
+    if (PatchUtil::evictionThreshold < frameSinceLastAccess)
     {
-        _PatchCellIndices[patchIdx] = PatchUtil::invalidCellIndex;
-        _CellAllocationMarks[cellIdx] = 0;
-        _CellPatchIndices[cellIdx] = PatchUtil::invalidPatchIndex;
+        // If Bounce Patch Allocation is enabled, then rank 0 patches are
+        // first demoted to rank 1, then later they are evicted.
+        // If Bounce Patch Allocation is disabled we go directly to
+        // eviction.
+        if (_BouncePatchAllocation && PatchUtil::GetRank(stats.counters) == 0)
+        {
+            PatchUtil::SetRank(stats.counters, 1);
+            PatchUtil::SetLastAccessFrame(stats.counters, _FrameIdx);
+            _PatchStatistics[patchIdx] = stats;
+        }
+        else
+        {
+            _PatchCellIndices[patchIdx] = PatchUtil::invalidCellIndex;
+            _CellAllocationMarks[cellIdx] = 0;
+            _CellPatchIndices[cellIdx] = PatchUtil::invalidPatchIndex;
+        }
     }
+
 }

Packages/com.unity.render-pipelines.core/Runtime/Lighting/SurfaceCache/PatchUtil.hlsl

@@ -43,6 +43,7 @@ namespace PatchUtil
     static const uint volumeAngularResolution = 4; // Must match C# side.
     static const float3 invalidIrradiance = float3(-1, -1, -1);
     static const uint updateMax = 32;
+    static const uint evictionThreshold = 60 * 4;
 
     struct PatchGeometry
     {
@@ -52,15 +53,18 @@ namespace PatchUtil
 
     struct PatchCounterSet
     {
+        // Layout
+        // 0x000000FF: Update count.
+        // 0x0000FF00: Rank.
+        // 0xFFFF0000: Last access frame.
         uint data;
     };
 
     struct PatchStatisticsSet
     {
         float3 mean;
         float3 variance;
-        PatchCounterSet patchCounters;
-        uint rank;
+        PatchCounterSet counters;
     };
 
     struct VolumeParamSet
@@ -81,14 +85,41 @@ namespace PatchUtil
         uint ringConfigOffset;
     };
 
-    void Reset(inout PatchCounterSet set)
+    uint ModuloDistance(uint a, uint b, uint modulo)
+    {
+            int dif = abs(int(a) - int(b));
+            return min(dif, modulo - dif);
+    }
+
+    uint GetFramesSinceLastAccess(uint currentFrameIdx, uint patchLastAccessFrame)
+    {
+        // Here we take into account that last access frame index is in [0, 2^16-1].
+        // We use that the last frame index can never be later than current frame index.
+        const uint modulo = 65536; // 2^16
+        return ModuloDistance(
+            currentFrameIdx % modulo,
+            patchLastAccessFrame,
+            modulo);
+    }
+
+    void Reset(out PatchCounterSet set)
     {
         set.data = 0;
     }
 
     uint GetUpdateCount(PatchCounterSet set)
     {
-        return set.data & 0xFFFF;
+        return set.data & 0xFF;
+    }
+
+    uint GetRank(PatchCounterSet set)
+    {
+        return (set.data & 0xFF00) >> 8;
+    }
+
+    void SetRank(inout PatchCounterSet set, uint rank)
+    {
+        set.data = (rank << 8) | (set.data & 0xFFFF00FF);
     }
 
     uint GetLastAccessFrame(PatchCounterSet set)
@@ -98,7 +129,7 @@ namespace PatchUtil
 
     void SetUpdateCount(inout PatchCounterSet set, uint updateCount)
     {
-        set.data = updateCount | (set.data & 0xFFFF0000);
+        set.data = updateCount | (set.data & 0xFFFFFF00);
     }
 
     void SetLastAccessFrame(inout PatchCounterSet set, uint lastAccessFrame)
@@ -113,9 +144,9 @@ namespace PatchUtil
 
     void WriteLastFrameAccess(RWStructuredBuffer<PatchUtil::PatchStatisticsSet> statisticsSets, uint patchIdx, uint frameIdx)
     {
-        PatchCounterSet counterSet = statisticsSets[patchIdx].patchCounters;
+        PatchCounterSet counterSet = statisticsSets[patchIdx].counters;
         SetLastAccessFrame(counterSet, frameIdx);
-        statisticsSets[patchIdx].patchCounters = counterSet;
+        statisticsSets[patchIdx].counters = counterSet;
     }
 
     float GetVoxelSize(float voxelMinSize, uint cascadeIdx)
@@ -166,14 +197,14 @@ namespace PatchUtil
     {
         // To avoid discontinuities near the cardinal axis directions, we apply an arbitrary rotation.
         // This is based on the assumption that surfaces oriented along the cardinal axis directions
-        // are most likely in a scene compared to other directions.
+        // are more likely in a scene compared to other directions.
         const float3x3 arbitraryRotation = float3x3(
             float3(0.34034f, -0.30925f, 0.888f),
             float3(-0.30925f, 0.85502f, 0.41629f),
             float3(-0.888f, -0.41629f, 0.19536f));
         const float3 rotatedDirection = mul(arbitraryRotation, direction);
 
-        const uint2 angularSquarePos = min(uint2(3, 3), SphereToSquare(rotatedDirection) * angularResolution);
+        const uint2 angularSquarePos = min(uint2(angularResolution - 1, angularResolution - 1), SphereToSquare(rotatedDirection) * angularResolution);
         return angularSquarePos.y * angularResolution + angularSquarePos.x;
     }
 
@@ -321,7 +352,7 @@ namespace PatchUtil
         return resultBool;
     }
 
-    uint FindPatchIndex(VolumeParamSet volumeParams, StructuredBuffer<uint> cellPatchIndices, float3 worldPosition, float3 worldNormal)
+    uint FindPatchIndex(VolumeParamSet volumeParams, CellPatchIndexBufferType cellPatchIndices, float3 worldPosition, float3 worldNormal)
     {
         VolumePositionResolution posResolution = ResolveVolumePosition(worldPosition, volumeParams);
         if (posResolution.isValid())
@@ -345,7 +376,7 @@ namespace PatchUtil
         }
     }
 
-    uint FindPatchIndexAndUpdateLastAccess(VolumeParamSet volumeParams, StructuredBuffer<uint> cellPatchIndices, RWStructuredBuffer<PatchUtil::PatchStatisticsSet> patchStatisticSets, float3 worldPosition, float3 worldNormal, uint frameIdx)
+    uint FindPatchIndexAndUpdateLastAccess(VolumeParamSet volumeParams, CellPatchIndexBufferType cellPatchIndices, RWStructuredBuffer<PatchUtil::PatchStatisticsSet> patchStatisticSets, float3 worldPosition, float3 worldNormal, uint frameIdx)
     {
         const uint patchIdx = FindPatchIndex(volumeParams, cellPatchIndices, worldPosition, worldNormal);
         if (patchIdx != invalidPatchIndex)
@@ -384,12 +415,17 @@ namespace PatchUtil
             resultIrradiance);
     }
 
+    float3 EvalIrradiance(SphericalHarmonics::RGBL1 irradiance, float3 normal)
+    {
+        return max(0, SphericalHarmonics::Eval(irradiance, normal));
+    }
+
     float3 ReadPlanarIrradiance(PatchIrradianceBufferType patchIrradiances, CellPatchIndexBufferType cellPatchIndices, uint spatialResolution, uint cascadeIdx, uint3 volumeSpacePosition, float3 worldNormal)
     {
         SphericalHarmonics::RGBL1 resultIrradiance;
         bool resultBool = ReadHemisphericalIrradiance(patchIrradiances, cellPatchIndices, spatialResolution, cascadeIdx, volumeSpacePosition, worldNormal, resultIrradiance);
         if (resultBool)
-            return max(0, SphericalHarmonics::Eval(resultIrradiance, worldNormal));
+            return EvalIrradiance(resultIrradiance, worldNormal);
         else
             return invalidIrradiance;
     }
@@ -420,20 +456,16 @@ namespace PatchUtil
 
     PatchStatisticsSet InitPatchStatistics(float3 irradianceSeed, uint frameIndex, uint rank)
     {
-        PatchCounterSet counterSet;
-        Reset(counterSet);
-        PatchUtil::SetLastAccessFrame(counterSet, frameIndex);
-
         PatchStatisticsSet stats;
         stats.mean = irradianceSeed;
         stats.variance = 0;
-        stats.patchCounters = counterSet;
-        stats.rank = rank;
+        Reset(stats.counters);
+        SetLastAccessFrame(stats.counters, frameIndex);
+        SetRank(stats.counters, rank);
 
         return stats;
     }
 
-
 #if BOUNCE_PATCH_ALLOCATION
     void AllocatePatch(
         float3 worldPosition,
@@ -461,17 +493,17 @@ namespace PatchUtil
             allocParams.cellAllocationMarks,
             cellIdx);
 
-        if (resolutionResult.code == PatchUtil::patchIndexResolutionCodeAllocationFailure || resolutionResult.code == PatchUtil::patchIndexResolutionCodeLookup)
-            return;
-
-        PatchUtil::PatchGeometry geo;
-        geo.position = worldPosition;
-        geo.normal = worldNormal;
-        patchGeometries[resolutionResult.patchIdx] = geo;
-
-        SphericalHarmonics::RGBL1 irradianceSeed = (SphericalHarmonics::RGBL1) 0;
-        patchIrradiances[resolutionResult.patchIdx] = irradianceSeed;
-        patchStatistics[resolutionResult.patchIdx] = PatchUtil::InitPatchStatistics(irradianceSeed.l0, frameIndex, /*rank*/ 1);
+        if (resolutionResult.code == PatchUtil::patchIndexResolutionCodeAllocationSuccess)
+        {
+            PatchUtil::PatchGeometry geo;
+            geo.position = worldPosition;
+            geo.normal = worldNormal;
+            patchGeometries[resolutionResult.patchIdx] = geo;
+
+            SphericalHarmonics::RGBL1 irradianceSeed = (SphericalHarmonics::RGBL1)0;
+            patchIrradiances[resolutionResult.patchIdx] = irradianceSeed;
+            patchStatistics[resolutionResult.patchIdx] = PatchUtil::InitPatchStatistics(irradianceSeed.l0, frameIndex, /*rank*/ 1);
+        }
     }
 #endif
 }

Packages/com.unity.render-pipelines.core/Runtime/Lighting/SurfaceCache/PathTracing.hlsl

@@ -232,9 +232,8 @@ float3 OutgoingDirectionalBounceAndMultiBounceRadiance(
     PatchUtil::VolumeParamSet volumeParams,
     float3 albedo,
     float3 emission,
-    out bool multiBounceSurfaceCacheMiss)
+    out uint bouncePatchIndex)
 {
-    multiBounceSurfaceCacheMiss = false;
     float3 radiance = 0.0f;
 
     if (any(dirLightIntensity != 0.0f))
@@ -248,21 +247,20 @@ float3 OutgoingDirectionalBounceAndMultiBounceRadiance(
             shadowRay.tMin = 0;
             shadowRay.tMax = FLT_MAX;
 
-            UnifiedRT::Hit hitResult2 = UnifiedRT::TraceRayClosestHit(dispatchInfo, accelStruct, 0xFFFFFFFF, shadowRay, UnifiedRT::kRayFlagNone);
-            if (!hitResult2.IsValid())
+            UnifiedRT::Hit hitResult = UnifiedRT::TraceRayClosestHit(dispatchInfo, accelStruct, 0xFFFFFFFF, shadowRay, UnifiedRT::kRayFlagNone);
+            if (!hitResult.IsValid())
             {
                 radiance += dirLightIntensity * dot(-dirLightDirection, normal);
             }
         }
     }
 
+    bouncePatchIndex = PatchUtil::invalidPatchIndex;
     if (multiBounce)
     {
-        float3 cacheRead = PatchUtil::ReadPlanarIrradiance(patchIrradiances, cellPatchIndices, volumeParams, position, normal);
-        if (all(cacheRead != PatchUtil::invalidIrradiance))
-            radiance += cacheRead;
-        else
-            multiBounceSurfaceCacheMiss = true;
+        bouncePatchIndex = PatchUtil::FindPatchIndex(volumeParams, cellPatchIndices, position, normal);
+        if (bouncePatchIndex != PatchUtil::invalidPatchIndex)
+            radiance += PatchUtil::EvalIrradiance(patchIrradiances[bouncePatchIndex], normal);
     }
 
     radiance *= albedo * INV_PI;
@@ -304,7 +302,7 @@ float3 IncomingEnviromentAndDirectionalBounceAndMultiBounceRadiance(
             const float3 hitAlbedo = MaterialPool::LoadAlbedoWithBoost(matEntry, matPoolParams.albedoTextures, matPoolParams.albedoSampler, matPoolParams.atlasTexelSize, matPoolParams.albedoBoost, hitGeo.uv0, hitGeo.uv1);
             const float3 hitEmission = MaterialPool::LoadEmission(matEntry, matPoolParams.emissionTextures, matPoolParams.emissionSampler, matPoolParams.atlasTexelSize, hitGeo.uv0, hitGeo.uv1);
 
-            bool multiBounceSurfaceCacheMiss = false;
+            uint bouncePatchIndex;
             radiance = OutgoingDirectionalBounceAndMultiBounceRadiance(
                 hitGeo.position,
                 hitGeo.normal,
@@ -318,20 +316,32 @@ float3 IncomingEnviromentAndDirectionalBounceAndMultiBounceRadiance(
                 volumeParams,
                 hitAlbedo,
                 hitEmission,
-                multiBounceSurfaceCacheMiss);
+                bouncePatchIndex);
 
             #if BOUNCE_PATCH_ALLOCATION
-            if (multiBounceSurfaceCacheMiss && enablePatchAllocation)
+            if (enablePatchAllocation)
             {
-                PatchUtil::AllocatePatch(
-                    hitGeo.position,
-                    hitGeo.normal,
-                    patchIrradiances,
-                    patchGeometries,
-                    patchStatistics,
-                    allocParams,
-                    volumeParams,
-                    frameIndex);
+                if (bouncePatchIndex == PatchUtil::invalidPatchIndex)
+                {
+                    PatchUtil::AllocatePatch(
+                           hitGeo.position,
+                           hitGeo.normal,
+                           patchIrradiances,
+                           patchGeometries,
+                           patchStatistics,
+                           allocParams,
+                           volumeParams,
+                           frameIndex);
+                }
+                else
+                {
+                    PatchUtil::PatchCounterSet counters = patchStatistics[bouncePatchIndex].counters;
+                    if (PatchUtil::GetRank(counters) == 1)
+                    {
+                        PatchUtil::SetLastAccessFrame(counters, frameIndex);
+                        patchStatistics[bouncePatchIndex].counters = counters;
+                    }
+                }
             }
             #endif
         }