Fix double dark ao and ao in lightloop (#12)

Fix double dark AO + material AO availability in light loop for probe volumes. Probe Volumes: Pack AO and isUninitializedGI flag into .x channel of light layers GBuffer RT to fix double dark AO and to allow emissive surfaces to receive probe volume lighting. Also perform small restructuring to a probe volume bilateral filter function to remove a shader warning

Author: pastasfuture

com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl

@@ -394,8 +394,7 @@ void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BS
         float reflectionProbeNormalizationWeight = 0.0f;
 
 #if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
-    bool uninitialized = IsUninitializedGI(builtinData.bakeDiffuseLighting);
-    builtinData.bakeDiffuseLighting = uninitialized ? float3(0.0, 0.0, 0.0) : builtinData.bakeDiffuseLighting;
+    bool uninitialized = TryClearUninitializedGI(builtinData);
 
     // If probe volume feature is enabled, this bit is enabled for all tiles to handle ambient probe fallback.
     // No need to branch internally on _EnableProbeVolumes uniform.
@@ -444,15 +443,6 @@ void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BS
 
 #endif
 
-#if (SHADERPASS == SHADERPASS_DEFERRED_LIGHTING)
-            // If we are deferred we should apply baked AO here as it was already apply for lightmap.
-            // But in deferred ambientOcclusion is white so we should use specularOcclusion instead. It is the
-            // same case than for Microshadow so we can reuse this function. It should not be apply in forward
-            // as in this case the baked AO is correctly apply in PostBSDF()
-            // This is apply only on bakeDiffuseLighting as ModifyBakedDiffuseLighting combine both bakeDiffuseLighting and backBakeDiffuseLighting
-            builtinDataProbeVolumes.bakeDiffuseLighting *= GetAmbientOcclusionForMicroShadowing(bsdfData);
-#endif
-
             ApplyDebugToBuiltinData(builtinDataProbeVolumes);
 
             // Note: builtinDataProbeVolumes.bakeDiffuseLighting and builtinDataProbeVolumes.backBakeDiffuseLighting were combine inside of ModifyBakedDiffuseLighting().

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

@@ -71,16 +71,19 @@
 
 #if PROBE_VOLUMES_BILATERAL_FILTERING_MODE != PROBEVOLUMESBILATERALFILTERINGMODES_DISABLED
 #if SHADEROPTIONS_PROBE_VOLUMES_BILATERAL_FILTERING_SAMPLE_MODE == PROBEVOLUMESBILATERALFILTERINGSAMPLEMODES_APPROXIMATE_SAMPLE
-        probeVolumeTexel3D = ProbeVolumeComputeTexel3DFromBilateralFilter(
-            probeVolumeTexel3D,
-            probeVolumeData,
-            posInput.positionWS, // unbiased
-            samplePositionWS, // biased
-            normalWS,
-            obbFrame,
-            obbExtents,
-            obbCenter
-        );
+        if (_ProbeVolumeLeakMitigationMode != LEAKMITIGATIONMODE_NORMAL_BIAS)
+        {
+            probeVolumeTexel3D = ProbeVolumeComputeTexel3DFromBilateralFilter(
+                probeVolumeTexel3D,
+                probeVolumeData,
+                posInput.positionWS, // unbiased
+                samplePositionWS, // biased
+                normalWS,
+                obbFrame,
+                obbExtents,
+                obbCenter
+            );
+        }
 #else // SHADEROPTIONS_PROBE_VOLUMES_BILATERAL_FILTERING_SAMPLE_MODE == PROBEVOLUMESBILATERALFILTERINGSAMPLEMODES_PRECISE_LOAD
         float weights[8];
         ProbeVolumeComputeWeightsFromBilateralFilter(

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

@@ -360,8 +360,6 @@ float3 ProbeVolumeComputeTexel3DFromBilateralFilter(
     float3 obbExtents,
     float3 obbCenter)
 {
-    if (_ProbeVolumeLeakMitigationMode == LEAKMITIGATIONMODE_NORMAL_BIAS) { return probeVolumeTexel3D; }
-
     float3 probeVolumeTexel3DMin = floor(probeVolumeTexel3D - 0.5) + 0.5;
 
     float weights[8]; for (uint i = 0; i < 8; ++i) { weights[i] = 1.0; }
@@ -420,11 +418,6 @@ float3 ProbeVolumeComputeTexel3DFromBilateralFilter(
         );
     }
 #endif
-    else
-    {
-        // Fallback to no bilateral filter if _ProbeVolumeLeakMitigationMode is configured to a mode unsupported in ShaderConfig.
-        return probeVolumeTexel3D;
-    }
 
     ProbeVolumeEvaluateAndAccumulateTrilinearWeights(weights, probeVolumeTexel3D, probeVolumeTexel3DMin);
 

com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinGIUtilities.hlsl

@@ -15,10 +15,16 @@
 
 #define UNINITIALIZED_GI float3((1 << 11), 1, (1 << 10))
 
-bool IsUninitializedGI(float3 bakedGI)
+bool IsUninitializedGI(BuiltinData builtinData)
 {
-    const float3 unitializedGI = UNINITIALIZED_GI;
-    return all(bakedGI == unitializedGI);
+    return all(builtinData.bakeDiffuseLighting == UNINITIALIZED_GI);
+}
+
+bool TryClearUninitializedGI(inout BuiltinData builtinData)
+{
+    bool isUninitializedGI = IsUninitializedGI(builtinData);
+    builtinData.bakeDiffuseLighting = isUninitializedGI ? float3(0.0, 0.0, 0.0) : builtinData.bakeDiffuseLighting;
+    return isUninitializedGI;
 }
 #endif
 

com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl

@@ -104,8 +104,10 @@ void PostInitBuiltinData(   float3 V, PositionInputs posInput, SurfaceData surfa
                             inout BuiltinData builtinData)
 {
 #if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
-    if (IsUninitializedGI(builtinData.bakeDiffuseLighting))
+    if (IsUninitializedGI(builtinData))
+    {
         return;
+    }
 #else
     // Apply control from the indirect lighting volume settings - This is apply here so we don't affect emissive
     // color in case of lit deferred for example and avoid material to have to deal with it

com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.cs

@@ -120,7 +120,7 @@ public struct BSDFData
             public Vector3 fresnel0;
 
             [SurfaceDataAttributes(precision = FieldPrecision.Real)]
-            public float ambientOcclusion; // Caution: This is accessible only if light layer is enabled, otherwise it is 1
+            public float ambientOcclusion;
             [SurfaceDataAttributes(precision = FieldPrecision.Real)]
             public float specularOcclusion;
 
@@ -196,7 +196,9 @@ protected void GetGBufferOptions(HDRenderPipelineAsset asset, out int gBufferCou
             // Caution: This must be in sync with GBUFFERMATERIAL_COUNT definition in
             supportShadowMask = asset.currentPlatformRenderPipelineSettings.supportShadowMask;
             supportLightLayers = asset.currentPlatformRenderPipelineSettings.supportLightLayers;
-            gBufferCount = 4 + (supportShadowMask ? 1 : 0) + (supportLightLayers ? 1 : 0);
+            gBufferCount = GetMaterialGBufferCountRequired()
+                + (supportShadowMask ? 1 : 0)
+                + ((supportLightLayers || (ShaderConfig.s_ProbeVolumesEvaluationMode == ProbeVolumesEvaluationModes.LightLoop)) ? 1 : 0);
 #if ENABLE_VIRTUALTEXTURES
             gBufferCount++;
 #endif
@@ -238,17 +240,24 @@ public override void GetMaterialGBufferDescription(HDRenderPipelineAsset asset,
             enableWrite[3] = true;
 
             #if ENABLE_VIRTUALTEXTURES
-                int index = 4;
+                int index = GetMaterialGBufferCountRequired();
                 RTFormat[index] = VTBufferManager.GetFeedbackBufferFormat();
                 gBufferUsage[index] = GBufferUsage.VTFeedback;
                 enableWrite[index] = false;
                 index++;
             #else
-                int index = 4;
+                int index = GetMaterialGBufferCountRequired();
             #endif
 
-            if (supportLightLayers)
+            if (supportLightLayers || (ShaderConfig.s_ProbeVolumesEvaluationMode == ProbeVolumesEvaluationModes.LightLoop))
             {
+                // Probe Volume Light Loop evaluation mode requires AO and an unitializedGI flag to be stored in the GBuffer.
+                // Use the previously unused R channel of the light layer RT to store this data.
+                // This means that we allocate this light layer RT if light layers is enabled OR Probe Volume Light Loop evaluation is enabled.
+                // This seems reasonable, as light layers are particularly important for controlling the look of surfaces in a fully deferred context.
+                // Probe Volumes are designed for this fully deferred context.
+                // My theory is it will be uncommon for a user to have light layers disabled, but probe volumes enabled.
+                // Typically, they will want both. 
                 RTFormat[index] = GraphicsFormat.R8G8B8A8_UNorm;
                 gBufferUsage[index] = GBufferUsage.LightLayers;
                 index++;
@@ -264,6 +273,11 @@ public override void GetMaterialGBufferDescription(HDRenderPipelineAsset asset,
             }
         }
 
+        private int GetMaterialGBufferCountRequired()
+        {
+            return 4;
+        }
+
 
         //-----------------------------------------------------------------------------
         // Init precomputed texture

com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl

@@ -41,7 +41,6 @@ TEXTURE2D_X(_GBufferTexture4); // VTFeedbakc or Light layer or shadow mask
 TEXTURE2D_X(_GBufferTexture5); // Light layer or shadow mask
 TEXTURE2D_X(_GBufferTexture6); // shadow mask
 
-
 TEXTURE2D_X(_LightLayersTexture);
 #ifdef SHADOWS_SHADOWMASK
 TEXTURE2D_X(_ShadowMaskTexture); // Alias for shadow mask, so we don't need to know which gbuffer is used for shadow mask
@@ -63,11 +62,11 @@ TEXTURE2D_X(_ShadowMaskTexture); // Alias for shadow mask, so we don't need to k
 #define OUT_GBUFFER_OPTIONAL_SLOT_2 outGBuffer5
 #endif
 
-#if defined(LIGHT_LAYERS) && defined(SHADOWS_SHADOWMASK)
-#define OUT_GBUFFER_LIGHT_LAYERS OUT_GBUFFER_OPTIONAL_SLOT_1
+#if (defined(LIGHT_LAYERS) || (SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP)) && defined(SHADOWS_SHADOWMASK)
+#define OUT_GBUFFER_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI OUT_GBUFFER_OPTIONAL_SLOT_1
 #define OUT_GBUFFER_SHADOWMASK OUT_GBUFFER_OPTIONAL_SLOT_2
-#elif defined(LIGHT_LAYERS)
-#define OUT_GBUFFER_LIGHT_LAYERS OUT_GBUFFER_OPTIONAL_SLOT_1
+#elif (defined(LIGHT_LAYERS) || (SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP))
+#define OUT_GBUFFER_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI OUT_GBUFFER_OPTIONAL_SLOT_1
 #elif defined(SHADOWS_SHADOWMASK)
 #define OUT_GBUFFER_SHADOWMASK OUT_GBUFFER_OPTIONAL_SLOT_1
 #endif
@@ -194,7 +193,7 @@ float3 GetNormalForShadowBias(BSDFData bsdfData)
 float GetAmbientOcclusionForMicroShadowing(BSDFData bsdfData)
 {
     float sourceAO;
-#if (SHADERPASS == SHADERPASS_DEFERRED_LIGHTING)
+#if (SHADERPASS == SHADERPASS_DEFERRED_LIGHTING) && !defined(OUT_GBUFFER_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI)
     // Note: In deferred pass we don't have space in GBuffer to store ambientOcclusion so we use specularOcclusion instead
     sourceAO = bsdfData.specularOcclusion;
 #else
@@ -462,6 +461,28 @@ BSDFData ConvertSurfaceDataToBSDFData(uint2 positionSS, SurfaceData surfaceData)
     return bsdfData;
 }
 
+// Store a 7-bit unorm payload, with a 1-bit isUninitializedGI flag.
+float EncodeIsUninitializedGIAndAO(bool isUninitializedGI, float ao)
+{
+    // TODO: Could add dither while discretizing to 7-bit to break up any potential banding.
+    float encoded = floor(saturate(ao) * 127.0 + 0.5);
+    encoded += isUninitializedGI ? 128.0 : 0.0;
+    encoded *= (1.0 / 255.0);
+
+    return encoded;
+}
+
+bool DecodeIsUninitializedGIAndAO(float encoded, out float ao)
+{
+    ao = encoded * 255.0;
+    bool isUninitializedGI = ao > 127.5;
+    ao -= isUninitializedGI ? 128.0 : 0.0;
+    ao *= (1.0 / 127.0);
+    ao = saturate(ao); // For precision.
+
+    return isUninitializedGI;
+}
+
 //-----------------------------------------------------------------------------
 // conversion function for deferred
 //-----------------------------------------------------------------------------
@@ -666,7 +687,7 @@ void EncodeIntoGBuffer( SurfaceData surfaceData
         if (_DebugLightingMode == DEBUGLIGHTINGMODE_EMISSIVE_LIGHTING)
         {
     #if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
-            if (!IsUninitializedGI(builtinData.bakeDiffuseLighting))
+            if (!IsUninitializedGI(builtinData))
     #endif
             {
                 builtinData.bakeDiffuseLighting = real3(0.0, 0.0, 0.0);
@@ -679,33 +700,34 @@ void EncodeIntoGBuffer( SurfaceData surfaceData
     }
 #endif
 
-    // RT3 - 11f:11f:10f
-    // In deferred we encode emissive color with bakeDiffuseLighting. We don't have the room to store emissiveColor.
-    // It mean that any futher process that affect bakeDiffuseLighting will also affect emissiveColor, like SSAO for example.
-#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
+    outGBuffer3 = float4(builtinData.emissiveColor * GetCurrentExposureMultiplier(), 0.0);
 
-    if (IsUninitializedGI(builtinData.bakeDiffuseLighting))
-    {
-        // builtinData.bakeDiffuseLighting contain uninitializedGI sentinel value.
-
-        // This means probe volumes will not get applied to this pixel, only emissiveColor will.
-        // When length(emissiveColor) is much greater than length(probeVolumeOutgoingRadiance), this will visually look reasonable.
-        // Unfortunately this will break down when emissiveColor is faded out (result will pop).
-        // TODO: If evaluating probe volumes in lightloop, only write out sentinel value here, and re-render emissive surfaces.
-        // Pre-expose lighting buffer
-        outGBuffer3 = float4(all(builtinData.emissiveColor == 0.0) ? builtinData.bakeDiffuseLighting : builtinData.emissiveColor * GetCurrentExposureMultiplier(), 0.0);
-    }
-    else
+#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
+    bool isUninitializedGI = IsUninitializedGI(builtinData);
+#else
+    bool isUninitializedGI = false;
 #endif
+    if (!isUninitializedGI)
     {
-        outGBuffer3 = float4(builtinData.bakeDiffuseLighting * surfaceData.ambientOcclusion + builtinData.emissiveColor, 0.0);
-        // Pre-expose lighting buffer
-        outGBuffer3.rgb *= GetCurrentExposureMultiplier();
+        // RT3 - 11f:11f:10f
+        // In deferred we encode emissive color with bakeDiffuseLighting. We don't have the room to store emissiveColor.
+        // It mean that any futher process that affect bakeDiffuseLighting will also affect emissiveColor, like SSAO for example.
+        outGBuffer3.rgb += builtinData.bakeDiffuseLighting * (surfaceData.ambientOcclusion * GetCurrentExposureMultiplier());
     }
 
-#ifdef LIGHT_LAYERS
+#if defined(LIGHT_LAYERS) || (SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP)
+    float4 lightLayersAndAOAndUnitializedGI = 0.0;
+
+#if defined(LIGHT_LAYERS)
     // Note: we need to mask out only 8bits of the layer mask before encoding it as otherwise any value > 255 will map to all layers active
-    OUT_GBUFFER_LIGHT_LAYERS = float4(0.0, 0.0, 0.0, (builtinData.renderingLayers & 0x000000FF) / 255.0);
+    lightLayersAndAOAndUnitializedGI.w = (builtinData.renderingLayers & 0x000000FF) / 255.0;
+#endif
+
+#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
+    lightLayersAndAOAndUnitializedGI.x = EncodeIsUninitializedGIAndAO(isUninitializedGI, surfaceData.ambientOcclusion);
+#endif
+
+    OUT_GBUFFER_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI = lightLayersAndAOAndUnitializedGI;
 #endif
 
 #ifdef SHADOWS_SHADOWMASK
@@ -739,31 +761,44 @@ uint DecodeFromGBuffer(uint2 positionSS, uint tileFeatureFlags, out BSDFData bsd
     GBufferType1 inGBuffer1 = LOAD_TEXTURE2D_X(_GBufferTexture1, positionSS);
     GBufferType2 inGBuffer2 = LOAD_TEXTURE2D_X(_GBufferTexture2, positionSS);
 
-    // BuiltinData
-    builtinData.bakeDiffuseLighting = LOAD_TEXTURE2D_X(_GBufferTexture3, positionSS).rgb;  // This also contain emissive (and * AO if no lightlayers)
-
-#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
-    if (!IsUninitializedGI(builtinData.bakeDiffuseLighting))
-#endif
-    {
-        // Inverse pre-exposure
-        builtinData.bakeDiffuseLighting *= GetInverseCurrentExposureMultiplier(); // zero-div guard
-    }
-
     // In deferred ambient occlusion isn't available and is already apply on bakeDiffuseLighting for the GI part.
     // Caution: even if we store it in the GBuffer we need to apply it on GI and not on emissive color, so AO must be 1.0 in deferred
     bsdfData.ambientOcclusion = 1.0;
 
+    // BuiltinData
+    builtinData.bakeDiffuseLighting = LOAD_TEXTURE2D_X(_GBufferTexture3, positionSS).rgb;
+
+    float4 inGBufferLightLayersAndAOAndUnitializedGI = 0.0;
+
+#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE != PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
     // Avoid to introduce a new variant for light layer as it is already long to compile
     if (_EnableLightLayers)
+#else
     {
-        float4 inGBuffer4 = LOAD_TEXTURE2D_X(_LightLayersTexture, positionSS);
-        builtinData.renderingLayers = uint(inGBuffer4.w * 255.5);
+        inGBufferLightLayersAndAOAndUnitializedGI = LOAD_TEXTURE2D_X(_LightLayersTexture, positionSS);
     }
+#endif
+
+#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
+    if (DecodeIsUninitializedGIAndAO(inGBufferLightLayersAndAOAndUnitializedGI.x, bsdfData.ambientOcclusion))
+    {
+        // In this context the bakeDiffuseLighting RT stores only emissiveColor.
+        // Inverse pre-exposure
+        builtinData.emissiveColor = builtinData.bakeDiffuseLighting * GetInverseCurrentExposureMultiplier(); // zero-div guard
+        builtinData.bakeDiffuseLighting = UNINITIALIZED_GI;
+    } 
     else
     {
-        builtinData.renderingLayers = DEFAULT_LIGHT_LAYERS;
+#else
+        // In this context, the bakeDiffuseLighting RT stores emissive + lightmapBakedLighting * ao.
+        // Inverse pre-exposure
+        builtinData.bakeDiffuseLighting *= GetInverseCurrentExposureMultiplier(); // zero-div guard
+#endif
+#if SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP
     }
+#endif
+
+    builtinData.renderingLayers = _EnableLightLayers ? uint(inGBufferLightLayersAndAOAndUnitializedGI.w * 255.5) : DEFAULT_LIGHT_LAYERS;
 
     // We know the GBufferType no need to use abstraction
 #ifdef SHADOWS_SHADOWMASK

com.unity.render-pipelines.high-definition/Runtime/Material/MaterialEvaluation.hlsl

@@ -118,6 +118,9 @@ void ApplyAmbientOcclusionFactor(AmbientOcclusionFactor aoFactor, inout BuiltinD
     // This is a tradeoff to avoid storing the precomputed (from data) AO in the GBuffer.
     // (This is also why GetScreenSpaceAmbientOcclusion*() is effectively called with AOFromData = 1.0 in Lit:PostEvaluateBSDF() in the
     // deferred case since DecodeFromGBuffer will init bsdfData.ambientOcclusion to 1.0 and we will only have SSAO in the aoFactor here)
+    //
+    // In the context of Probe Volumes, the above constraints are not true. Ambient Occlusion is packed in the unused bakeDiffuseLighting
+    // buffer, so material ambient occlusion is available in the light loop, and is correctly applied without double darkening.
     builtinData.bakeDiffuseLighting *= aoFactor.indirectAmbientOcclusion;
     lighting.indirect.specularReflected *= aoFactor.indirectSpecularOcclusion;
     lighting.direct.diffuse *= aoFactor.directAmbientOcclusion;

com.unity.render-pipelines.high-definition/Runtime/Material/MaterialGBufferMacros.hlsl

@@ -12,11 +12,12 @@
 #define GBufferType4 float4
 #define GBufferType5 float4
 #define GBufferType6 float4
+#define GBufferType7 float4
 
-#ifdef LIGHT_LAYERS
-#define GBUFFERMATERIAL_LIGHT_LAYERS 1
+#if defined(LIGHT_LAYERS) || (SHADEROPTIONS_PROBE_VOLUMES_EVALUATION_MODE == PROBEVOLUMESEVALUATIONMODES_LIGHT_LOOP) 
+#define GBUFFERMATERIAL_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI 1
 #else
-#define GBUFFERMATERIAL_LIGHT_LAYERS 0
+#define GBUFFERMATERIAL_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI 0
 #endif
 
 #ifdef SHADOWS_SHADOWMASK
@@ -41,7 +42,7 @@
 #endif
 
 // Caution: This must be in sync with Lit.cs GetMaterialGBufferCount()
-#define GBUFFERMATERIAL_COUNT (4 + GBUFFERMATERIAL_VTFEEDBACK + GBUFFERMATERIAL_LIGHT_LAYERS + GBUFFERMATERIAL_SHADOWMASK)
+#define GBUFFERMATERIAL_COUNT (4 + GBUFFERMATERIAL_VTFEEDBACK + GBUFFERMATERIAL_LIGHT_LAYERS_AND_AO_AND_UNITIALIZED_GI + GBUFFERMATERIAL_SHADOWMASK)
 
 // Only one deferred layout is allowed for a HDRenderPipeline, this will be detect by the redefinition of GBUFFERMATERIAL_COUNT
 // If GBUFFERMATERIAL_COUNT is define two time, the shaders will not compile