Merge pull request #1784 from Unity-Technologies/Improve-bakeDiffuseLighting-code

Refactor GetBakedDiffuseLighting

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/1x_Materials/1401_StackLit/TestStackMat_Dielectric_SSS.mat

   serializedVersion: 6
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_Name: TestStackMat_Dielectric_SSS
   m_Shader: {fileID: 4800000, guid: 3a796817b9614b347895c0e8db89b63a, type: 3}
   m_ShaderKeywords: _MATERIAL_FEATURE_SUBSURFACE_SCATTERING _MATERIAL_FEATURE_TRANSMISSION
     serializedVersion: 3
     m_TexEnvs:
     - _AmbientOcclusionMap:
-        m_Texture: {fileID: 2800000, guid: 73993dd804df9ad47abfdee49346e56b, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
+        m_Texture: {fileID: 2800000, guid: be4b71c50f9aa414ea41fcfb7a1ea330, type: 3}
+        m_Scale: {x: 2, y: 2}
+        m_Offset: {x: -0.05, y: 0.5}
     - _AnisotropyMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _Drag: 1
     - _DstBlend: 0
     - _DualSpecularLobeShow: 0
-    - _EmissiveColorMapShow: 0
+    - _EmissiveColorMapShow: 1
-    - _EmissiveShow: 0
+    - _EmissiveShow: 1
     - _EnableAnisotropy: 0
     - _EnableBlendModePreserveSpecularLighting: 1
     - _EnableCoat: 0
     - _ZWrite: 1
     m_Colors:
     - _AmbientOcclusionMapChannelMask: {r: 1, g: 0, b: 0, a: 0}
-    - _AmbientOcclusionMapRange: {r: 0, g: 1, b: 0, a: 0}
-    - _AmbientOcclusionMapRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _AmbientOcclusionMapRange: {r: 0, g: 0.9999999, b: 0, a: 0}
+    - _AmbientOcclusionMapRemap: {r: 0, g: 0.9999999, b: 0, a: 0}
     - _AnisotropyMapChannelMask: {r: 1, g: 0, b: 0, a: 0}
     - _AnisotropyMapRange: {r: 0, g: 1, b: 0, a: 0}
     - _AnisotropyMapRemap: {r: 0, g: 1, b: 0, a: 0}

com.unity.render-pipelines.high-definition/CHANGELOG.md

 - Added desired lux intensity and auto multiplier for HDRI sky
 - Added an option to disable light by type in the debug menu
 - Added gradient sky
+- Split EmissiveColor and bakeDiffuseLighting in forward avoiding the emissiveColor to be affect by SSAO
 
 ### Fixed
 - Fixed an issue with PreIntegratedFGD texture being sometimes destroyed and not regenerated causing rendering to break

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

         $SurfaceDescription.Normal:       normalTS =                   surfaceDescription.Normal;
 
         // compute world space normal
-        GetNormalWS(fragInputs, V, normalTS, surfaceData.normalWS);
+        GetNormalWS(fragInputs, normalTS, surfaceData.normalWS);
 
         // TODO: use surfaceDescription tangent definition for anisotropy
         surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz);    // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
 
         BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData);
 
-        // Builtin Data -- we don't call GetBuiltinData(fragInputs, surfaceData, ...)
-        // that function assumes there are specific global properties defined
-        // for shadergraph shaders, we fill it out here instead
-        ZERO_INITIALIZE(BuiltinData, builtinData);
-        float3 bentNormalWS =                   surfaceData.normalWS;           // TODO : make bent normals work
-
-        builtinData.opacity =                   surfaceDescription.Alpha;
-        builtinData.bakeDiffuseLighting =       SampleBakedGI(fragInputs.positionRWS, bentNormalWS, fragInputs.texCoord1, fragInputs.texCoord2);    // see GetBuiltinData()
-
-        // It is safe to call this function here as surfaceData have been filled
-        // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
-        BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS.xy, surfaceData);
-        if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
-        {
-            // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
-            // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
-            // TODO: optimize more this code.
-            // Add GI transmission contribution by resampling the GI for inverted vertex normal
-            builtinData.bakeDiffuseLighting += SampleBakedGI(fragInputs.positionRWS, -fragInputs.worldToTangent[2], fragInputs.texCoord1, fragInputs.texCoord2) * bsdfData.transmittance;
-        }
+        // Builtin Data
+        // For back lighting we use the oposite vertex normal 
+        InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData);
-        builtinData.velocity =                  float2(0.0, 0.0);
-#ifdef SHADOWS_SHADOWMASK
-        float4 shadowMask = SampleShadowMask(fragInputs.positionRWS, fragInputs.texCoord1);
-        builtinData.shadowMask0 = shadowMask.x;
-        builtinData.shadowMask1 = shadowMask.y;
-        builtinData.shadowMask2 = shadowMask.z;
-        builtinData.shadowMask3 = shadowMask.w;
-#else
-        builtinData.shadowMask0 = 0.0;
-        builtinData.shadowMask1 = 0.0;
-        builtinData.shadowMask2 = 0.0;
-        builtinData.shadowMask3 = 0.0;
-#endif
+
-        // Use uniform directly - The float need to be cast to uint (as unity don't support to set a uint as uniform)
-        builtinData.renderingLayers =           _EnableLightLayers ? asuint(unity_RenderingLayer.x) : DEFAULT_LIGHT_LAYERS;
+
+
+        PostInitBuiltinData(V, posInput, surfaceData, builtinData);
     }
 
     //-------------------------------------------------------------------------------------

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

 
         BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData);
 
-        // Builtin Data -- we don't call GetBuiltinData(fragInputs, surfaceData, ...)
-        // that function assumes there are specific global properties defined
-        // for shadergraph shaders, we fill it out here instead
-        ZERO_INITIALIZE(BuiltinData, builtinData);
+        // Builtin Data
+        ZERO_INITIALIZE(BuiltinData, builtinData); // No call to InitBuiltinData as we don't have any lighting
-        builtinData.bakeDiffuseLighting =       float3(0.0, 0.0, 0.0);
-        builtinData.velocity =                  float2(0.0, 0.0);
-        builtinData.shadowMask0 = 0.0;
-        builtinData.shadowMask1 = 0.0;
-        builtinData.shadowMask2 = 0.0;
-        builtinData.shadowMask3 = 0.0;
-        builtinData.renderingLayers =           0.0;
-        builtinData.depthOffset =               0.0;                        // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput);
     }
 
     //-------------------------------------------------------------------------------------

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

     return (lightLayers & renderingLayers) != 0;
 }
 
-// bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
 void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, BuiltinData builtinData, uint featureFlags,
                 out float3 diffuseLighting,
                 out float3 specularLighting)

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs

         // BuiltinData
         // This structure include common data that should be present in all material
         // and are independent from the BSDF parametrization.
-        // Note: These parameters can be store in GBuffer if the writer wants
+        // Note: These parameters can be store in GBuffer or not depends on storage available
         //-----------------------------------------------------------------------------
         [GenerateHLSL(PackingRules.Exact, false, true, 100)]
         public struct BuiltinData
             // at the same time than material information.
             [SurfaceDataAttributes("Bake Diffuse Lighting", false, true)]
             public Vector3 bakeDiffuseLighting; // This is the result of sampling lightmap/lightprobe/proxyvolume
+            [SurfaceDataAttributes("Back Bake Diffuse Lighting", false, true)]
+            public Vector3 backBakeDiffuseLighting; // This is the result of sampling lightmap/lightprobe/proxyvolume from the back for transmission
 
             // Use for float instead of vector4 to ease the debug (no performance impact)
             // Note: We have no way to remove these value automatically based on either SHADEROPTIONS_BAKED_SHADOW_MASK_ENABLE or s_BakedShadowMaskEnable here. Unless we make two structure... For now always keep this value
             [SurfaceDataAttributes("Distortion Blur")]
             public float distortionBlur;           // Define the color buffer mipmap level to use
 
+            // Misc
-            // Depth
             [SurfaceDataAttributes("Depth Offset")]
             public float depthOffset; // define the depth in unity unit to add in Z forward direction
         };

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs.hlsl

 //
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY (100)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING (101)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_0 (102)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_1 (103)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_2 (104)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_3 (105)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR (106)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (107)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (108)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (109)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_RENDERING_LAYERS (110)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (111)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_BACK_BAKE_DIFFUSE_LIGHTING (102)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_0 (103)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_1 (104)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_2 (105)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_3 (106)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR (107)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (108)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (109)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (110)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_RENDERING_LAYERS (111)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (112)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin+BuiltinData
 // PackingRules = Exact
     float3 bakeDiffuseLighting;
+    float3 backBakeDiffuseLighting;
     float shadowMask0;
     float shadowMask1;
     float shadowMask2;
             break;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
             result = builtindata.bakeDiffuseLighting;
+            needLinearToSRGB = true;
+            break;
+        case DEBUGVIEW_BUILTIN_BUILTINDATA_BACK_BAKE_DIFFUSE_LIGHTING:
+            result = builtindata.backBakeDiffuseLighting;
             needLinearToSRGB = true;
             break;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_0:

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/DecalData.hlsl

 #include "CoreRP/ShaderLibrary/Packing.hlsl"
 #include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
 #include "CoreRP/ShaderLibrary/EntityLighting.hlsl"
-#include "../MaterialUtilities.hlsl"
 
 #if (SHADERPASS == SHADERPASS_DBUFFER_PROJECTOR)
 void GetSurfaceData(float2 texCoordDS, float4x4 normalToWorld, out DecalSurfaceData surfaceData)
 #if (SHADERPASS == SHADERPASS_DBUFFER_PROJECTOR)
 	float3 normalWS = mul((float3x3)normalToWorld, normalTS);
 #elif (SHADERPASS == SHADERPASS_DBUFFER_MESH)	
-	float3 normalWS;
-	GetNormalWS(input, 0, normalTS, normalWS);
+    // We need to normalize as we use mikkt tangent space and this is expected (tangent space is not normalize)
+    float3 normalWS = normalize(TransformTangentToWorld(normalTS, input.worldToTangent));
 #endif
 	surfaceData.normalWS.xyz = normalWS * 0.5f + 0.5f;
 	surfaceData.HTileMask |= DBUFFERHTILEBIT_NORMAL;

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLitData.hlsl

     surfaceData.atDistance = 1000000.0;
     surfaceData.transmittanceMask = 0.0;
 
-    GetNormalWS(input, V, normalTS, surfaceData.normalWS);
+    GetNormalWS(input, normalTS, surfaceData.normalWS);
-    GetNormalWS(input, V, bentNormalTS, bentNormalWS);
+    GetNormalWS(input, bentNormalTS, bentNormalWS);
 #else // if no bent normal are available at all just keep the calculation fully
     bentNormalWS = surfaceData.normalWS;
 #endif
     surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, input.worldToTangent[2], _SpecularAAScreenSpaceVariance, _SpecularAAThreshold);
 #endif
 
-    GetBuiltinData(input, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
+    GetBuiltinData(input, V, posInput, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
 }
 
 #include "../Lit/LitDataMeshModification.hlsl"

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

     outGBuffer2.a  = PackFloatInt8bit(coatMask, materialFeatureId, 8);
 
     // RT3 - 11f:11f:10f
-    outGBuffer3 = float4(builtinData.bakeDiffuseLighting, 0.0);
-
+    // 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.
+    // Also if we don't have the room to store AO, then we apply it at this time on bakeDiffuseLighting which will cause a double occlusion with SSAO
+    outGBuffer3 = float4(builtinData.bakeDiffuseLighting + builtinData.emissiveColor, 0.0);
+#else
+    outGBuffer3 = float4(builtinData.bakeDiffuseLighting * surfaceData.ambientOcclusion + builtinData.emissiveColor, 0.0);
 #endif
 
 #ifdef SHADOWS_SHADOWMASK
     GBufferType2 inGBuffer2 = LOAD_TEXTURE2D(_GBufferTexture2, positionSS);
 
     // BuiltinData
-    builtinData.bakeDiffuseLighting = LOAD_TEXTURE2D(_GBufferTexture3, positionSS).rgb;  // This also contain emissive
+    builtinData.bakeDiffuseLighting = LOAD_TEXTURE2D(_GBufferTexture3, positionSS).rgb;  // This also contain emissive (and * AO if no lightlayers)
 
     // Avoid to introduce a new variant for light layer as it is already long to compile
     if (_EnableLightLayers)
 // bake lighting function
 //-----------------------------------------------------------------------------
 
-// GetBakedDiffuseLighting function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case)
-// In forward it must be add to the final contribution.
-// This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer.
-float3 GetBakedDiffuseLighting(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
+// This define allow to say that we implement a ModifyBakedDiffuseLighting function to be call in PostInitBuiltinData
+#define MODIFY_BAKED_DIFFUSE_LIGHTING
+
+// This function allow to modify the content of (back) baked diffuse lighting when we gather builtinData
+// This is use to apply lighting model specific code, like pre-integration, transmission etc...
+// It is up to the lighting model implementer to chose if the modification are apply here or in PostEvaluateBSDF
+void ModifyBakedDiffuseLighting(float3 V, PositionInputs posInput, SurfaceData surfaceData, inout BuiltinData builtinData)
-#ifdef DEBUG_DISPLAY
-    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
-    {
-        // The lighting in SH or lightmap is assume to contain bounced light only (i.e no direct lighting), and is divide by PI (i.e Lambert is apply), so multiply by PI here to get back the illuminance
-        return builtinData.bakeDiffuseLighting * PI;
+    // In case of deferred, all lighting model operation are done before storage in GBuffer, as we store emissive with bakeDiffuseLighting
+
+    // To get the data we need to do the whole process - compiler should optimize everything
+    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS, surfaceData);
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    // Add GI transmission contribution to bakeDiffuseLighting, we then drop backBakeDiffuseLighting (i.e it is not used anymore, this save VGPR in forward and in deferred we can't store it anyway)
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
+    {       
+        builtinData.bakeDiffuseLighting += builtinData.backBakeDiffuseLighting * bsdfData.transmittance;
-#endif
-    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING)) // This test is static as it is done in GBuffer or forward pass, will be remove by compiler
+    // For SSS we need to take into account the state of diffuseColor 
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
-        bsdfData.diffuseColor = GetModifiedDiffuseColorForSSS(bsdfData); // local modification of bsdfData
+        bsdfData.diffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
-    // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
-    return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor;
+    // Premultiply (back) bake diffuse lighting information with DisneyDiffuse pre-integration
+    builtinData.bakeDiffuseLighting *= preLightData.diffuseFGD * bsdfData.diffuseColor;
 }
 
 //-----------------------------------------------------------------------------
     float3 modifiedDiffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
 
     // Apply the albedo to the direct diffuse lighting (only once). The indirect (baked)
-    // diffuse lighting has already had the albedo applied in GetBakedDiffuseLighting().
-    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + builtinData.bakeDiffuseLighting;
+    // diffuse lighting has already multiply the albedo in ModifyBakedDiffuseLighting().
+    // Note: In deferred bakeDiffuseLighting also contain emissive and in this case emissiveColor is 0
+    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + builtinData.bakeDiffuseLighting + builtinData.emissiveColor;
 
     // If refraction is enable we use the transmittanceMask to lerp between current diffuse lighting and refraction value
     // Physically speaking, transmittanceMask should be 1, but for artistic reasons, we let the value vary

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

-void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float3 bentNormalWS, float depthOffset, out BuiltinData builtinData)
+void GetBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, SurfaceData surfaceData, float alpha, float3 bentNormalWS, float depthOffset, out BuiltinData builtinData)
-    // Builtin Data
-    builtinData.opacity = alpha;
-
-    // TODO: Sample lightmap/lightprobe/volume proxy
-    // This should also handle projective lightmap
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionRWS, bentNormalWS, input.texCoord1, input.texCoord2);
-
-    // It is safe to call this function here as surfaceData have been filled
-    // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
-    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(input.positionSS.xy, surfaceData);
-    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
-    {
-        // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
-        // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
-        // TODO: optimize more this code.
-        // Add GI transmission contribution by resampling the GI for inverted vertex normal
-        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionRWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
-    }
-
-#ifdef SHADOWS_SHADOWMASK
-    float4 shadowMask = SampleShadowMask(input.positionRWS, input.texCoord1);
-    builtinData.shadowMask0 = shadowMask.x;
-    builtinData.shadowMask1 = shadowMask.y;
-    builtinData.shadowMask2 = shadowMask.z;
-    builtinData.shadowMask3 = shadowMask.w;
-#else
-    builtinData.shadowMask0 = 0.0;
-    builtinData.shadowMask1 = 0.0;
-    builtinData.shadowMask2 = 0.0;
-    builtinData.shadowMask3 = 0.0;
-#endif
+    // For back lighting we use the oposite vertex normal 
+    InitBuiltinData(alpha, bentNormalWS, -input.worldToTangent[2], input.positionRWS, input.texCoord1, input.texCoord2, builtinData);
 
     builtinData.emissiveColor = _EmissiveColor * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
 #ifdef _EMISSIVE_COLOR_MAP
     builtinData.emissiveColor *= SAMPLE_UVMAPPING_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, emissiveMapMapping).rgb;
 #endif // _EMISSIVE_COLOR_MAP
 
-    builtinData.velocity = float2(0.0, 0.0);
-
-#else
-    builtinData.distortion = float2(0.0, 0.0);
-    builtinData.distortionBlur = 0.0;
-    // Use uniform directly - The float need to be cast to uint (as unity don't support to set a uint as uniform)
-    builtinData.renderingLayers = _EnableLightLayers ? asuint(unity_RenderingLayer.x) : DEFAULT_LIGHT_LAYERS;
+    builtinData.depthOffset = depthOffset;
-    builtinData.depthOffset = depthOffset;
+    PostInitBuiltinData(V, posInput, surfaceData, builtinData);
 }

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

 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
 #include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
-#include "../MaterialUtilities.hlsl"
-#include "../Decal/DecalUtilities.hlsl"
+#include "HDRP/Material/MaterialUtilities.hlsl"
+#include "HDRP/Material/Decal/DecalUtilities.hlsl"
 
 // TODO: move this function to commonLighting.hlsl once validated it work correctly
 float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData)
     float3 bentNormalTS;
     float3 bentNormalWS;
     float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS);
-    GetNormalWS(input, V, normalTS, surfaceData.normalWS);
+    GetNormalWS(input, normalTS, surfaceData.normalWS);
-    GetNormalWS(input, V, bentNormalTS, bentNormalWS);
+    GetNormalWS(input, bentNormalTS, bentNormalWS);
 #else
     bentNormalWS = surfaceData.normalWS;
 #endif
 #endif
 
     // Caution: surfaceData must be fully initialize before calling GetBuiltinData
-    GetBuiltinData(input, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
+    GetBuiltinData(input, V, posInput, surfaceData, alpha, bentNormalWS, depthOffset, builtinData);
 }
 
 #include "LitDataMeshModification.hlsl"

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

 
 void ApplyAmbientOcclusionFactor(AmbientOcclusionFactor aoFactor, inout BuiltinData builtinData, inout AggregateLighting lighting)
 {
-    // Note: in case of deferred Lit, builtinData.bakeDiffuseLighting contain indirect diffuse + emissive,
-    // so Ambient occlusion is multiply by emissive which is wrong but not a big deal
+    // Note: in case of deferred Lit, builtinData.bakeDiffuseLighting contain indirect diffuse * surfaceData.ambientOcclusion + emissive,
+    // so emissive is affected by SSAO and we get a double darkening from SSAO and from AO which is incorrect but we accept the tradeoff
     builtinData.bakeDiffuseLighting *= aoFactor.indirectAmbientOcclusion;
     lighting.indirect.specularReflected *= aoFactor.indirectSpecularOcclusion;
     lighting.direct.diffuse *= aoFactor.directAmbientOcclusion;
         switch (_DebugLightingMode)
         {
         case DEBUGLIGHTINGMODE_LUX_METER:
+            // Note: We don't include emissive here (and in deferred it is correct as lux calculation of bakeDiffuseLighting don't consider emissive)
             diffuseLighting = lighting.direct.diffuse + builtinData.bakeDiffuseLighting;
 
             //Compress lighting values for color picker if enabled

com.unity.render-pipelines.high-definition/HDRP/Material/MaterialUtilities.hlsl

 #endif
 }
 
+// For builtinData we want to allow the user to overwrite default GI in the surface shader / shader graph.
+// So we perform the following order of operation:
+// 1. InitBuiltinData - Init bakeDiffuseLighting and backBakeDiffuseLighting
+// 2. User can overwrite these value in the surface shader / shader graph
+// 3. PostInitBuiltinData - Handle debug mode + allow the current lighting model to update the data with ModifyBakedDiffuseLighting
+
+// This method initialize BuiltinData usual values and after update of builtinData by the caller must be follow by PostInitBuiltinData
+void InitBuiltinData(   float alpha, float3 normalWS, float3 backNormalWS, float3 positionRWS, float2 texCoord1, float2 texCoord2,
+                        out BuiltinData builtinData)
+{
+    ZERO_INITIALIZE(BuiltinData, builtinData);
+
+    builtinData.opacity = alpha;
+
+    // Sample lightmap/lightprobe/volume proxy
+    builtinData.bakeDiffuseLighting = SampleBakedGI(positionRWS, normalWS, texCoord1, texCoord2);
+    // We also sample the back lighting in case we have transmission. If not use this will be optimize out by the compiler
+    // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
+    // however it may not optimize the lightprobe case due to the proxy volume relying on dynamic if (to verify), not a problem for SH9, but a problem for proxy volume.
+    // TODO: optimize more this code.    
+    builtinData.backBakeDiffuseLighting = SampleBakedGI(positionRWS, backNormalWS, texCoord1, texCoord2);
+
+#ifdef SHADOWS_SHADOWMASK
+    float4 shadowMask = SampleShadowMask(positionRWS, texCoord1);
+    builtinData.shadowMask0 = shadowMask.x;
+    builtinData.shadowMask1 = shadowMask.y;
+    builtinData.shadowMask2 = shadowMask.z;
+    builtinData.shadowMask3 = shadowMask.w;
+#endif
+
+    // Use uniform directly - The float need to be cast to uint (as unity don't support to set a uint as uniform)
+    builtinData.renderingLayers = _EnableLightLayers ? asuint(unity_RenderingLayer.x) : DEFAULT_LIGHT_LAYERS;
+}
+
+// InitBuiltinData must be call before calling PostInitBuiltinData
+void PostInitBuiltinData(   float3 V, inout PositionInputs posInput, SurfaceData surfaceData,
+                            inout BuiltinData builtinData)
+{
+#ifdef DEBUG_DISPLAY
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    {
+        // The lighting in SH or lightmap is assume to contain bounced light only (i.e no direct lighting),
+        // and is divide by PI (i.e Lambert is apply), so multiply by PI here to get back the illuminance
+        builtinData.bakeDiffuseLighting *= PI; // don't take into account backBakeDiffuseLighting
+    }
+    else
+#endif
+    {
+#ifdef MODIFY_BAKED_DIFFUSE_LIGHTING
+        ModifyBakedDiffuseLighting(V, posInput, surfaceData, builtinData);
+#endif
+    }
+}
+
 // Flipping or mirroring a normal can be done directly on the tangent space. This has the benefit to apply to the whole process either in surface gradient or not.
 // This function will modify FragInputs and this is not propagate outside of GetSurfaceAndBuiltinData(). This is ok as tangent space is not use outside of GetSurfaceAndBuiltinData().
 void ApplyDoubleSidedFlipOrMirror(inout FragInputs input)
 }
 
 // This function convert the tangent space normal/tangent to world space and orthonormalize it + apply a correction of the normal if it is not pointing towards the near plane
-void GetNormalWS(FragInputs input, float3 V, float3 normalTS, out float3 normalWS)
+void GetNormalWS(FragInputs input, float3 normalTS, out float3 normalWS)
-    #ifdef SURFACE_GRADIENT
+#ifdef SURFACE_GRADIENT
-    #else
+#else
-    #endif
+#endif
 }

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.hlsl

 // bake lighting function
 //-----------------------------------------------------------------------------
 
-//
-// GetBakedDiffuseLighting will be called from ShaderPassForward.hlsl.
-//
-// GetBakedDiffuseLighting function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case)
-// In forward it must be add to the final contribution.
-// This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer.
-float3 GetBakedDiffuseLighting(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
+// This define allow to say that we implement a ModifyBakedDiffuseLighting function to be call in PostInitBuiltinData
+#define MODIFY_BAKED_DIFFUSE_LIGHTING
+
+void ModifyBakedDiffuseLighting(float3 V, PositionInputs posInput, SurfaceData surfaceData, inout BuiltinData builtinData)
-#ifdef DEBUG_DISPLAY
-    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+    // To get the data we need to do the whole process - compiler should optimize everything
+    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS, surfaceData);
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    // Add GI transmission contribution to bakeDiffuseLighting, we then drop backBakeDiffuseLighting (i.e it is not used anymore, this save VGPR)
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_STACK_LIT_TRANSMISSION))
-        // The lighting in SH or lightmap is assume to contain bounced light only (i.e no direct lighting), and is divide by PI (i.e Lambert is apply), so multiply by PI here to get back the illuminance
-        return builtinData.bakeDiffuseLighting * PI;
+        builtinData.bakeDiffuseLighting += builtinData.backBakeDiffuseLighting * bsdfData.transmittance;
-#endif
-    // Note bsdfData isn't modified outside of this function scope.
-    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_STACK_LIT_SUBSURFACE_SCATTERING)) // This test is static as it is done in GBuffer or forward pass, will be remove by compiler
+    // For SSS we need to take into account the state of diffuseColor 
+    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_STACK_LIT_SUBSURFACE_SCATTERING))
-        // SSS Texturing mode can change albedo because diffuse maps can already contain some SSS too
-        bsdfData.diffuseColor = GetModifiedDiffuseColorForSSS(bsdfData); // local modification of bsdfData
+        bsdfData.diffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
-    // Premultiply bake diffuse lighting information
+    // Premultiply (back) bake diffuse lighting information with diffuse pre-integration
-    return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * preLightData.diffuseEnergy * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor;
+    builtinData.bakeDiffuseLighting *= preLightData.diffuseFGD * preLightData.diffuseEnergy * bsdfData.diffuseColor;
-
 
 //-----------------------------------------------------------------------------
 // light transport functions
     float3 modifiedDiffuseColor = GetModifiedDiffuseColorForSSS(bsdfData);
 
     // Apply the albedo to the direct diffuse lighting (only once). The indirect (baked)
-    // diffuse lighting has already had the albedo applied in GetBakedDiffuseLighting().
-    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + builtinData.bakeDiffuseLighting;
+    // diffuse lighting has already multiply the albedo in ModifyBakedDiffuseLighting().
+    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + builtinData.bakeDiffuseLighting + builtinData.emissiveColor;
 
     specularLighting = lighting.direct.specular + lighting.indirect.specularReflected;
 

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLitData.hlsl

 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
 #include "CoreRP/ShaderLibrary/Sampling/SampleUVMapping.hlsl"
-#include "../MaterialUtilities.hlsl"
+#include "HDRP/Material/MaterialUtilities.hlsl"
 
 //-----------------------------------------------------------------------------
 // Texture Mapping
     // Builtin Data:
     // -------------------------------------------------------------
 
-    // NEWLITTODO: for all BuiltinData, might need to just refactor and use a comon function like that
-    // contained in LitBuiltinData.hlsl
-
-    builtinData.opacity = alpha;
-
-    builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionRWS, surfaceData.normalWS, input.texCoord1, input.texCoord2);
-
-    // It is safe to call this function here as surfaceData have been filled
-    // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
-    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(input.positionSS.xy, surfaceData);
-    if (HasFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_STACK_LIT_TRANSMISSION))
-    {
-        // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap
-        // however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume.
-        // TODO: optimize more this code.
-        // Add GI transmission contribution by resampling the GI for inverted vertex normal
-        builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionRWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
-    }
+    // For back lighting we use the oposite vertex normal 
+    InitBuiltinData(alpha, surfaceData.normalWS, -input.worldToTangent[2], input.positionRWS, input.texCoord1, input.texCoord2, builtinData);
-    // TODO:
-    builtinData.velocity = float2(0.0, 0.0);
-
-#ifdef SHADOWS_SHADOWMASK
-    float4 shadowMask = SampleShadowMask(input.positionRWS, input.texCoord1);
-    builtinData.shadowMask0 = shadowMask.x;
-    builtinData.shadowMask1 = shadowMask.y;
-    builtinData.shadowMask2 = shadowMask.z;
-    builtinData.shadowMask3 = shadowMask.w;
-#else
-    builtinData.shadowMask0 = 0.0;
-    builtinData.shadowMask1 = 0.0;
-    builtinData.shadowMask2 = 0.0;
-    builtinData.shadowMask3 = 0.0;
-#endif
-
-#else
-    builtinData.distortion = float2(0.0, 0.0);
-    builtinData.distortionBlur = 0.0;
-    // Use uniform directly - The float need to be cast to uint (as unity don't support to set a uint as uniform)
-    builtinData.renderingLayers = _EnableLightLayers ? asuint(unity_RenderingLayer.x) : DEFAULT_LIGHT_LAYERS;
-
-    builtinData.depthOffset = 0.0;
+    PostInitBuiltinData(V, posInput, surfaceData, builtinData);
 }

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/UnlitData.hlsl

 //-------------------------------------------------------------------------------------
 // Fill SurfaceData/Builtin data function
 //-------------------------------------------------------------------------------------
-#include "../MaterialUtilities.hlsl"
 
 void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData)
 {
 #endif
 
     // Builtin Data
+    ZERO_INITIALIZE(BuiltinData, builtinData); // No call to InitBuiltinData as we don't have any lighting
-
-    builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
 
 #ifdef _EMISSIVE_COLOR_MAP
     builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb * _EmissiveColor;
 
-    builtinData.velocity = float2(0.0, 0.0);
-
-    builtinData.shadowMask0 = 0.0;
-    builtinData.shadowMask1 = 0.0;
-    builtinData.shadowMask2 = 0.0;
-    builtinData.shadowMask3 = 0.0;
-
-#else
-    builtinData.distortion = float2(0.0, 0.0);
-    builtinData.distortionBlur = 0.0;
-
-    builtinData.renderingLayers = 0;
-
-    builtinData.depthOffset = 0.0;
 
 #if defined(DEBUG_DISPLAY)
     if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDepthOnly.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     SurfaceData surfaceData;

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDistortion.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     // Perform alpha testing + get distortion

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassForward.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     SurfaceData surfaceData;
         float3 diffuseLighting;
         float3 specularLighting;
 
-        builtinData.bakeDiffuseLighting = GetBakedDiffuseLighting(surfaceData, builtinData, bsdfData, preLightData);
         LightLoop(V, posInput, preLightData, bsdfData, builtinData, featureFlags, diffuseLighting, specularLighting);
 
 #ifdef OUTPUT_SPLIT_LIGHTING

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassForwardUnlit.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     SurfaceData surfaceData;

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassGBuffer.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     SurfaceData surfaceData;
     ApplyDebugToSurfaceData(input.worldToTangent, surfaceData);
 #endif
 
-    BSDFData bsdfData = ConvertSurfaceDataToBSDFData(input.positionSS.xy, surfaceData);
-
-    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
-
-    builtinData.bakeDiffuseLighting = GetBakedDiffuseLighting(surfaceData, builtinData, bsdfData, preLightData);
     ENCODE_INTO_GBUFFER(surfaceData, builtinData, posInput.positionSS, outGBuffer);
 
 #ifdef _DEPTHOFFSET_ON

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassLightTransport.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     SurfaceData surfaceData;

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassVelocity.hlsl

 #ifdef VARYINGS_NEED_POSITION_WS
     float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
 #else
-    float3 V = 0; // Avoid the division by 0
+    // Unused
+    float3 V = float3(1.0, 1.0, 1.0); // Avoid the division by 0
 #endif
 
     // Perform alpha testing + get velocity