Dynamic GI:

Max Sim Per Frame Control per Probe Volumes Dynamic GI (#44)

* Control over max # of probe volume dynamic GI simulation's per frame

* fixed issues with static value construction

* More direct control of perf controls to dynamic GI

Less GC allocations and better cleanup

Cleanup and removed the need entirely clearing radiance cache on first frame of probe volume dynamic GI sim. compute shaders just handle that first frame case via variant instead. Removes hitches this way

Sometimes we got NaN's, so added an extra safe clear on radiance data but via compute dispatch when needed

slight bug fix to previous commit

Quality variants for propagation axis amounts

Dynamic GI:

Added basic probe volume dynamic GI stats

more dynamic GI stats

Optimize GI data layout (#45)

* Optimized the layout of the dynamic GI data.
* Added migration of existing baked data to new layout. Context menu item "Reserialize (All)" on Probe Volume Asset now also runs the migration. Had to move the migration code from Probe Volume to Probe Volume Asset for this.
Limitation: Context menu migration is skipped for assets of version < 3, since updating to v.3 requires rotation from an object in a scene.
* Apply inverse-square law to propagation axis weights to get a more correct distribution for diagonal axes.

Dynamic GI:

Dynamic GI baked emission (#51)

* Bake emission into dynamic GI neighbors and use it in the propagation.

* Use 2x2 pixel blocks per baking request to control texture lods with uv and position gradients within these blocks.

* Added the logic to control the material sampling lod for neighbor baking.

* Added support of any Probe Volume rotation while baking dynamic GI neighbors and combining dynamic and baked SH.

* Respect the Baked Emission material toggle when baking the dynamic GI neighbors.

* Added a volume component setting to scale baked emission for dynamic GI.

* Provide ddx and ddy for position and UV of a hit when baking neighbor materials.

* Set the camera position shader property to zero before baking neighbors to support position-based effects in materials.

* Clean-up.

Work in progress for dgi optimization - setup new compute buffer

Work in progress.

Populate new neighbor axis lookups buffer and switch to reading from it.

Remove old neighbour axis lookup array.

Order members in NeighborAxisLookup by type size.

adding safety cleanup to help trigger the sorted axis set after cleanup call

Dynamic GI: Bind white texture for HVSSS in dynamic GI light loop

Author: szymonbonfire

com.unity.render-pipelines.high-definition/Editor/Lighting/ProbeVolume/ProbeVolumeUI.Drawer.cs

@@ -157,8 +157,10 @@ static void Drawer_PrimarySettings(SerializedProbeVolume serialized, Editor owne
             if (serialized.supportDynamicGI.boolValue)
             {
                 EditorGUILayout.PropertyField(serialized.drawNeighbors, Styles.s_DrawNeighborsLabel);
-                if (serialized.drawNeighbors.boolValue && serialized.advancedFade.boolValue)
+
+                if (serialized.drawNeighbors.boolValue)
                 {
+                    EditorGUILayout.PropertyField(serialized.drawEmission, Styles.s_DrawEmissionLabel);
                     EditorGUILayout.PropertyField(serialized.neighborsQuadScale, Styles.s_NeighborsQuadScaleLabel);
                 }
             }

com.unity.render-pipelines.high-definition/Editor/Lighting/ProbeVolume/ProbeVolumeUI.Skin.cs

@@ -28,6 +28,7 @@ internal static class Styles
             internal static readonly GUIContent s_DrawValidityLabel = new GUIContent("Draw Validity", "Visualize per-probe validity. Green is full validity, no backfaces visible. Red is no validity, max backfaces visible.");
             internal static readonly GUIContent s_HighlightRingingLabel = new GUIContent("Highlight Ringing", "Negative values on probes due to ringing will be highlighted and blinked in red.");
             internal static readonly GUIContent s_DrawNeighborsLabel = new GUIContent("Draw Neighbors", "Enable or disable drawing probe neighborhood to debug dynamic gi.");
+            internal static readonly GUIContent s_DrawEmissionLabel = new GUIContent("Draw Emission", "Show neighborhood emission instead of albedo.");
             internal static readonly GUIContent s_NeighborsQuadScaleLabel = new GUIContent("Draw Neighbors Scale", "The size of the debug quads when viewing draw neighbors mode");
             internal static readonly GUIContent s_DrawOctahedralDepthRays = new GUIContent("Draw Octahedral Depth Rays", "Enable or disable drawing rays to visualize to the octahedral depth data.");
             internal static readonly GUIContent s_DrawOctahedralDepthRayIndexX = new GUIContent("Octahedral Depth Rays Probe X", "Specifies the x index of the probe to visualize octahedral depth rays for.");

com.unity.render-pipelines.high-definition/Editor/Lighting/ProbeVolume/SerializedProbeVolume.cs

@@ -10,6 +10,7 @@ class SerializedProbeVolume
         internal SerializedProperty drawValidity;
         internal SerializedProperty highlightRinging;
         internal SerializedProperty drawNeighbors;
+        internal SerializedProperty drawEmission;
         internal SerializedProperty neighborsQuadScale;
         internal SerializedProperty drawOctahedralDepthRays;
         internal SerializedProperty drawOctahedralDepthRayIndexX;
@@ -61,6 +62,7 @@ internal SerializedProbeVolume(SerializedObject serializedObject)
             drawValidity = probeVolumeParams.FindPropertyRelative("drawValidity");
             highlightRinging = probeVolumeParams.FindPropertyRelative("highlightRinging");
             drawNeighbors = probeVolumeParams.FindPropertyRelative("drawNeighbors");
+            drawEmission = probeVolumeParams.FindPropertyRelative("drawEmission");
             neighborsQuadScale = probeVolumeParams.FindPropertyRelative("neighborsQuadScale");
 
             drawOctahedralDepthRays = probeVolumeParams.FindPropertyRelative("drawOctahedralDepthRays");

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeDynamicGI.cs

@@ -19,6 +19,8 @@ public class ProbeDynamicGI : VolumeComponent
     {
         [Tooltip("Indirect multiplier for all lights affect Dynamic GI")]
         public ClampedFloatParameter indirectMultiplier = new ClampedFloatParameter(1f, 0.0f, 2f);
+        [Tooltip("Multiplier for material emissive colors that affect Dynamic GI")]
+        public ClampedFloatParameter bakedEmissionMultiplier = new ClampedFloatParameter(0f, 0f, 2f);
         [Tooltip("A control for blending in more influence of infinite bounce light near surfaces")]
         public ClampedFloatParameter infiniteBounce = new ClampedFloatParameter(1f, 0.0f, 2f);
 

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagation.hlsl

@@ -5,9 +5,10 @@
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationGlobals.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbeVolumeDynamicGI.hlsl"
 
+int _ProbeVolumeProbeCount;
+
 RWStructuredBuffer<float3> _RadianceCacheAxis;
 StructuredBuffer<float3> _PreviousRadianceCacheAxis;
-int _RadianceCacheAxisCount;
 
 int _ProbeVolumeIndex;
 float _LeakMultiplier;
@@ -26,15 +27,8 @@ bool IsFarFromCamera(float3 worldPosition, float rangeInFrontOfCamera, float ran
 
 float3 ReadPreviousPropagationAxis(uint probeIndex, uint axisIndex)
 {
-    const uint index = probeIndex * NEIGHBOR_AXIS_COUNT + axisIndex;
-
-    // TODO: remove this if check with stricter checks on construction side in C#
-    if(index < (uint)_RadianceCacheAxisCount)
-    {
-        return _PreviousRadianceCacheAxis[index];
-    }
-
-    return 0;
+    const uint index = axisIndex * _ProbeVolumeProbeCount + probeIndex;
+    return _PreviousRadianceCacheAxis[index];
 }
 
 float3 NormalizeOutputRadiance(float4 lightingAndWeight, float probeValidity)
@@ -48,16 +42,10 @@ float3 NormalizeOutputRadiance(float4 lightingAndWeight, float probeValidity)
     return radiance;
 }
 
-void WritePropagationOutput(uint probeIndex, uint axisIndex, float4 lightingAndWeight, float probeValidity)
+void WritePropagationOutput(uint index, float4 lightingAndWeight, float probeValidity)
 {
-    const uint index = probeIndex * NEIGHBOR_AXIS_COUNT + axisIndex;
-
-    // TODO: remove this if check with stricter checks on construction side in C#
-    if(index < (uint)_RadianceCacheAxisCount)
-    {
-        const float3 finalRadiance = NormalizeOutputRadiance(lightingAndWeight, probeValidity);
-        _RadianceCacheAxis[index] = finalRadiance;
-    }
+    const float3 finalRadiance = NormalizeOutputRadiance(lightingAndWeight, probeValidity);
+    _RadianceCacheAxis[index] = finalRadiance;
 }
 
 

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationAxes.compute

@@ -1,3 +1,12 @@
+#pragma multi_compile _ SAMPLE_NEIGHBORS_DIRECTION_ONLY SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION
+#pragma multi_compile _ PROPAGATION_AXIS_MOST PROPAGATION_AXIS_LEAST
+#pragma multi_compile _ PREVIOUS_RADIANCE_CACHE_INVALID
+
+#pragma kernel PropagateLight
+#define GROUP_SIZE 64
+//#pragma enable_d3d11_debug_symbols
+
+
 #include "Packages/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs.hlsl"
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
 #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
@@ -14,14 +23,18 @@
 // #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
-//#pragma enable_d3d11_debug_symbols
+#if defined(PROPAGATION_AXIS_LEAST)
+    #define PROPAGATION_AXIS_AMOUNT 10
+#elif defined(PROPAGATION_AXIS_MOST)
+    #define PROPAGATION_AXIS_AMOUNT 17
+#else
+    #define PROPAGATION_AXIS_AMOUNT 26
+#endif
+
 
 float4 _RayAxis[NEIGHBOR_AXIS_COUNT];
-float4 _SortedNeighborAxis[NEIGHBOR_AXIS_COUNT * NEIGHBOR_AXIS_COUNT];
+StructuredBuffer<NeighborAxisLookup> _SortedNeighborAxisLookups;
 
 StructuredBuffer<NeighborAxis> _ProbeVolumeNeighbors;
 int _ProbeVolumeNeighborsCount;
@@ -212,8 +225,8 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
     const int index = id.x;
     if (index < _ProbeVolumeNeighborsCount)
     {
-        const uint probeIndex = (uint)index / NEIGHBOR_AXIS_COUNT;
-        const uint axisIndex = (uint)index - probeIndex * NEIGHBOR_AXIS_COUNT;
+        const uint axisIndex = (uint)index / _ProbeVolumeProbeCount;
+        const uint probeIndex = (uint)index - axisIndex * _ProbeVolumeProbeCount;
 
         float4 lightingAndWeight = float4(0, 0, 0, 1);
         uint3 probeCoordinate = ProbeIndexToProbeCoordinatesUint(probeIndex);
@@ -224,6 +237,12 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         // Early out at far distances
         if (IsFarFromCamera(probePositionWS, _RangeInFrontOfCamera, _RangeBehindCamera))
         {
+            #if defined(PREVIOUS_RADIANCE_CACHE_INVALID)
+            _RadianceCacheAxis[index] = 0;
+            #else
+            _RadianceCacheAxis[index] = _PreviousRadianceCacheAxis[index];
+            #endif
+
             return;
         }
 
@@ -243,22 +262,13 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         float probeValidity = 0;
         int neighborAxisIndexOffset = axisIndex * NEIGHBOR_AXIS_COUNT;
 
-        // use NEIGHBOR_AXIS_COUNT for all of them
-        // use 17 for only the very small values trimmed (very subtle)
-        // use 10 for some quality loss (noticeable)
-        const int relevantAxisLookups = 10;
-
-        for(int l=0; l < relevantAxisLookups; ++l)
+        for(int l=0; l < PROPAGATION_AXIS_AMOUNT; ++l)
         {
-            float4 neighborAxisLookup = _SortedNeighborAxis[neighborAxisIndexOffset + l];
-            int i = (int)neighborAxisLookup.y;
-            float sgWeight = neighborAxisLookup.x;
+            NeighborAxisLookup neighborAxisLookup = _SortedNeighborAxisLookups[neighborAxisIndexOffset + l];
+            int i = neighborAxisLookup.index;
+            float sgWeight = neighborAxisLookup.sgWeight;
 
-            float3 neighborDirection = _RayAxis[i].xyz;
-            float3 neighborWorldDirection = neighborDirection;
-            neighborWorldDirection = mul(neighborDirection, probeVolumeLtw);
-
-            uint sampleAxis = probeIndex * NEIGHBOR_AXIS_COUNT + i;
+            uint sampleAxis = i * _ProbeVolumeProbeCount + probeIndex;
             NeighborAxis neighbor = _ProbeVolumeNeighbors[sampleAxis];
 
             uint hitIndex = 0;
@@ -282,19 +292,29 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
                    neighborProbeCoordinate.y >= 0 && neighborProbeCoordinate.y < (int)_ProbeVolumeDGIResolutionY &&
                    neighborProbeCoordinate.z >= 0 && neighborProbeCoordinate.z < (int)_ProbeVolumeDGIResolutionZ)
                 {
-                    uint neighborProbeIndex = ProbeCoordinateToIndex(neighborProbeCoordinate);
-                    float3 prevAxisRadiance = ReadPreviousPropagationAxis(neighborProbeIndex, axisIndex);
-
-                    incomingNeighborRadiance = prevAxisRadiance;
+                    #if defined(PREVIOUS_RADIANCE_CACHE_INVALID)
+                        incomingNeighborRadiance = 0;
+                    #else
+                        uint neighborProbeIndex = ProbeCoordinateToIndex(neighborProbeCoordinate);
+                        float3 prevAxisRadiance = ReadPreviousPropagationAxis(neighborProbeIndex, axisIndex);
+
+                        incomingNeighborRadiance = prevAxisRadiance;
+                    #endif
                 }
 #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 = ComputeNeighborBoundaryEdgeWorldPosition(probePositionWS, i, probeVolumeLtw, neighborWorldDirection);
-                    SHIncomingIrradiance shIncomingIrradiance = ProbeVolumeEvaluateIncomingIrradiance(boundaryEdgePositionWS, _ProbeVolumeDGILightLayers);
-#endif
+                    float3 neighborDirection = neighborAxisLookup.neighborDirection;
+                    float3 neighborWorldDirection = neighborDirection;
+
+                    #if defined(SAMPLE_NEIGHBORS_POSITION_AND_DIRECTION)
+                        // sample neighbor probe volumes to gather radiance from neighbor volumes
+                        float3 boundaryEdgePositionWS = ComputeNeighborBoundaryEdgeWorldPosition(probePositionWS, i, probeVolumeLtw, neighborWorldDirection);
+                        SHIncomingIrradiance shIncomingIrradiance = ProbeVolumeEvaluateIncomingIrradiance(boundaryEdgePositionWS, _ProbeVolumeDGILightLayers);
+                    #else
+                        neighborWorldDirection = mul(neighborDirection, probeVolumeLtw);
+                    #endif
+
                     incomingNeighborRadiance = ProbeVolumeEvaluateIncomingRadiance(shIncomingIrradiance, neighborWorldDirection) * INV_PI;
                 }
 #endif
@@ -305,9 +325,9 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         }
 
         incomingRadiance *= rcp(max(weight, 0.00001));
-        probeValidity *= 1.0 / relevantAxisLookups;
+        probeValidity *= 1.0 / PROPAGATION_AXIS_AMOUNT;
 
         lightingAndWeight.rgb += incomingRadiance * _PropagationContribution;
-        WritePropagationOutput(probeIndex, axisIndex, lightingAndWeight, probeValidity);
+        WritePropagationOutput(index, lightingAndWeight, probeValidity);
     }
 }

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationClearRadianceCache.compute

@@ -0,0 +1,25 @@
+#pragma kernel ClearPreviousRadianceCache
+#define GROUP_SIZE 64
+//#pragma enable_d3d11_debug_symbols
+
+
+RWStructuredBuffer<float3> _RadianceCacheAxis0;
+RWStructuredBuffer<float3> _RadianceCacheAxis1;
+RWStructuredBuffer<float3> _HitRadianceCacheAxis;
+int _RadianceCacheAxisCount;
+int _HitRadianceCacheAxisCount;
+
+[numthreads(GROUP_SIZE, 1, 1)]
+void ClearPreviousRadianceCache(uint3 id : SV_DispatchThreadID)
+{
+    const int axisIndex = id.x;
+    if (axisIndex < _RadianceCacheAxisCount)
+    {
+        _RadianceCacheAxis0[axisIndex] = 0;
+        _RadianceCacheAxis1[axisIndex] = 0;
+    }
+    if (axisIndex < _HitRadianceCacheAxisCount)
+    {
+        _HitRadianceCacheAxis[axisIndex] = 0;
+    }
+}

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationClearRadianceCache.compute.meta

@@ -27,6 +27,9 @@ float4 _ProbeVolumeAtlasResolutionAndSliceCount;
 float3 _ProbeVolumeAtlasSHRotateRight;
 float3 _ProbeVolumeAtlasSHRotateUp;
 float3 _ProbeVolumeAtlasSHRotateForward;
+float3 _ProbeVolumeAtlasDynamicSHRotateRight;
+float3 _ProbeVolumeAtlasDynamicSHRotateUp;
+float3 _ProbeVolumeAtlasDynamicSHRotateForward;
 
 StructuredBuffer<float3> _RadianceCacheAxis;
 int _RadianceCacheAxisCount;
@@ -127,14 +130,17 @@ SHIncomingIrradiance ProjectPropagationAxisFromPeak(uint probeIndex)
     SHIncomingIrradiance incomingIrradiance;
     ZERO_INITIALIZE(SHIncomingIrradiance, incomingIrradiance);
 
-    uint localIndex = probeIndex * NEIGHBOR_AXIS_COUNT;
+    uint localIndex = probeIndex;
     for (int axis = 0; axis < NEIGHBOR_AXIS_COUNT; ++axis)
     {
         float3 radiance = _RadianceCacheAxis[localIndex].xyz;
         float3 direction = _RayAxis[axis].xyz;
+        const float3x3 probeVolumeAtlasDynamicSHRotate = float3x3(_ProbeVolumeAtlasDynamicSHRotateRight, _ProbeVolumeAtlasDynamicSHRotateUp, _ProbeVolumeAtlasDynamicSHRotateForward);
+        direction = mul(direction, probeVolumeAtlasDynamicSHRotate);
+        
         SHIncomingIrradianceAccumulate(incomingIrradiance, direction, radiance);
         //FCCAddToOutputRepresentation(radiance, direction, incomingIrradiance);
-        localIndex++;
+        localIndex += _ProbeVolumeAtlasReadBufferCount;
     }
 
     return incomingIrradiance;
@@ -213,17 +219,19 @@ SHIncomingIrradiance ProjectPropagationAxisFromFit(uint probeIndex)
     SHIncomingIrradiance incomingIrradiance;
     ZERO_INITIALIZE(SHIncomingIrradiance, incomingIrradiance);
 
-    uint localIndex = probeIndex * NEIGHBOR_AXIS_COUNT;
+    uint localIndex = probeIndex;
     for (int axis = 0; axis < NEIGHBOR_AXIS_COUNT; ++axis)
     {
         float3 radiance = _RadianceCacheAxis[localIndex].xyz;
         float3 direction = _RayAxis[axis].xyz;
+        const float3x3 probeVolumeAtlasDynamicSHRotate = float3x3(_ProbeVolumeAtlasDynamicSHRotateRight, _ProbeVolumeAtlasDynamicSHRotateUp, _ProbeVolumeAtlasDynamicSHRotateForward);
+        direction = mul(direction, probeVolumeAtlasDynamicSHRotate);
 
         SHIncomingIrradiance incomingIrradianceCurrentSG = SHIncomingIrradianceComputeFromSphericalGaussian(direction, _PropagationSharpness, radiance);
 
         SHIncomingIrradianceAccumulateFromSHIncomingIrradiance(incomingIrradiance, incomingIrradianceCurrentSG);
 
-        localIndex++;
+        localIndex += _ProbeVolumeAtlasReadBufferCount;
     }
 
     return incomingIrradiance;

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationCombine.compute

@@ -1,21 +1,25 @@
+#pragma multi_compile _ COMPUTE_INFINITE_BOUNCE
+#pragma multi_compile _ PREVIOUS_RADIANCE_CACHE_INVALID
+
+#pragma kernel AccumulateLightingDirectional
+#define GROUP_SIZE 64
+//#pragma enable_d3d11_debug_symbols
+
+
 #define SHADOW_MINIMAL
 #define LIGHT_EVALUATION_NO_HEIGHT_FOG
-
 #define DEBUGGING 0
 #define SUPPORTS_AREA_LIGHTS 1
 
+
 #include "Packages/com.unity.render-pipelines.high-definition-config/Runtime/ShaderConfig.cs.hlsl"
 #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
 #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/ProbePropagationLighting.hlsl"
 
-#pragma kernel AccumulateLightingDirectional
-#define GROUP_SIZE 64
-//#pragma enable_d3d11_debug_symbols
 
-#pragma multi_compile _ COMPUTE_INFINITE_BOUNCE
 
 RWStructuredBuffer<float3> _HitRadianceCacheAxis;
 int _HitRadianceCacheAxisCount;
@@ -27,6 +31,7 @@ float4 _RayAxis[NEIGHBOR_AXIS_COUNT];
 
 float _DirectContribution;
 float _IndirectScale;
+float _BakedEmissionMultiplier;
 float _RayBias;
 float _InfiniteBounce;
 float _InfiniteBounceSharpness;
@@ -106,14 +111,18 @@ void GatherLighting(SurfaceHitData hit, inout float4 lighting)
 
 float3 EstimateIncomingBounceLightSG(uint probeIndex, PackedNeighborHit neighborData)
 {
-    float3 normal = UnpackNormal(neighborData.normalAxis);
-    float4 albedoDistance = UnpackAlbedoAndDistance(neighborData.albedoDistance, _ProbeVolumeDGIMaxNeighborDistance);
-
-    float3 incomingIrradiance = EvaluateBRDFLambertApproximate(probeIndex, normal, _InfiniteBounceSharpness, _RayAxis);
-    incomingIrradiance *= _InfiniteBounce * INV_PI;
-    incomingIrradiance *= albedoDistance.rgb;
-
-    return incomingIrradiance;
+    #if defined(PREVIOUS_RADIANCE_CACHE_INVALID)
+        return 0;
+    #else
+        float3 normal = UnpackNormal(neighborData.normalAxis);
+        float4 albedoDistance = UnpackAlbedoAndDistance(neighborData.albedoDistance, _ProbeVolumeDGIMaxNeighborDistance);
+
+        float3 incomingIrradiance = EvaluateBRDFLambertApproximate(probeIndex, normal, _InfiniteBounceSharpness, _RayAxis);
+        incomingIrradiance *= _InfiniteBounce * INV_PI;
+        incomingIrradiance *= albedoDistance.rgb;
+
+        return incomingIrradiance;
+    #endif
 }
 
 float3 ProbeIndexToProbeCoordinates(uint probeIndex)
@@ -189,6 +198,7 @@ void AccumulateLightingDirectional(uint3 id : SV_DispatchThreadID)
         GatherLighting(hit, lightingAndWeight);
 
         const float3 finalRadiance = NormalizeOutputRadiance(lightingAndWeight, probeValidity);
-        _HitRadianceCacheAxis[hitAxisIndex] = finalRadiance;
+        const float3 emission = UnpackEmission(neighborData.emission) * _BakedEmissionMultiplier;
+        _HitRadianceCacheAxis[hitAxisIndex] = finalRadiance + emission;
     }
 }