Partner/crazyhunter 10.7.0 custom.1.pvdgi cross volumes (#38)

pastasfuture · szymonbonfire · web-flow · commit ff9abbb7f430 · 2021-10-06T14:22:38.000-07:00
* Scaffolding for testing how sampling neighbor probe volumes around edges of dynamic GI volumes can help with propagating GI from neighbors. Needs to be filled in

* typo

* work in progress

* Probe Volumes: Fix up case where ProbeVolume.hlsl is included and LIGHTLOOP_DISABLE_TILE_AND_CLUSTER is defined. Add support for dynamic GI border axes sampling all other probe volumes in order to propagate dynamic GI across volume boundaries.

* Fix fade calculation

* Fix warning about sign / unsign mismatch.

* cache and respect the HDRP asset Dynamic GI toggle at runtime for perf testing

* Probe Volumes: Dynamic GI: Add Neighboring Volume Propagation Mode to Probe Dynamic GI Volume Override for selecting which algorithm is used to inject dynamic GI from neighboring probe volumes at boundaries. Options include Disabled, Sample Neighbors Direction Only (reccomended), and Sample Neighbors Position and Direction

* Probe Volumes: Dynamic GI: If Dynamic GI is on, and Neighboring Volume Propagation is on, force probe volumes to upload to structured buffers and the atlas if they are within the rangeInFrontOfCamera or rangeBehindCamera distance.

* Probe Volume GI: neighboringVolumePropagationMode - change default to SampleNeighborsPositionAndDirection

Co-authored-by: Szymon Swistun &lt;szymon@bonfirestudios.com&gt;
Co-authored-by: pastasfuture &lt;nickb@bonfirestudios.com&gt;
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeDynamicGI.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeDynamicGI.cs
@@ -41,6 +41,8 @@ public class ProbeDynamicGI : VolumeComponent
         public ClampedFloatParameter leakMultiplier = new ClampedFloatParameter(0.0f, 0.0f, 1.0f);
         [Tooltip("Advanced control to bias the distance from the normal of the hit surface to perform direct lighting evaluation on")]
         public ClampedFloatParameter bias = new ClampedFloatParameter(0.05f, 0.0f, 0.33f);
+        [Tooltip("Advanced control for how probes at volume boundaries propagate light from neighboring Probe Volumes.\n\nDisabled: No light is propagated across neighbors.\n\nSample Neighbors Direction Only: Samples all probe volumes once per probe and evaluates light from the resulting probe data for each axis.\n\nSample Neighbors Position and Direction: Samples all probe volumes for all propagation axes at each axes neighboring probe position.\nPotentially more accurate than Sample Neighbors Direction Only, but significantly more expensive.")]
+        public DynamicGINeighboringVolumePropagationModeParameter neighboringVolumePropagationMode = new DynamicGINeighboringVolumePropagationModeParameter(DynamicGINeighboringVolumePropagationMode.SampleNeighborsPositionAndDirection);
 
         [Tooltip("Debug Contribution control for mixing in baked indirect lighting")]
         public ClampedFloatParameter bakeAmount = new ClampedFloatParameter(1.0f, 0.0f, 1.0f);
@@ -64,5 +66,20 @@ public sealed class SHFromSGModeParameter : VolumeParameter<SHFromSGMode>
             public SHFromSGModeParameter(SHFromSGMode value, bool overrideState = false)
                 : base(value, overrideState) {}
         }
+
+        [Serializable]
+        public enum DynamicGINeighboringVolumePropagationMode
+        {
+            Disabled = 0,
+            SampleNeighborsDirectionOnly,
+            SampleNeighborsPositionAndDirection
+        };
+
+        [Serializable]
+        public sealed class DynamicGINeighboringVolumePropagationModeParameter : VolumeParameter<DynamicGINeighboringVolumePropagationMode>
+        {
+            public DynamicGINeighboringVolumePropagationModeParameter(DynamicGINeighboringVolumePropagationMode value, bool overrideState = false)
+                : base(value, overrideState) { }
+        }
     }
 } // UnityEngine.Experimental.Rendering.HDPipeline
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationAxes.compute b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationAxes.compute
@@ -3,6 +3,18 @@
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationSphericalGaussians.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeSphericalHarmonicsLighting.hlsl"
+
+#define LIGHTLOOP_DISABLE_TILE_AND_CLUSTER
+// Force probe volume bilateral filtering off to speed things up.
+// Comment out this line if you would like to use the project wide setting bilateral filtering defined in ShaderConfig.cs
+#define PROBE_VOLUMES_BILATERAL_FILTERING_MODE PROBEVOLUMESBILATERALFILTERINGMODES_DISABLED
+
+// Can force L1 or L0 sampling by modifying this define. When commented out it will use the project wide setting defined in ShaderConfig.cs
+// #define PROBE_VOLUMES_SAMPLING_MODE PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolume.hlsl"
+
+#pragma multi_compile _ SAMPLE_NEIGHBORS_DIRECTION_ONLY SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION
 
 #pragma kernel PropagateLight
 #define GROUP_SIZE 64
@@ -24,12 +36,16 @@ uint _ProbeVolumeDGIResolutionX;
 uint _ProbeVolumeDGIResolutionY;
 uint _ProbeVolumeDGIResolutionZ;
 float3 _ProbeVolumeDGIResolutionInverse;
+float _ProbeVolumeDGIMaxNeighborDistance;
 
 float3 _ProbeVolumeDGIBoundsRight;
 float3 _ProbeVolumeDGIBoundsUp;
 float3 _ProbeVolumeDGIBoundsExtents;
 float3 _ProbeVolumeDGIBoundsCenter;
 
+uint _ProbeVolumeDGILightLayers;
+int _ProbeVolumeDGIEngineDataIndex;
+
 float _RangeInFrontOfCamera;
 float _RangeBehindCamera;
 
@@ -55,6 +71,131 @@ float3 ProbeCoordinatesToWorldPosition(float3 probeCoordinates, float3x3 probeVo
     return mul(localPosition, probeVolumeLtw) + GetAbsolutePositionWS(_ProbeVolumeDGIBoundsCenter);
 }
 
+#if PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0
+    void ProbeVolumeAccumulateDynamicGINeighborsSphericalHarmonicsL0(
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+    void ProbeVolumeAccumulateDynamicGINeighborsSphericalHarmonicsL1(
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L2
+    void ProbeVolumeAccumulateDynamicGINeighborsSphericalHarmonicsL2(
+#endif
+        PositionInputs posInput, float3 normalWS, float3 viewDirectionWS, uint renderingLayers,
+#if PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0
+        out ProbeVolumeSphericalHarmonicsL0 coefficients,
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+        out ProbeVolumeSphericalHarmonicsL1 coefficients,
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L2
+        out ProbeVolumeSphericalHarmonicsL2 coefficients,
+#endif
+        inout float weightHierarchy)
+{
+
+#if PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0
+        ZERO_INITIALIZE(ProbeVolumeSphericalHarmonicsL0, coefficients);
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+        ZERO_INITIALIZE(ProbeVolumeSphericalHarmonicsL1, coefficients);
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L2
+        ZERO_INITIALIZE(ProbeVolumeSphericalHarmonicsL2, coefficients);
+#endif
+    
+    for (int i = 0; i < (int)_ProbeVolumeCount; ++i)
+    {
+        ProbeVolumeEngineData probeVolumeData = _ProbeVolumeDatas[i];
+        OrientedBBox probeVolumeBounds = _ProbeVolumeBounds[i];
+
+        if (ProbeVolumeIsAllWavesComplete(weightHierarchy, probeVolumeData.volumeBlendMode)) { break; }
+
+        // Do not sample ourselves.
+        // TODO: We also likely only want to sample neighboring probe volumes if they are simulating dynamic GI (and ideally, only the dynamic GI portion).
+        if (i != _ProbeVolumeDGIEngineDataIndex)
+        {
+#if PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0
+            ProbeVolumeAccumulateSphericalHarmonicsL0(
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+            ProbeVolumeAccumulateSphericalHarmonicsL1(
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L2
+            ProbeVolumeAccumulateSphericalHarmonicsL2(
+#endif
+                posInput, normalWS, viewDirectionWS, renderingLayers,
+                probeVolumeData, probeVolumeBounds,
+                coefficients,
+                weightHierarchy
+            );
+        }
+    }
+}
+
+SHIncomingIrradiance ProbeVolumeEvaluateIncomingIrradiance(float3 positionWS, uint renderingLayers)
+{
+    float3 positionRWS = GetCameraRelativePositionWS(positionWS);
+    PositionInputs posInput;
+    ZERO_INITIALIZE(PositionInputs, posInput);
+    posInput.positionWS = positionRWS; // TODO: Be careful about RWS here.
+    // float2 positionNDC; // unused in probe volumes.
+    // uint2  positionSS; // unused in probe volumes.
+    // uint2  tileCoord;   // unused in probe volumes with light lists disabled.
+    // float  deviceDepth; // unused in probe volumes.
+    posInput.linearDepth = abs(mul(GetWorldToViewMatrix(), float4(positionRWS, 1.0)).z); // needed for depth fade. TODO: Should be a max(0.0) but need to figure out the sign flip here.
+
+    // Completely disable normal and view bias in this context by setting the normal and view to zero.
+    // They are only used for bias.
+    const float3 normalWSForBias = 0.0;
+    const float3 viewDirectionWSForBias = 0.0;
+    SHIncomingIrradiance shIncomingIrradiance;
+    ZERO_INITIALIZE(SHIncomingIrradiance, shIncomingIrradiance);
+    float weightHierarchy = 0.0;
+
+#if PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0
+    #error "Need to define implementation of ProbeVolumeEvaluateIncomingRadiance for PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L0"
+    // TODO:
+    // ProbeVolumeSphericalHarmonicsL0 coefficients;
+    // ProbeVolumeAccumulateSphericalHarmonicsL0(posInput, normalWS, normalWS, renderingLayers, coefficients, weightHierarchy);
+    // bakeDiffuseLighting += ProbeVolumeEvaluateSphericalHarmonicsL0(normalWS, coefficients);
+
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1
+    #error "Need to define implementation of ProbeVolumeEvaluateIncomingRadiance for PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L1"
+    // TODO:
+    // ProbeVolumeSphericalHarmonicsL1 coefficients;
+    // ProbeVolumeAccumulateDynamicGINeighborsSphericalHarmonicsL1(posInput, normalWSForBias, viewDirectionWSForBias, renderingLayers, coefficients, weightHierarchy);
+
+#elif PROBE_VOLUMES_SAMPLING_MODE == PROBEVOLUMESENCODINGMODES_SPHERICAL_HARMONICS_L2
+    ProbeVolumeSphericalHarmonicsL2 coefficients;
+    ProbeVolumeAccumulateDynamicGINeighborsSphericalHarmonicsL2(posInput, normalWSForBias, viewDirectionWSForBias, renderingLayers, coefficients, weightHierarchy);
+
+    SHOutgoingRadiosityWithProjectedConstantsPacked outgoingRadiosityProjectedConstantsPacked;
+    [unroll] for (int i = 0; i < SH_PACKED_COEFFICIENT_COUNT; ++i) { outgoingRadiosityProjectedConstantsPacked.data[i] = coefficients.data[i]; }
+    SHOutgoingRadiosityWithProjectedConstants outgoingRadiosityProjectedConstants = SHOutgoingRadiosityWithProjectedConstantsCompute(outgoingRadiosityProjectedConstantsPacked);
+    SHOutgoingRadiosity bakedOutgoingRadiosity = SHOutgoingRadiosityCompute(outgoingRadiosityProjectedConstants);
+    shIncomingIrradiance = SHIncomingIrradianceCompute(bakedOutgoingRadiosity);
+#endif
+
+    return shIncomingIrradiance;   
+}
+
+float3 ProbeVolumeEvaluateIncomingRadiance(SHIncomingIrradiance shIncomingIrradiance, float3 directionWS)
+{
+    // TODO: Rather than simply point sampling the incoming radiance, we could approximately evaluate the integral of the axis SG and the SH term using very similar math
+    // to what we use for converting from SGs to SH in ProbePropagationCombine.compute.
+    // In short, we would generate a zonal harmonic that approximately represents our SG, use it as a window for our SH data, compute the integral of our windowed SH term over the sphere,
+    // and use that as the amplitude for our axis SG (likely requires careful normalization).
+    // Point sampling might be good enough - would just be nice to have the option to compare.
+    float3 incomingRadiance = IncomingRadianceCompute(shIncomingIrradiance, directionWS);
+
+    // Values can be negative due to ringing. Clip off negative values.
+    incomingRadiance = max(0.0, incomingRadiance);
+
+    return incomingRadiance;
+}
+
+bool IsBoundaryProbe(uint3 probeCoordinate, uint3 resolution)
+{
+    return (probeCoordinate.x == 0) 
+        || (probeCoordinate.y == 0)
+        || (probeCoordinate.z == 0)
+        || ((probeCoordinate.x + 1) == resolution.x)
+        || ((probeCoordinate.y + 1) == resolution.y)
+        || ((probeCoordinate.z + 1) == resolution.z);
+}
+
 [numthreads(GROUP_SIZE, 1, 1)]
 void PropagateLight(uint3 id : SV_DispatchThreadID)
 {
@@ -68,14 +209,23 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         uint3 probeCoordinate = ProbeIndexToProbeCoordinatesUint(probeIndex);
 
         const float3x3 probeVolumeLtw = float3x3(_ProbeVolumeDGIBoundsRight, _ProbeVolumeDGIBoundsUp, cross(_ProbeVolumeDGIBoundsRight, _ProbeVolumeDGIBoundsUp));
-        const float3 worldPosition =  ProbeCoordinatesToWorldPosition(probeCoordinate, probeVolumeLtw);
+        const float3 probePositionWS =  ProbeCoordinatesToWorldPosition(probeCoordinate, probeVolumeLtw);
 
         // Early out at far distances
-        if (IsFarFromCamera(worldPosition, _RangeInFrontOfCamera, _RangeBehindCamera))
+        if (IsFarFromCamera(probePositionWS, _RangeInFrontOfCamera, _RangeBehindCamera))
         {
             return;
         }
 
+#if defined(SAMPLE_NEIGHBORS_DIRECTION_ONLY)
+        SHIncomingIrradiance shIncomingIrradiance;
+        ZERO_INITIALIZE(SHIncomingIrradiance, shIncomingIrradiance);
+        if (IsBoundaryProbe(probeCoordinate, uint3(_ProbeVolumeDGIResolutionX, _ProbeVolumeDGIResolutionY, _ProbeVolumeDGIResolutionZ)))
+        {
+            shIncomingIrradiance = ProbeVolumeEvaluateIncomingIrradiance(probePositionWS, _ProbeVolumeDGILightLayers);
+        }
+#endif
+
         float3 incomingRadiance = 0;
         float weight = 0.0f;
         float probeValidity = 0;
@@ -84,6 +234,9 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         for(int i=0; i < NEIGHBOR_AXIS_COUNT; ++i)
         {
             float3 neighborDirection = _RayAxis[i].xyz;
+            float neighborAxisLength = _RayAxis[i].w;
+            float3 neighborWorldDirection = mul(neighborDirection, probeVolumeLtw);
+
             uint sampleAxis = probeIndex * NEIGHBOR_AXIS_COUNT + i;
             NeighborAxis neighbor = _ProbeVolumeNeighbors[sampleAxis];
 
@@ -111,7 +264,6 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
                 int3 offset = GetNeighborAxisOffset(i);
                 int3 neighborProbeCoordinate = probeCoordinate + offset;
 
-                //TODO: remove missed axis on generation to avoid this branch entirely here
                 if(neighborProbeCoordinate.x >= 0 && neighborProbeCoordinate.x < (int)_ProbeVolumeDGIResolutionX &&
                    neighborProbeCoordinate.y >= 0 && neighborProbeCoordinate.y < (int)_ProbeVolumeDGIResolutionY &&
                    neighborProbeCoordinate.z >= 0 && neighborProbeCoordinate.z < (int)_ProbeVolumeDGIResolutionZ)
@@ -122,6 +274,18 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
                     weight += sgWeight;
                     incomingRadiance += prevAxisRadiance * sgWeight;
                 }
+#if defined(SAMPLE_NEIGHBORS_DIRECTION_ONLY) || defined(SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION)
+                else
+                {
+#if defined(SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION)
+                    // sample neighbor probe volumes to gather radiance from neighbor volumes
+                    float3 boundaryEdgePositionWS = probePositionWS + neighborWorldDirection * neighborAxisLength * _ProbeVolumeDGIMaxNeighborDistance;
+                    SHIncomingIrradiance shIncomingIrradiance = ProbeVolumeEvaluateIncomingIrradiance(boundaryEdgePositionWS, _ProbeVolumeDGILightLayers);
+#endif
+                    weight += sgWeight;
+                    incomingRadiance += ProbeVolumeEvaluateIncomingRadiance(shIncomingIrradiance, neighborWorldDirection) * sgWeight;
+                }
+#endif
             }
         }
 
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeDynamicGI.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeDynamicGI.cs
@@ -402,10 +402,36 @@ void DispatchPropagationAxes(CommandBuffer cmd, ProbeVolumeHandle probeVolume, i
             var obb = probeVolume.GetProbeVolumeEngineDataBoundingBox();
             var data = probeVolume.GetProbeVolumeEngineData();
 
+            switch (giSettings.neighboringVolumePropagationMode.value)
+            {
+                case ProbeDynamicGI.DynamicGINeighboringVolumePropagationMode.SampleNeighborsDirectionOnly:
+                {
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_DIRECTION_ONLY", true);
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION", false);
+                    break;
+                }
+                case ProbeDynamicGI.DynamicGINeighboringVolumePropagationMode.SampleNeighborsPositionAndDirection:
+                {
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_DIRECTION_ONLY", false);
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION", true);
+                    break;
+                }
+                case ProbeDynamicGI.DynamicGINeighboringVolumePropagationMode.Disabled:
+                default:
+                {
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_DIRECTION_ONLY", false);
+                    CoreUtils.SetKeyword(shader, "SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION", false);
+                    break;
+                }
+            }
+
+            cmd.SetComputeFloatParam(shader, "_ProbeVolumeDGIMaxNeighborDistance", data.maxNeighborDistance);
             cmd.SetComputeIntParam(shader, "_ProbeVolumeDGIResolutionXY", (int)data.resolutionXY);
             cmd.SetComputeIntParam(shader, "_ProbeVolumeDGIResolutionX", (int)data.resolutionX);
             cmd.SetComputeIntParam(shader, "_ProbeVolumeDGIResolutionY", (int)data.resolution.y);
             cmd.SetComputeIntParam(shader, "_ProbeVolumeDGIResolutionZ", (int)data.resolution.z);
+            cmd.SetComputeIntParam(shader, "_ProbeVolumeDGILightLayers", unchecked((int)data.lightLayers));
+            cmd.SetComputeIntParam(shader, "_ProbeVolumeDGIEngineDataIndex", probeVolume.GetProbeVolumeEngineDataIndex());
             cmd.SetComputeVectorParam(shader, "_ProbeVolumeDGIResolutionInverse", data.resolutionInverse);
             cmd.SetComputeVectorParam(shader, "_ProbeVolumeDGIBoundsRight", obb.right);
             cmd.SetComputeVectorParam(shader, "_ProbeVolumeDGIBoundsUp", obb.up);
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeSphericalHarmonicsLighting.hlsl b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeSphericalHarmonicsLighting.hlsl
@@ -295,6 +295,7 @@ SHIncomingIrradiance SHIncomingIrradianceCompute(SHOutgoingRadiosity shOutgoingR
 
     SHIncomingIrradiance shIncomingIrradiance;
 
+    [unroll]
     for (int i = 0; i < SH_COEFFICIENT_COUNT; ++i)
     {
         shIncomingIrradiance.data[i] = (shOutgoingRadiosity.data[i] / shConvolveCosineLobeConstants[i]) * PI;
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolume.hlsl b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolume.hlsl
@@ -19,6 +19,7 @@
 #endif
 
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonLighting.hlsl" // Needed for IsMatchingLightLayer().
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolume.cs.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeLightLoopDef.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeAtlas.hlsl"
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeLightLoopDef.hlsl b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeLightLoopDef.hlsl
@@ -192,8 +192,14 @@ uint ProbeVolumeFetchIndex(uint probeVolumeStart, uint probeVolumeOffset)
     return ProbeVolumeMaterialPassFetchIndex(probeVolumeStart, probeVolumeOffset);
 #else // #if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
     // Access probe volume data from standard lightloop light list data structure.
+
+#if defined(LIGHTLOOP_DISABLE_TILE_AND_CLUSTER)
+    return probeVolumeStart + probeVolumeOffset;
+#else
     return FetchIndex(probeVolumeStart, probeVolumeOffset);
 #endif
+
+#endif
 }
 
 // This function scalarize an index accross all lanes. To be effecient it must be used in the context
diff --git a/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeLighting.cs b/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/ProbeVolumeLighting.cs

Original file line number	Diff line number	Diff line change
`@@ -295,6 +295,7 @@ SHIncomingIrradiance SHIncomingIrradianceCompute(SHOutgoingRadiosity shOutgoingR`
`295`	`295`
`296`	`296`	`SHIncomingIrradiance shIncomingIrradiance;`
`297`	`297`
	`298`	`+ [unroll]`
`298`	`299`	`for (int i = 0; i < SH_COEFFICIENT_COUNT; ++i)`
`299`	`300`	`{`
`300`	`301`	`shIncomingIrradiance.data[i] = (shOutgoingRadiosity.data[i] / shConvolveCosineLobeConstants[i]) * PI;`