Merge HDRP/staging

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}

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/9x_Other/9001_Decals/Decal_All_ColorTint.mat

   serializedVersion: 6
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_Name: Decal_All_ColorTint
   m_Shader: {fileID: 4800000, guid: 1d64af84bdc970c4fae0c1e06dd95b73, type: 3}
   m_ShaderKeywords: _ALBEDOCONTRIBUTION _COLORMAP _MASKMAP _NORMALMAP
   m_CustomRenderQueue: -1
   stringTagMap: {}
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DBufferMesh_M
+  - DBufferMesh_AO
+  - DBufferMesh_MAO
+  - DBufferMesh_MAOS
+  - DBufferMesh_MS
+  - DBufferMesh_AOS
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
+    - _DrawOrder: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _InvTilingScale: 1
     - _LinkDetailsWithBase: 1
     - _MaskBlendMode: 4
-    - _MaskBlendSrc: 1
+    - _MaskBlendSrc: 0
     - _MaskmapAO: 0
     - _MaskmapMetal: 0
     - _MaskmapSmoothness: 1

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/9x_Other/9001_Decals/Decal_BlendMask.mat

   serializedVersion: 6
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_Name: Decal_BlendMask
   m_Shader: {fileID: 4800000, guid: 1d64af84bdc970c4fae0c1e06dd95b73, type: 3}
   m_ShaderKeywords: _ALBEDOCONTRIBUTION _COLORMAP _MASKMAP _NORMALMAP
   m_CustomRenderQueue: -1
   stringTagMap: {}
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DBufferMesh_M
+  - DBufferMesh_AO
+  - DBufferMesh_MAO
+  - DBufferMesh_MAOS
+  - DBufferMesh_MS
+  - DBufferMesh_AOS
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
+    - _DrawOrder: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _InvTilingScale: 1
     - _LinkDetailsWithBase: 1
     - _MaskBlendMode: 4
-    - _MaskBlendSrc: 1
+    - _MaskBlendSrc: 0
     - _MaskmapAO: 0
     - _MaskmapMetal: 0
     - _MaskmapSmoothness: 1

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/9x_Other/9001_Decals/Decal_BlendMask_Factor05.mat

   serializedVersion: 6
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_Name: Decal_BlendMask_Factor05
   m_Shader: {fileID: 4800000, guid: 1d64af84bdc970c4fae0c1e06dd95b73, type: 3}
   m_ShaderKeywords: _ALBEDOCONTRIBUTION _COLORMAP _MASKMAP _NORMALMAP
   m_CustomRenderQueue: -1
   stringTagMap: {}
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DBufferMesh_M
+  - DBufferMesh_AO
+  - DBufferMesh_MAO
+  - DBufferMesh_MAOS
+  - DBufferMesh_MS
+  - DBufferMesh_AOS
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
+    - _DrawOrder: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _InvTilingScale: 1
     - _LinkDetailsWithBase: 1
     - _MaskBlendMode: 4
-    - _MaskBlendSrc: 1
+    - _MaskBlendSrc: 0
     - _MaskmapAO: 0
     - _MaskmapMetal: 0
     - _MaskmapSmoothness: 1

TestProjects/HDRP_Tests/Assets/GraphicTests/Scenes/9x_Other/9001_Decals/Decal_BlendMask_NoAlbedo.mat

   serializedVersion: 6
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_Name: Decal_BlendMask_NoAlbedo
   m_Shader: {fileID: 4800000, guid: 1d64af84bdc970c4fae0c1e06dd95b73, type: 3}
   m_ShaderKeywords: _COLORMAP _MASKMAP _NORMALMAP
   m_CustomRenderQueue: -1
   stringTagMap: {}
-  disabledShaderPasses: []
+  disabledShaderPasses:
+  - DBufferMesh_M
+  - DBufferMesh_AO
+  - DBufferMesh_MAO
+  - DBufferMesh_MAOS
+  - DBufferMesh_MS
+  - DBufferMesh_AOS
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
+    - _DrawOrder: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _InvTilingScale: 1
     - _LinkDetailsWithBase: 1
     - _MaskBlendMode: 4
-    - _MaskBlendSrc: 1
+    - _MaskBlendSrc: 0
     - _MaskmapAO: 0
     - _MaskmapMetal: 0
     - _MaskmapSmoothness: 1

build.py

 
 def packages_list():
     return [
+        #ORDER IS IMPORTANT
+        ("com.unity.shadergraph", os.path.join("com.unity.shadergraph")),
-        ("com.unity.shadergraph", os.path.join("com.unity.shadergraph")),
         ("com.unity.testframework.graphics", os.path.join("com.unity.testframework.graphics"))
     ]
 

com.unity.render-pipelines.core/CoreRP/Textures/TextureCache.cs

         {
         }
 
+        bool TextureHasMipmaps(Texture texture)
+        {
+            var crt = texture as CustomRenderTexture;
+
+            if (texture is Texture2D)
+                return ((Texture2D)texture).mipmapCount > 1;
+            else if (crt is CustomRenderTexture)
+                return ((CustomRenderTexture)texture).useMipMap;
+            return false;
+        }
+
         public override void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
         {
             var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);
             }
             else
             {
-                cmd.CopyTexture(texture, 0, m_Cache, sliceIndex);
+                if (TextureHasMipmaps(texture))
+                    cmd.CopyTexture(texture, 0, m_Cache, sliceIndex);
+                else
+                    Debug.LogWarning("The texture '" + texture + "' should have mipmaps to be handeled by the cookie texture array");
             }
         }
 

com.unity.render-pipelines.core/package.json

     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
     "version": "3.0.1-preview",
-    "unity": "2018.2",
+    "unity": "2018.3",
     "displayName": "Render Pipeline Core Library"
 }

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
 - Added a volume to control indirect light intensity
 
 ### Fixed
 - Refactored Constant Buffers to avoid hitting the maximum number of bound CBs in some cases.
 - Fixed the light range affecting the transform scale when changed.
 - Snap to grid now works for Decal projector resizing.
+- Added a warning for 128x128 cookie texture without mipmaps
 
 ### Changed
 - Movde Render Pipeline Debug "Windows from Windows->General-> Render Pipeline debug windows" to "Windows from Windows->Analysis-> Render Pipeline debug windows"
 - Refactor shader code: BakeLightingData structure have been replace by BuiltinData. Lot of shader code have been remove/change.
 - Refactor shader code: All GBuffer are now handled by the deferred material. Mean ShadowMask and LightLayers are control by lit material in lit.hlsl and not outside anymore. Lot of shader code have been remove/change.
+- Refactor shader code: Rename GetBakedDiffuseLighting to ModifyBakedDiffuseLighting. This function now handle lighting model for transmission too. Lux meter debug mode is factor outisde.
+- Refactor shader code: GetBakedDiffuseLighting is not call anymore in GBuffer or forward pass, including the ConvertSurfaceDataToBSDFData and GetPreLightData, this is done in ModifyBakedDiffuseLighting now
+- Refactor shader code: Added a backBakeDiffuseLighting to BuiltinData to handle lighting for transmission
+- Refactor shader code: Material must now call InitBuiltinData (Init all to zero + init bakeDiffuseLighting and backBakeDiffuseLighting ) and PostInitBuiltinData
 
 ### Added
 - Added support for RendererPriority on Renderer. This allow to control order of transparent rendering manually. HDRP have now two stage of sorting for transparent in addition to bact to front. Material have a priority then Renderer have a priority.

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.cs

 
         static void ApplyConstraintsOnTargets(HDReflectionProbeUI s, SerializedHDReflectionProbe sp, Editor o)
         {
-            switch ((Shape)sp.influenceVolume.shape.enumValueIndex)
+            switch ((InfluenceShape)sp.influenceVolume.shape.enumValueIndex)
-                case Shape.Box:
+                case InfluenceShape.Box:
                 {
                     var maxBlendDistance = sp.influenceVolume.boxSize.vector3Value;
                     sp.targetData.influenceVolume.boxBlendDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistancePositive, maxBlendDistance);
                     break;
                 }
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                 {
                     var maxBlendDistance = Vector3.one * sp.influenceVolume.sphereRadius.floatValue;
                     sp.targetData.influenceVolume.boxBlendDistancePositive = Vector3.Min(sp.targetData.influenceVolume.boxBlendDistancePositive, maxBlendDistance);

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs

             if (p.proxyVolumeComponent.objectReferenceValue != null)
             {
                 var proxy = (ReflectionProxyVolumeComponent)p.proxyVolumeComponent.objectReferenceValue;
-                if ((int)proxy.proxyVolume.shapeType != p.influenceVolume.shape.enumValueIndex)
+                if ((int)proxy.proxyVolume.shape != p.influenceVolume.shape.enumValueIndex)
                     EditorGUILayout.HelpBox(
                         "Proxy volume and influence volume have different shape types, this is not supported.",
                         MessageType.Error,
             if (EditorGUI.EndChangeCheck())
                 s.SetShapeTarget(p.influenceVolume.shape.intValue);
 
-            switch ((Shape)p.influenceVolume.shape.enumValueIndex)
+            switch ((InfluenceShape)p.influenceVolume.shape.enumValueIndex)
-                case Shape.Box:
+                case InfluenceShape.Box:
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                     Drawer_InfluenceShapeSphereSettings(s, p, owner);
                     break;
             }
 
         static void Drawer_InfluenceAreas(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
         {
-            if (s.IsSectionExpandedShape(Shape.Box).value)
+            if (s.IsSectionExpandedShape(InfluenceShape.Box).value)
-            if (s.IsSectionExpandedShape(Shape.Sphere).value)
+            if (s.IsSectionExpandedShape(InfluenceShape.Sphere).value)
             {
                 Drawer_InfluenceSphereSettings(s, p, owner);
             }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.cs

     {
         const int k_AnimBoolSingleFieldCount = 4;
         static readonly int k_ReflectionProbeModeCount = Enum.GetValues(typeof(ReflectionProbeMode)).Length;
-        static readonly int k_ReflectionInfluenceShapeCount = Enum.GetValues(typeof(Shape)).Length;
+        static readonly int k_ReflectionInfluenceShapeCount = Enum.GetValues(typeof(InfluenceShape)).Length;
         static readonly int k_AnimBoolsCount = k_ReflectionProbeModeCount + k_ReflectionInfluenceShapeCount + k_AnimBoolSingleFieldCount;
 
         public InfluenceVolumeUI influenceVolume = new InfluenceVolumeUI();
                 GetReflectionProbeModeBool(i).target = i == value;
         }
 
-        public AnimBool IsSectionExpandedShape(Shape value)
+        public AnimBool IsSectionExpandedShape(InfluenceShape value)
         {
             return m_AnimBools[k_AnimBoolSingleFieldCount + k_ReflectionProbeModeCount + (int)value];
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

         static void Drawer_DifferentShapeError(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
         {
             var proxy = d.proxyVolumeReference.objectReferenceValue as ReflectionProxyVolumeComponent;
-            if (proxy != null && (int)proxy.proxyVolume.shapeType != d.influenceVolume.shape.enumValueIndex)
+            if (proxy != null && (int)proxy.proxyVolume.shape != d.influenceVolume.shape.enumValueIndex)
             {
                 EditorGUILayout.HelpBox(
                     "Proxy volume and influence volume have different shape types, this is not supported.",
             if (d.proxyVolumeReference.objectReferenceValue != null)
             {
                 var proxy = (ReflectionProxyVolumeComponent)d.proxyVolumeReference.objectReferenceValue;
-                if ((int)proxy.proxyVolume.shapeType != d.influenceVolume.shape.enumValueIndex)
+                if ((int)proxy.proxyVolume.shape != d.influenceVolume.shape.enumValueIndex)
                     EditorGUILayout.HelpBox(
                         "Proxy volume and influence volume have different shape types, this is not supported.",
                         MessageType.Error,

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.Drawers.cs

                         CED.space,
                         CED.Action(Drawer_FieldShapeType),
                         CED.FadeGroup(
-                            (s, d, o, i) => s.IsSectionExpanded_Shape((Shape)i),
+                            (s, d, o, i) => s.IsSectionExpanded_Shape((InfluenceShape)i),
                             FadeOption.None,
                             SectionShapeBoxPlanar,
                             SectionShapeSpherePlanar
                         CED.space,
                         CED.Action(Drawer_FieldShapeType),
                         CED.FadeGroup(
-                            (s, d, o, i) => s.IsSectionExpanded_Shape((Shape)i),
+                            (s, d, o, i) => s.IsSectionExpanded_Shape((InfluenceShape)i),
                             FadeOption.None,
                             SectionShapeBox,
                             SectionShapeSphere

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.Gizmos.cs

             Gizmos.color = color;
             switch (d.shape)
             {
-                case Shape.Box:
+                case InfluenceShape.Box:
                 {
                     s.boxBaseHandle.center = d.offset;
                     s.boxBaseHandle.size = d.boxSize;
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                 {
                     if (isSolid)
                         Gizmos.DrawSphere(d.offset, d.sphereRadius);
             Gizmos.color = color;
             switch (d.shape)
             {
-                case Shape.Box:
+                case InfluenceShape.Box:
                 {
                     Gizmo6FacesBox refBox = isNormal ? s.boxInfluenceNormalHandle : s.boxInfluenceHandle;
                     refBox.center = d.offset + boxOffset;
                 }
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                 {
                     if (isSolid)
                         Gizmos.DrawSphere(d.offset, d.sphereRadius + sphereOffset);

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.Handles.cs

             Handles.color = k_GizmoThemeColorBase;
             switch (d.shape)
             {
-                case Shape.Box:
+                case InfluenceShape.Box:
                     {
                         var center = d.offset;
                         var size = d.boxSize;
                         d.boxSize = size;
                         break;
                     }
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                     {
                         var center = d.offset;
                         var radius = d.sphereRadius;
             Handles.color = k_GizmoThemeColorInfluence;
             switch (d.shape)
             {
-                case Shape.Box:
+                case InfluenceShape.Box:
                     {
                         var positive = d.boxBlendDistancePositive;
                         var negative = d.boxBlendDistanceNegative;
                         s.data.Apply();
                         break;
                     }
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                     {
                         var fade = d.sphereBlendDistance;
                         DrawSphereFadeHandle(
             Handles.color = k_GizmoThemeColorInfluenceNormal;
             switch (d.shape)
             {
-                case Shape.Box:
+                case InfluenceShape.Box:
                     {
 
                         Vector3 positive = d.boxBlendNormalDistancePositive;
                         s.data.Apply();
                         break;
                     }
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
                     {
                         var fade = d.sphereBlendNormalDistance;
                         DrawSphereFadeHandle(

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/InfluenceVolumeUI.cs

         internal static readonly Color k_GizmoThemeColorDisabled = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
         internal static readonly Color k_GizmoThemeColorDisabledFace = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
 
-        static readonly int k_ShapeCount = Enum.GetValues(typeof(Shape)).Length;
+        static readonly int k_ShapeCount = Enum.GetValues(typeof(InfluenceShape)).Length;
 
         public Gizmo6FacesBox boxBaseHandle;
         public Gizmo6FacesBoxContained boxInfluenceHandle;
         public override void Update()
         {
             base.Update();
-            SetIsSectionExpanded_Shape((Shape)data.shape.intValue);
+            SetIsSectionExpanded_Shape((InfluenceShape)data.shape.intValue);
-        void SetIsSectionExpanded_Shape(Shape shape)
+        void SetIsSectionExpanded_Shape(InfluenceShape shape)
-        public AnimBool IsSectionExpanded_Shape(Shape shapeType)
+        public AnimBool IsSectionExpanded_Shape(InfluenceShape shapeType)
         {
             return m_AnimBools[(int)shapeType];
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/ProxyVolumeUI.cs

         internal static Color k_GizmoThemeColorDisabled = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
         internal static Color k_GizmoThemeColorDisabledFace = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
 
-        static readonly int k_ShapeCount = Enum.GetValues(typeof(Shape)).Length;
+        static readonly int k_ShapeCount = Enum.GetValues(typeof(InfluenceShape)).Length;
 
         public static readonly CED.IDrawer SectionShape;
 
             SectionShape = CED.Group(
                     CED.Action(Drawer_FieldShapeType),
                     CED.FadeGroup(
-                        (s, d, o, i) => s.IsSectionExpanded_Shape((Shape)i),
+                        (s, d, o, i) => s.IsSectionExpanded_Shape((InfluenceShape)i),
                         FadeOption.Indent,
                         SectionShapeBox,
                         SectionShapeSphere
         {
             base.Update();
             if (data != null)
-                SetIsSectionExpanded_Shape((Shape)data.shapeType.intValue);
+                SetIsSectionExpanded_Shape((InfluenceShape)data.shape.intValue);
-        void SetIsSectionExpanded_Shape(Shape shape)
+        void SetIsSectionExpanded_Shape(InfluenceShape shape)
-        public AnimBool IsSectionExpanded_Shape(Shape shapeType)
+        public AnimBool IsSectionExpanded_Shape(InfluenceShape shapeType)
         {
             return m_AnimBools[(int)shapeType];
         }
-            EditorGUILayout.PropertyField(d.shapeType, _.GetContent("Shape Type"));
+            EditorGUILayout.PropertyField(d.shape, _.GetContent("Shape Type"));
-            EditorGUILayout.PropertyField(d.boxOffset, _.GetContent("Box Offset"));
-            EditorGUILayout.PropertyField(d.boxInfiniteProjection, _.GetContent("Infinite Projection"));
-            EditorGUILayout.PropertyField(d.sphereOffset, _.GetContent("Sphere Offset"));
-            EditorGUILayout.PropertyField(d.sphereInfiniteProjection, _.GetContent("Infinite Projection"));
-            switch (proxyVolume.shapeType)
+            switch (proxyVolume.shape)
-                case Shape.Box:
+                case ProxyShape.Box:
-                case Shape.Sphere:
+                case ProxyShape.Sphere:
                     Handles_EditBase_Sphere(transform, proxyVolume, ui, sourceAsset);
                     break;
             }
 
         static void Handles_EditBase_Sphere(Transform transform, ProxyVolume proxyVolume, ProxyVolumeUI s, Object sourceAsset)
         {
-            s.sphereProjectionHandle.center = proxyVolume.sphereOffset;
+            s.sphereProjectionHandle.center = Vector3.zero;
             s.sphereProjectionHandle.radius = proxyVolume.sphereRadius;
 
             var mat = Handles.matrix;
             {
                 Undo.RecordObject(sourceAsset, "Modified Projection Volume");
 
-                proxyVolume.sphereOffset = s.sphereProjectionHandle.center;
                 proxyVolume.sphereRadius = s.sphereProjectionHandle.radius;
 
                 EditorUtility.SetDirty(sourceAsset);
 
         static void Handles_EditBase_Box(Transform transform, ProxyVolume proxyVolume, ProxyVolumeUI s, Object sourceAsset)
         {
-            s.boxProjectionHandle.center = proxyVolume.boxOffset;
+            s.boxProjectionHandle.center = Vector3.zero;
             s.boxProjectionHandle.size = proxyVolume.boxSize;
 
             var mat = Handles.matrix;
             {
                 Undo.RecordObject(sourceAsset, "Modified Projection Volume AABB");
 
-                proxyVolume.boxOffset = s.boxProjectionHandle.center;
                 proxyVolume.boxSize = s.boxProjectionHandle.size;
 
                 EditorUtility.SetDirty(sourceAsset);
 
         public static void DrawGizmos_EditNone(Transform transform, ProxyVolume proxyVolume, ProxyVolumeUI ui, Object sourceAsset)
         {
-            switch (proxyVolume.shapeType)
+            switch (proxyVolume.shape)
-                case Shape.Box:
+                case ProxyShape.Box:
-                case Shape.Sphere:
+                case ProxyShape.Sphere:
                     Gizmos_EditNone_Sphere(transform, proxyVolume, ui, sourceAsset);
                     break;
             }
             Gizmos.matrix = t.localToWorldMatrix;
 
             Gizmos.color = k_GizmoThemeColorProjection;
-            Gizmos.DrawWireSphere(d.sphereOffset, d.sphereRadius);
+            Gizmos.DrawWireSphere(Vector3.zero, d.sphereRadius);
 
             Gizmos.matrix = mat;
         }
             Gizmos.matrix = t.localToWorldMatrix;
 
             Gizmos.color = k_GizmoThemeColorProjection;
-            Gizmos.DrawWireCube(d.boxOffset, d.boxSize);
+            Gizmos.DrawWireCube(Vector3.zero, d.boxSize);
 
             Gizmos.matrix = mat;
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/Volume/SerializedProxyVolume.cs

     {
         public SerializedProperty root;
 
-        public SerializedProperty shapeType;
+        public SerializedProperty shape;
-        public SerializedProperty boxOffset;
-        public SerializedProperty boxInfiniteProjection;
-        public SerializedProperty sphereOffset;
-        public SerializedProperty sphereInfiniteProjection;
-            shapeType = root.Find((ProxyVolume p) => p.shapeType);
+            shape = root.Find((ProxyVolume p) => p.shape);
-            boxOffset = root.Find((ProxyVolume p) => p.boxOffset);
-            boxInfiniteProjection = root.Find((ProxyVolume p) => p.boxInfiniteProjection);
-            sphereOffset = root.Find((ProxyVolume p) => p.sphereOffset);
-            sphereInfiniteProjection = root.Find((ProxyVolume p) => p.sphereInfiniteProjection);
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Decal/DecalUI.cs

             CoreUtils.SetKeyword(material, "_COLORMAP", material.GetTexture(kBaseColorMap));
             CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap));
             CoreUtils.SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap)); 
-            CoreUtils.SetKeyword(material, "_NORMAL_BLEND_SRC_B", material.GetFloat(kNormalBlendSrc) == 1.0f);
-            CoreUtils.SetKeyword(material, "_MASK_BLEND_SRC_B", material.GetFloat(kMaskBlendSrc) == 1.0f);
 
             material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMStr, false);
             material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsAOStr, false);

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.cs

                             }
 
                             LightVolumeType lightVolumeType = LightVolumeType.Box;
-                            if (additional != null && additional.influenceVolume.shape == Shape.Sphere)
+                            if (additional != null && additional.influenceVolume.shape == InfluenceShape.Sphere)
                                 lightVolumeType = LightVolumeType.Sphere;
                             ++envLightCount;
 
                                 continue;
 
                             var lightVolumeType = LightVolumeType.Box;
-                            if (probe.influenceVolume.shape == Shape.Sphere)
+                            if (probe.influenceVolume.shape == InfluenceShape.Sphere)
                                 lightVolumeType = LightVolumeType.Sphere;
                             ++envLightCount;
 

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/Lighting/Reflection/HDAdditionalReflectionData.cs

             UseInfluenceVolume,
             // Add new version here and they will automatically be the Current one
             Max,
-            Current = Max - 1            
+            Current = Max - 1
         }
 
         [SerializeField, FormerlySerializedAs("version")]
 #pragma warning disable 649 //never assigned
         //data only kept for migration, to be removed in future version
         [SerializeField, System.Obsolete("influenceShape is deprecated, use influenceVolume parameters instead")]
-        Shape influenceShape;
+        InfluenceShape influenceShape;
         [SerializeField, System.Obsolete("influenceSphereRadius is deprecated, use influenceVolume parameters instead")]
         float influenceSphereRadius = 3.0f;
         [SerializeField, System.Obsolete("blendDistancePositive is deprecated, use influenceVolume parameters instead")]
 
         void MigrateToUseInfluenceVolume()
         {
+            influenceVolume.boxSize = legacyProbe.size;
-            influenceVolume.shape = influenceShape;
+            influenceVolume.shape = influenceShape; //must be done after each size transfert
             influenceVolume.boxBlendDistancePositive = blendDistancePositive;
             influenceVolume.boxBlendDistanceNegative = blendDistanceNegative;
             influenceVolume.boxBlendNormalDistancePositive = blendNormalDistancePositive;

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/HDProbe.cs

             get { return m_RefreshMode; }
             set { m_RefreshMode = value; }
         }
-        
+
-                influenceVolume = new InfluenceVolume(this);
-            else
-                influenceVolume.Init(this);
+                influenceVolume = new InfluenceVolume();
+            influenceVolume.Init(this);
         }
 
         void ISerializationCallbackReceiver.OnBeforeSerialize()

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/PlanarReflectionProbe.cs

                     : influenceToWorld;
             }
         }
-        public Shape proxyShape
+        public ProxyShape proxyShape
-                    ? proxyVolume.proxyVolume.shapeType
-                    : influenceVolume.shape;
+                    ? proxyVolume.proxyVolume.shape
+                    : (ProxyShape)influenceVolume.shape;
             }
         }
         public Vector3 proxyExtents
                     : influenceVolume.boxSize;
             }
         }
-        public bool infiniteProjection { get { return proxyVolume != null && proxyVolume.proxyVolume.infiniteProjection; } }
+        public bool infiniteProjection
+        {
+            get
+            {
+                return proxyVolume != null
+                    && proxyVolume.proxyVolume.shape == ProxyShape.Infinite;
+            }
+        }
 
         public bool useMirrorPlane
         {

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/ProbeWrapper.cs

             throw new ArgumentException();
         }
 
-        protected static EnvShapeType ConvertShape(Shape shape)
+        protected static EnvShapeType ConvertShape(InfluenceShape shape)
-                case Shape.Box:
+                case InfluenceShape.Box:
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
+                    return EnvShapeType.Sphere;
+            }
+        }
+
+        protected static EnvShapeType ConvertShape(ProxyShape shape)
+        {
+            switch (shape)
+            {
+                case ProxyShape.Box:
+                    return EnvShapeType.Box;
+                default:
+                case ProxyShape.Infinite:
+                case ProxyShape.Sphere:
                     return EnvShapeType.Sphere;
             }
         }
                 add = HDUtils.s_DefaultHDAdditionalReflectionData;
                 if (add.influenceVolume == null)
                 {
-                    add.Awake();
+                    add.Awake(); // We need to init the 'default' data if it isn't
-                add.influenceVolume.shape= Shape.Box;
+                add.influenceVolume.shape= InfluenceShape.Box;
             }
             return add;
         }
                 switch (additional.influenceVolume.shape)
                 {
                     default:
-                    case Shape.Box:
+                    case InfluenceShape.Box:
-                    case Shape.Sphere:
+                    case InfluenceShape.Sphere:
                         return Vector3.one * additional.influenceVolume.sphereRadius;
                 }
             }
             get
             {
                 return additional.proxyVolume != null
-                    ? ConvertShape(additional.proxyVolume.proxyVolume.shapeType)
+                    ? ConvertShape(additional.proxyVolume.proxyVolume.shape)
                     : influenceShapeType;
             }
         }
             get
             {
                 return additional.proxyVolume != null
-                    ? additional.proxyVolume.proxyVolume.infiniteProjection
+                    ? additional.proxyVolume.proxyVolume.shape == ProxyShape.Infinite
                     : probe.boxProjection == 0;
             }
         }
                 switch (planarReflectionProbe.influenceVolume.shape)
                 {
                     default:
-                    case Shape.Box:
+                    case InfluenceShape.Box:
-                    case Shape.Sphere:
+                    case InfluenceShape.Sphere:
                         return planarReflectionProbe.influenceVolume.sphereRadius * Vector3.one;
                 }
             }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/InfluenceVolume.cs

         HDProbe probe;
 
         [SerializeField, FormerlySerializedAs("m_ShapeType")]
-        Shape m_Shape = Shape.Box;
+        InfluenceShape m_Shape = InfluenceShape.Box;
         [SerializeField, FormerlySerializedAs("m_BoxBaseOffset")]
         Vector3 m_Offset;
 #pragma warning disable 649 //never assigned
         float m_SphereBlendNormalDistance;
 
         /// <summary>Shape of this InfluenceVolume.</summary>
-        public Shape shape
+        public InfluenceShape shape
         {
             get { return m_Shape; }
             set
                 {
-                    case Shape.Box:
+                    case InfluenceShape.Box:
-                    case Shape.Sphere:
+                    case InfluenceShape.Sphere:
                         probe.UpdatedInfluenceVolumeShape(Vector3.one * (2 * m_SphereRadius), offset);
                         break;
                 }
         /// Value between 0 (on InfluenceVolume hull) and sphereRadius (fade sub volume reduced to a point).
         /// </summary>
         public float sphereBlendNormalDistance { get { return m_SphereBlendNormalDistance; } set { m_SphereBlendNormalDistance = value; } }
-
-        internal InfluenceVolume(HDProbe probe)
-        {
-            Init(probe);
-        }
-
+        
         internal void Init(HDProbe probe)
         {
             this.probe = probe;
             switch (shape)
             {
                 default:
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
-                case Shape.Box:
+                case InfluenceShape.Box:
                 {
                     var position = probeTransform.TransformPoint(offset);
                     var radius = Mathf.Max(boxSize.x, Mathf.Max(boxSize.y, boxSize.z));
             switch (shape)
             {
                 default:
-                case Shape.Sphere:
+                case InfluenceShape.Sphere:
-                case Shape.Box:
+                case InfluenceShape.Box:
                 {
                     var position = probeTransform.TransformPoint(offset);
                     return new Bounds(position, boxSize);
 
         internal void MigrateOffsetSphere()
         {
-            if (shape == Shape.Sphere)
+            if (shape == InfluenceShape.Sphere)
             {
 #pragma warning disable CS0618 // Type or member is obsolete
                 m_Offset = m_SphereBaseOffset;

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/ProxyVolume.cs

 using System;
+using UnityEngine.Serialization;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-        [SerializeField]
-        Shape m_ShapeType = Shape.Box;
+        [SerializeField, FormerlySerializedAs("m_ShapeType")]
+        ProxyShape m_Shape = ProxyShape.Box;
-        [SerializeField]
-        Vector3 m_BoxOffset;
-        [SerializeField]
+        [SerializeField, Obsolete("Kept only for compatibility. Use m_Shape instead")]
-        [SerializeField]
-        Vector3 m_SphereOffset;
-        [SerializeField]
+        [SerializeField, Obsolete("Kept only for compatibility. Use m_Shape instead")]
-
-        public Shape shapeType { get { return m_ShapeType; } }
+        /// <summary>The shape of the proxy</summary>
+        public ProxyShape shape { get { return m_Shape; } private set { m_Shape = value; } }
+        /// <summary>The size of the proxy if it as a shape Box</summary>
-        public Vector3 boxOffset { get { return m_BoxOffset; } set { m_BoxOffset = value; } }
-        public bool boxInfiniteProjection { get { return m_BoxInfiniteProjection; } }
+        /// <summary>The radius of the proxy if it as a shape Sphere</summary>
-        public Vector3 sphereOffset { get { return m_SphereOffset; } set { m_SphereOffset = value; } }
-        public bool sphereInfiniteProjection { get { return m_SphereInfiniteProjection; } }
-        public Vector3 extents
+
+        internal Vector3 extents
-                switch (shapeType)
+                switch (shape)
-                    case Shape.Box: return m_BoxSize * 0.5f;
-                    case Shape.Sphere: return Vector3.one * m_SphereRadius;
+                    case ProxyShape.Box: return m_BoxSize * 0.5f;
+                    case ProxyShape.Sphere: return Vector3.one * m_SphereRadius;
-        public bool infiniteProjection
+        internal void MigrateInfiniteProhjectionInShape()
-            get
+#pragma warning disable CS0618 // Type or member is obsolete
+            if (shape == ProxyShape.Sphere && m_SphereInfiniteProjection
+                || shape == ProxyShape.Box && m_BoxInfiniteProjection)
+#pragma warning restore CS0618 // Type or member is obsolete
-                return shapeType == Shape.Box && boxInfiniteProjection
-                    || shapeType == Shape.Sphere && sphereInfiniteProjection;
+                shape = ProxyShape.Infinite;
             }
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/ReflectionProxyVolumeComponent.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    public class ReflectionProxyVolumeComponent : MonoBehaviour
+    public class ReflectionProxyVolumeComponent : MonoBehaviour, ISerializationCallbackReceiver
+        enum Version
+        {
+            First,
+            IncludeInfiniteInShape,
+            // Add new version here and they will automatically be the Current one
+            Max,
+            Current = Max - 1
+        }
+
+        [SerializeField]
+        int m_Version;
+
+        /// <summary>Access to proxy volume parameters</summary>
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            if (m_Version != (int)Version.Current)
+            {
+                // Add here data migration code
+                if (m_Version < (int)Version.IncludeInfiniteInShape)
+                {
+                    proxyVolume.MigrateInfiniteProhjectionInShape();
+                }
+                m_Version = (int)Version.Current;
+            }
+        }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/ShapeType.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    public enum Shape
+    public enum InfluenceShape
+    {
+        Box,
+        Sphere,
+    }
+
+    public enum ProxyShape
+        Infinite
     }
 }

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/Decal.shader

     #pragma shader_feature _MASKMAP
 	#pragma shader_feature _ALBEDOCONTRIBUTION
 
-	#pragma shader_feature _NORMAL_BLEND_SRC_B
-	#pragma shader_feature _MASK_BLEND_SRC_B
-
     #pragma multi_compile_instancing
     // No need to teset for DECALS_3RT we are in decal shader, so there is no OFF state
 	#pragma multi_compile _ DECALS_4RT

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)
 	surfaceData.baseColor.w = 0;	// dont blend any albedo
 #endif
 
-	float maskMapBlend;
+    // Default to _DecalBlend, if we use _NormalBlendSrc as maskmap and there is no maskmap, it mean we have 1
+	float maskMapBlend = _DecalBlend;
+
-	maskMapBlend = surfaceData.mask.z * _DecalBlend;	// store before overwriting with smoothness
+	maskMapBlend *= surfaceData.mask.z;	// store before overwriting with smoothness
-#if _MASK_BLEND_SRC_B
-	surfaceData.mask.w = maskMapBlend;
-#else
-    surfaceData.mask.w = albedoMapBlend;
-#endif
+	surfaceData.mask.w = _MaskBlendSrc ? maskMapBlend : albedoMapBlend;
 #endif
 
 	// needs to be after mask, because blend source could be in the mask map blue
 	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));
-#if _NORMAL_BLEND_SRC_B
-	surfaceData.normalWS.w = maskMapBlend;
-#else
-	surfaceData.normalWS.w = albedoMapBlend;
-#endif	
+	surfaceData.normalWS.w = _NormalBlendSrc ? maskMapBlend : albedoMapBlend;
 #endif
 	surfaceData.MAOSBlend.xy = float2(surfaceData.mask.w, surfaceData.mask.w);
 }

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

 TEXTURE2D(_MaskMap);
 SAMPLER(sampler_MaskMap);
 
+float _NormalBlendSrc;
+float _MaskBlendSrc;
 float _DecalBlend;
 float4 _BaseColor;
 float _DecalMeshDepthBias;

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;
 }
 
 //-----------------------------------------------------------------------------
     lighting.indirect.specularReflected *= _IndirectLightingMultiplier.y;
 
     // 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
     lighting.indirect.specularReflected *= _IndirectLightingMultiplier.y;
 
     // 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

com.unity.render-pipelines.high-definition/package.json

     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
     "version": "3.0.1-preview",
-    "unity": "2018.2",
+    "unity": "2018.3",
     "displayName": "HD Render Pipeline",
     "dependencies": {
         "com.unity.postprocessing": "2.0.9-preview",

com.unity.render-pipelines.lightweight/package.json

     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
     "version": "3.0.1-preview",
-    "unity": "2018.2",
+    "unity": "2018.3",
     "displayName": "Lightweight Render Pipeline",
     "dependencies": {
         "com.unity.postprocessing": "2.0.9-preview",

com.unity.shadergraph/CHANGELOG.md

 - If the current render pipeline is not compatible, master nodes now display an error badge.
 - The preview shader now only considers the current render pipeline. Because of this there is less code to compile, and therefore the preview shader will compile faster.
 - When you rename a shader graph or sub shader graph locally on your disk, the title of the Shader Graph window, black board, and preview also updates.
+- Removed legacy matrices from Transfomation Matrix node.
 - The Lightweight PBR subshader now normalizes normal, tangent, and view direction correctly.
 - Texture 2D Array and Texture 3D nodes can no longer be used in the vertex shader.
 - Shader graphs using alpha clip now generate correct depth and shadow passes.

com.unity.shadergraph/Editor/Data/Nodes/Input/Matrix/TransformationMatrixNode.cs

 {
     public enum TransformationMatrixType
     {
+        None = -1,
         ModelView,
         View,
         Projection,
         WorldToObject
     };
 
+    public enum UnityMatrixType
+    {
+        Model,
+        InverseModel,
+        View,
+        InverseView,
+        Projection,
+        InverseProjection,
+        ViewProjection,
+        InverseViewProjection
+    }
+
-        static Dictionary<TransformationMatrixType, string> m_matrixList = new Dictionary<TransformationMatrixType, string>
+        static Dictionary<UnityMatrixType, string> m_MatrixList = new Dictionary<UnityMatrixType, string>
-            {TransformationMatrixType.ModelView, "UNITY_MATRIX_MV"},
-            {TransformationMatrixType.View, "UNITY_MATRIX_V"},
-            {TransformationMatrixType.Projection, "UNITY_MATRIX_P"},
-            {TransformationMatrixType.ViewProjection, "UNITY_MATRIX_VP"},
-            {TransformationMatrixType.TransposeModelView, "UNITY_MATRIX_T_MV"},
-            {TransformationMatrixType.InverseTransposeModelView, "UNITY_MATRIX_IT_MV"},
-            {TransformationMatrixType.ObjectToWorld, "UNITY_MATRIX_M"},
-            {TransformationMatrixType.WorldToObject, "UNITY_MATRIX_I_M"},
+            {UnityMatrixType.Model, "UNITY_MATRIX_M"},
+            {UnityMatrixType.InverseModel, "UNITY_MATRIX_I_M"},
+            {UnityMatrixType.View, "UNITY_MATRIX_V"},
+            {UnityMatrixType.InverseView, "UNITY_MATRIX_I_V"},
+            {UnityMatrixType.Projection, "UNITY_MATRIX_P"},
+            {UnityMatrixType.InverseProjection, "UNITY_MATRIX_I_P"},
+            {UnityMatrixType.ViewProjection, "UNITY_MATRIX_VP"},
+            {UnityMatrixType.InverseViewProjection, "UNITY_MATRIX_I_VP"},
+        };
+        
+        static Dictionary<TransformationMatrixType, UnityMatrixType> m_MatrixUpgrade = new Dictionary<TransformationMatrixType, UnityMatrixType>
+        {
+            {TransformationMatrixType.ModelView, UnityMatrixType.Model},
+            {TransformationMatrixType.View, UnityMatrixType.View},
+            {TransformationMatrixType.Projection, UnityMatrixType.Projection},
+            {TransformationMatrixType.ViewProjection, UnityMatrixType.ViewProjection},
+            {TransformationMatrixType.TransposeModelView, UnityMatrixType.Model},
+            {TransformationMatrixType.InverseTransposeModelView, UnityMatrixType.Model},
+            {TransformationMatrixType.ObjectToWorld, UnityMatrixType.Model},
+            {TransformationMatrixType.WorldToObject, UnityMatrixType.InverseModel},
+        [SerializeField]
+        private UnityMatrixType m_MatrixType = UnityMatrixType.Model;
+
         private const int kOutputSlotId = 0;
         private const string kOutputSlotName = "Out";
 
-        public TransformationMatrixType matrix
+        public UnityMatrixType matrixType
-            get { return m_matrix; }
+            get { return m_MatrixType; }
-                if (m_matrix == value)
+                if (m_MatrixType == value)
-                m_matrix = value;
+                m_MatrixType = value;
                 Dirty(ModificationScope.Graph);
             }
         }
 
         public sealed override void UpdateNodeAfterDeserialization()
         {
+            if(m_matrix != TransformationMatrixType.None)
+            {
+                m_MatrixType = m_MatrixUpgrade[m_matrix];
+                m_matrix = TransformationMatrixType.None;
+            }
+
             AddSlot(new Matrix4MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output));
             RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
         }
-            return m_matrixList[matrix].ToString(CultureInfo.InvariantCulture);
+            return m_MatrixList[matrixType].ToString(CultureInfo.InvariantCulture);
         }
 
         public bool RequiresVertexColor()

com.unity.shadergraph/Editor/Data/Nodes/Input/Scene/CameraNode.cs

             switch (slotId)
             {
                 case OutputSlot1Id:
-                    return "-1 * mul(unity_ObjectToWorld, UNITY_MATRIX_IT_MV [2].xyz)";
+                    return "-1 * mul(unity_ObjectToWorld, transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V)) [2].xyz)";
                 case OutputSlot2Id:
                     return "unity_OrthoParams.w";
                 case OutputSlot3Id:

com.unity.shadergraph/Editor/Data/Util/MatrixNames.cs

         public const string View = "UNITY_MATRIX_V";
         public const string ViewInverse = "UNITY_MATRIX_I_V";
         public const string Projection = "UNITY_MATRIX_P";
+        public const string ProjectionInverse = "UNITY_MATRIX_I_P";
-        public const string ModelView = "UNITY_MATRIX_MV";
-        public const string ModelViewTransposed = "UNITY_MATRIX_T_MV";
-        public const string ModelViewInverseTransposed = "UNITY_MATRIX_IT_MV";
-        public const string ModelViewProjection = "UNITY_MATRIX_MVP";
+        public const string ViewProjectionInverse = "UNITY_MATRIX_I_VP";
     }
 }

com.unity.shadergraph/package.json

     "name": "com.unity.shadergraph",
     "description": "Shader Graph",
     "version": "3.0.1-preview",
-    "unity": "2018.2",
+    "unity": "2018.3",
     "displayName": "Shader Graph",
     "dependencies": {
     }

com.unity.testframework.graphics/package.json

 	"name": "com.unity.testframework.graphics",
 	"displayName":"Graphics Tests Framework",
 	"version": "3.0.1-preview",
-	"unity": "2018.2",
+	"unity": "2018.3",
 	"description": "Provides test framework helpers for writing tests for graphics code, such as image comparison assertions and automatic management of reference images.",
 	"keywords": ["qa", "test", "testing", "tests", "graphics"],
 	"dependencies": {