Apply reflection probes in the order defined by their volume

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 
                     for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
                     {
-                        var probe = cullResults.visibleReflectionProbes[probeIndex];
+                        VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];
 
                         // probe.texture can be null when we are adding a reflection probe in the editor
                         if (probe.texture == null || envLightCount >= k_MaxEnvLightsOnScreen)
                         LightVolumeType lightVolumeType = probe.boxProjection != 0 ? LightVolumeType.Box : LightVolumeType.Box;
                         ++envLightCount;
 
-                        // 16 bit lightVolume, 16 bit index
-                        sortKeys[sortCount++] = (uint)lightVolumeType << 16 | (uint)probeIndex;
+                        float boxVolume = 8 * probe.bounds.extents.x * probe.bounds.extents.y * probe.bounds.extents.z;
+                        float logVolume = Mathf.Clamp(256 + Mathf.Log(boxVolume, 1.1f), 0, 8191); // Allow for negative exponents
+
+                        // 13 bit volume, 3 bit LightVolumeType, 16 bit index
+                        sortKeys[sortCount++] = (uint)logVolume << 19 | (uint)lightVolumeType << 16 | ((uint)probeIndex & 0xFFFF); // Sort by volume
                     }
 
                     // Not necessary yet but call it for future modification with sphere influence volume
                     {
                         // In 1. we have already classify and sorted the light, we need to use this sorted order here
                         uint sortKey = sortKeys[sortIndex];
-                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0xFFFF);
+                        LightVolumeType lightVolumeType = (LightVolumeType)((sortKey >> 16) & 0x3);
                         int probeIndex = (int)(sortKey & 0xFFFF);
 
                         VisibleReflectionProbe probe = cullResults.visibleReflectionProbes[probeIndex];

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

         #endif
     }
 
-    float3 iblDiffuseLighting = float3(0.0, 0.0, 0.0);
+    float3 iblDiffuseLighting  = float3(0.0, 0.0, 0.0);
-
-    // TODO: Check the reflection hierarchy, for the current system (matching legacy unity) we must sort from bigger solid angle to lower (lower override bigger). So begging by sky
-    // TODO: Change the way it is done by reversing the order, from smaller solid angle to bigger, so we can early out when the weight is 1.
-    // Only apply sky IBL if the sky texture is available.
-    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
-    {
-        if(_EnvLightSkyEnabled)
-        {
-            float3 localDiffuseLighting, localSpecularLighting;
-            float2 weight;
-            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
-            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
-            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
-            iblDiffuseLighting = lerp(iblDiffuseLighting, localDiffuseLighting, weight.x); // Should be remove by the compiler if it is smart as all is constant 0
-            iblSpecularLighting = lerp(iblSpecularLighting, localSpecularLighting, weight.y);
-        }
-    }
+    float  totalIblWeight      = 0; // Max: 1
+    // Reflection probes are sorted by volume (in the increasing order).
-        #ifdef LIGHTLOOP_TILE_PASS
-
+    #ifdef LIGHTLOOP_TILE_PASS
+    #else
+        uint envLightCount = _EnvLightCount;
+    #endif
-        for(i = 0; i < envLightCount; ++i)
+        for(i = 0; i < envLightCount && totalIblWeight < 1.0; ++i)
+        #ifdef LIGHTLOOP_TILE_PASS
+            uint envLightIndex = FetchIndex(envLightStart, i);
+        #else
+            uint envLightIndex = i;
+        #endif
+
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[FetchIndex(envLightStart, i)], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[envLightIndex], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = saturate(accumulatedWeight);
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
+
-
-        #else
+    }
-        for (i = 0; i < _EnvLightCount; ++i)
+    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
+    {
+        // Only apply the sky IBL if the sky texture is available, and if we haven't yet accumulated enough IBL lighting.
+        if(_EnvLightSkyEnabled && totalIblWeight < 1.0)
-            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES;
-            EvaluateBSDF_Env(context, V, posInput, prelightData, _EnvLightDatas[i], bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // The sky is a single cubemap texture separate from the reflection probe texture array (different resolution and compression)
+            context.sampleReflection = SINGLE_PASS_CONTEXT_SAMPLE_SKY;
+            EnvLightData envLightSky = InitSkyEnvLightData(0); // The sky data are generated on the fly so the compiler can optimize the code
+            EvaluateBSDF_Env(context, V, posInput, prelightData, envLightSky, bsdfData, localDiffuseLighting, localSpecularLighting, weight);
+
+            // IBL weights should not exceed 1.
+            float accumulatedWeight = totalIblWeight + weight.y;
+            totalIblWeight          = 1.0;
+            weight.y               -= saturate(accumulatedWeight - totalIblWeight);
+
-
-        #endif
     }
 
     // Apply ambient occlusion on direct lighting based on strenght factor