Merge pull request #1713 from Unity-Technologies/HDRP/staging

Merge Hdrp/staging

com.unity.render-pipelines.core/CoreRP/Editor/Debugging/DebugWindow.cs

             s_TypeMapDirty = false;
         }
 
-        [MenuItem("Window/General/Render Pipeline Debug", priority = 112)] // 112 is hardcoded number given by the UxTeam to fit correctly in the Windows menu
+        [MenuItem("Window/Analysis/Render Pipeline Debug", priority = 112)] // 112 is hardcoded number given by the UxTeam to fit correctly in the Windows menu
         static void Init()
         {
             var window = GetWindow<DebugWindow>();

com.unity.render-pipelines.core/CoreRP/Shadow/AdditionalShadowData.cs

     [RequireComponent(typeof(Light))]
     public class AdditionalShadowData : MonoBehaviour
     {
-        [HideInInspector]
-        public float version = 1.0f;
+// Currently m_Version is not used and produce a warning, remove these pragmas at the next version incrementation
+#pragma warning disable 414
+        [SerializeField]
+        [UnityEngine.Serialization.FormerlySerializedAs("version")]
+        private int m_Version = 1;
+#pragma warning restore 414
 
         public const int DefaultShadowResolution = 512;
 

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

 
 ## [3.0.1-preview]
 
+### Added
+- Decal now support per channel selection mask. There is now two mode. One with BaseColor, Normal and Smoothness and another one more expensive with BaseColor, Normal, Smoothness, Metal and AO. Control is on HDRP Asset. This may require to launch an update script for old scene: 'Edit/Render Pipeline/Single step upgrade script/Upgrade all DecalMaterial MaskBlendMode'.
+
+- 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.
+
+### Changed
+- Movde Render Pipeline Debug "Windows from Windows->General-> Render Pipeline debug windows" to "Windows from Windows->Analysis-> Render Pipeline debug windows"
 
 ### 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/Camera/HDAdditionalCameraData.cs

     public class HDAdditionalCameraData : MonoBehaviour, ISerializationCallbackReceiver
     {
         [HideInInspector]
-        public float version = 1.0f;
+        const int currentVersion = 1;
+
+        [SerializeField, FormerlySerializedAs("version")]
+        int m_Version;
 
         // The light culling use standard projection matrices (non-oblique)
         // If the user overrides the projection matrix with an oblique one
             // When FrameSettings are manipulated or RenderPath change we reset them to reflect the change, discarding all the Debug Windows change.
             // Tag as dirty so frameSettings are correctly initialize at next HDRenderPipeline.Render() call
             m_frameSettingsIsDirty = true;
+
+            if(m_Version != currentVersion)
+            {
+                // Add here data migration code
+                m_Version = currentVersion;
+            }
         }
 
         // This is called at the creation of the HD Additional Camera Data, to convert the legacy camera settings to HD

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

                     if (hdLightData != null)
                         hdLightData.UpdateAreaLightEmissiveMesh();
             };
+            
+            // If the light is disabled in the editor we force the light upgrade from his inspector
+            foreach (var additionalLightData in m_AdditionalLightDatas)
+                additionalLightData.UpgradeLight();
         }
 
         public override void OnInspectorGUI()
 
             if (m_UpdateAreaLightEmissiveMeshComponents)
                 UpdateAreaLightEmissiveMeshComponents();
-            
-            // If the light is disabled in the editor we force the light upgrade from his inspector
-            foreach (var additionalLightData in m_AdditionalLightDatas)
-                additionalLightData.UpgradeLight();
         }
 
         void DrawFoldout(SerializedProperty foldoutProperty, string title, Action func)
 
             if (EditorGUI.EndChangeCheck())
             {
-                UpdateLightScale();
                 m_UpdateAreaLightEmissiveMeshComponents = true;
                 ((Light)target).SetLightDirty(); // Should be apply only to parameter that's affect GI, but make the code cleaner
             }
                 m_AdditionalLightData.lightUnit.enumValueIndex = (int)DirectionalLightUnit.Lux;
             else
                 m_AdditionalLightData.lightUnit.enumValueIndex = (int)LightUnit.Lumen;
-        }
-
-        // Refect light size changes on transform local scale
-        void UpdateLightScale()
-        {
-            foreach (var hdLightData in m_AdditionalLightDatas)
-            {
-                switch (m_LightShape)
-                {
-                    case LightShape.Line:
-                        hdLightData.transform.localScale = new Vector3(m_AdditionalLightData.shapeWidth.floatValue, 0, 0);
-                        break;
-                    case LightShape.Rectangle:
-                        hdLightData.transform.localScale = new Vector3(m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue, 0);
-                        break;
-                    case LightShape.Point:
-                    case LightShape.Spot:
-                        hdLightData.transform.localScale = Vector3.one * settings.range.floatValue;
-                        break;
-                }
-            }
         }
 
         LightUnit LightIntensityUnitPopup(LightShape shape)

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

 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEngine.Rendering;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
         {
             public static string InputsText = "Inputs";
 
-            public static GUIContent baseColorText = new GUIContent("Albedo (RGB) and Blend Factor (A)", "Albedo (RGB) and Blend Factor (A)");
-            public static GUIContent baseColorText2 = new GUIContent("Blend Factor (A)", "Blend Factor (A)");
+            public static GUIContent baseColorText = new GUIContent("BaseColor (RGB) and Opacity (A)", "BaseColor (RGB) and Opacity (A)");
+            public static GUIContent baseColorText2 = new GUIContent("Opacity(A)", "Opacity (A)");
-            public static GUIContent maskMapText = new GUIContent("Mask Map - M(R), AO(G), D(B), S(A)", "Mask map");
-            public static GUIContent decalBlendText = new GUIContent("Decal Blend", "Whole decal blend");
-            public static GUIContent BlendText = new GUIContent("Decal Blend", "Whole decal blend");
-            public static GUIContent AlbedoModeText = new GUIContent("Albedo contribution", "Base color + Blend, Blend only");
+            public static GUIContent decalBlendText = new GUIContent("Global Opacity", "Whole decal Opacity");
+            public static GUIContent AlbedoModeText = new GUIContent("Affect BaseColor", "Base color + Opacity, Opacity only");
+
+            public static GUIContent[] maskMapText =
+            {
+                new GUIContent("Error", "Mask map"), // Not possible
+                new GUIContent("Mask Map - M(R), Opacity(B)", "Mask map - Metal(R), Opacity(B)"), // Decal.MaskBlendFlags.Metal:
+                new GUIContent("Mask Map - AO(G), Opacity(B)", "Mask map - Ambient Occlusion(G), Opacity(B)"), // Decal.MaskBlendFlags.AO:
+                new GUIContent("Mask Map - M(R), AO(G), Opacity(B)", "Mask map - Metal(R), Ambient Occlusion(G), Opacity(B)"), // Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.AO:
+                new GUIContent("Mask Map - Opacity(B), S(A)", "Mask map - Opacity(B), Smoothness(A)"), // Decal.MaskBlendFlags.Smoothness:
+                new GUIContent("Mask Map - M(R), Opacity(B), S(A)", "Mask map - Metal(R), Opacity(B), Smoothness(A)"), // Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.Smoothness:
+                new GUIContent("Mask Map - AO(G), Opacity(B), S(A)", "Mask map - Ambient Occlusion(G), Opacity(B), Smoothness(A)"), // Decal.MaskBlendFlags.AO | Decal.MaskBlendFlags.Smoothness:
+                new GUIContent("Mask Map - M(R), AO(G), Opacity(B), S(A)", "Mask map - Metal(R), Ambient Occlusion(G), Opacity(B), Smoothness(A)") // Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.AO | Decal.MaskBlendFlags.Smoothness:
+            };
+        }
+
+        enum BlendSource
+        {
+            BaseColorMapAlpha,
+            MaskMapBlue
+        protected string[] blendSourceNames = Enum.GetNames(typeof(BlendSource));
+
+        protected string[] blendModeNames = Enum.GetNames(typeof(BlendMode));
 
         protected MaterialProperty baseColorMap = new MaterialProperty();
         protected const string kBaseColorMap = "_BaseColorMap";
         protected MaterialProperty albedoMode = new MaterialProperty();
         protected const string kAlbedoMode = "_AlbedoMode";
 
+        protected MaterialProperty normalBlendSrc = new MaterialProperty();
+        protected const string kNormalBlendSrc = "_NormalBlendSrc";
+
+        protected MaterialProperty maskBlendSrc = new MaterialProperty();
+        protected const string kMaskBlendSrc = "_MaskBlendSrc";
+
+        protected MaterialProperty maskBlendMode = new MaterialProperty();
+        protected const string kMaskBlendMode = "_MaskBlendMode";
+
+        protected MaterialProperty maskmapMetal = new MaterialProperty();
+        protected const string kMaskmapMetal = "_MaskmapMetal";
+
+        protected MaterialProperty maskmapAO = new MaterialProperty();
+        protected const string kMaskmapAO = "_MaskmapAO";
+
+        protected MaterialProperty maskmapSmoothness = new MaterialProperty();
+        protected const string kMaskmapSmoothness = "_MaskmapSmoothness";
 
         protected MaterialEditor m_MaterialEditor;
 
             maskMap = FindProperty(kMaskMap, props);
             decalBlend = FindProperty(kDecalBlend, props);
             albedoMode = FindProperty(kAlbedoMode, props);
+            normalBlendSrc = FindProperty(kNormalBlendSrc, props);
+            maskBlendSrc = FindProperty(kMaskBlendSrc, props);
+            maskBlendMode = FindProperty(kMaskBlendMode, props);
+            maskmapMetal = FindProperty(kMaskmapMetal, props);
+            maskmapAO = FindProperty(kMaskmapAO, props);
+            maskmapSmoothness = FindProperty(kMaskmapSmoothness, props);
+            
             // always instanced
             SerializedProperty instancing = m_MaterialEditor.serializedObject.FindProperty("m_EnableInstancingVariants");
             instancing.boolValue = true;
         static public void SetupMaterialKeywordsAndPass(Material material)
         {
+            Decal.MaskBlendFlags blendMode = (Decal.MaskBlendFlags)material.GetFloat(kMaskBlendMode);
+
-            CoreUtils.SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
+            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);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMAOStr, false);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsSStr, false);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMSStr, false);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsAOSStr, false);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMAOSStr, false);
+            material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecals3RTStr, true);
+            switch (blendMode)
+            {
+                case Decal.MaskBlendFlags.Metal:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.AO:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsAOStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.AO:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMAOStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.Smoothness:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsSStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.Smoothness:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMSStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.AO | Decal.MaskBlendFlags.Smoothness:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsAOSStr, true);
+                    break;
+
+                case Decal.MaskBlendFlags.Metal | Decal.MaskBlendFlags.AO | Decal.MaskBlendFlags.Smoothness:
+                    material.SetShaderPassEnabled(HDShaderPassNames.s_MeshDecalsMAOSStr, true);
+                    break;
+            }
         }
 
         protected void SetupMaterialKeywordsAndPassInternal(Material material)
         {
             // Use default labelWidth
             EditorGUIUtility.labelWidth = 0f;
+            float normalBlendSrcValue = normalBlendSrc.floatValue;
+            float maskBlendSrcValue =  maskBlendSrc.floatValue;
+
+            Decal.MaskBlendFlags maskBlendFlags = (Decal.MaskBlendFlags)maskBlendMode.floatValue;              
+
+            HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+            bool perChannelMask = hdrp.renderPipelineSettings.decalSettings.perChannelMask;
 
             // Detect any changes to the material
             EditorGUI.BeginChangeCheck();
                 EditorGUI.indentLevel++;
-                m_MaterialEditor.ShaderProperty(albedoMode, Styles.AlbedoModeText);
-                if (material.GetFloat(kAlbedoMode) == 1.0f)
+
+                m_MaterialEditor.TexturePropertySingleLine((material.GetFloat(kAlbedoMode) == 1.0f) ? Styles.baseColorText : Styles.baseColorText2, baseColorMap, baseColor);
+                if (material.GetTexture(kBaseColorMap))
-                    m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor);                    
+                    EditorGUI.indentLevel++;
+                    m_MaterialEditor.ShaderProperty(albedoMode, Styles.AlbedoModeText);
+                    EditorGUI.indentLevel--;
+                }
+
+                m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap);
+                if (material.GetTexture(kNormalMap))
+                {
+                    EditorGUI.indentLevel++;
+                    normalBlendSrcValue = EditorGUILayout.Popup("Normal Opacity channel", (int)normalBlendSrcValue, blendSourceNames);
+                    EditorGUI.indentLevel--;
-                else
+
+                m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapText[(int)maskBlendFlags], maskMap);
+                if (material.GetTexture(kMaskMap))
-                    m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText2, baseColorMap, baseColor);                    
+                    EditorGUI.indentLevel++;
+                    maskBlendSrcValue = EditorGUILayout.Popup("Mask Opacity channel", (int) maskBlendSrcValue, blendSourceNames);
+                    if (perChannelMask)
+                    {
+                        // Following condition force users to always have at least one attribute enabled
+                        m_MaterialEditor.ShaderProperty(maskmapMetal, "Affect Metal");
+                        if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f))
+                            maskmapMetal.floatValue = 1.0f;
+                        m_MaterialEditor.ShaderProperty(maskmapAO, "Affect AO");
+                        if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f))
+                            maskmapAO.floatValue = 1.0f;
+                        m_MaterialEditor.ShaderProperty(maskmapSmoothness, "Affect Smoothness");
+                        if ((maskmapMetal.floatValue == 0.0f) && (maskmapAO.floatValue == 0.0f) && (maskmapSmoothness.floatValue == 0.0f))
+                            maskmapSmoothness.floatValue = 1.0f;
+
+                        if (maskmapMetal.floatValue == 1.0f)
+                            maskBlendFlags |= Decal.MaskBlendFlags.Metal;
+                        if (maskmapAO.floatValue == 1.0f)
+                            maskBlendFlags |= Decal.MaskBlendFlags.AO;
+                        if (maskmapSmoothness.floatValue == 1.0f)
+                            maskBlendFlags |= Decal.MaskBlendFlags.Smoothness;
+                    }
+                    EditorGUI.indentLevel--;
-                m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap);
-                m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapText, maskMap);
+
+                EditorGUILayout.HelpBox(
+                    "Control of AO and Metal is based on option 'Enable Metal and AO properties' in HDRP Asset.\nThere is a performance cost of enabling this option.",
+                    MessageType.Info);
+                normalBlendSrc.floatValue = normalBlendSrcValue;
+                maskBlendSrc.floatValue = maskBlendSrcValue;
+                maskBlendMode.floatValue = (float) maskBlendFlags;
                 foreach (var obj in m_MaterialEditor.targets)
                     SetupMaterialKeywordsAndPassInternal((Material)obj);
             }

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/Settings/GlobalDecalSettingsUI.cs

             EditorGUILayout.PropertyField(d.drawDistance, _.GetContent("Draw Distance"));
             EditorGUILayout.PropertyField(d.atlasWidth, _.GetContent("Atlas Width"));
             EditorGUILayout.PropertyField(d.atlasHeight, _.GetContent("Atlas Height"));
+            EditorGUILayout.PropertyField(d.perChannelMask, _.GetContent("Enable Metal and AO properties"));
             --EditorGUI.indentLevel;
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/Settings/SerializedGlobalDecalSettings.cs

         public SerializedProperty drawDistance;
         public SerializedProperty atlasWidth;
         public SerializedProperty atlasHeight;
+        public SerializedProperty perChannelMask;
 
         public SerializedGlobalDecalSettings(SerializedProperty root)
         {
             atlasWidth = root.Find((GlobalDecalSettings s) => s.atlasWidth);
             atlasHeight = root.Find((GlobalDecalSettings s) => s.atlasHeight);
+            perChannelMask = root.Find((GlobalDecalSettings s) => s.perChannelMask);
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/Upgraders/HDRPVersion.cs

     [InitializeOnLoad]
     public class HDRPVersion
     {
-        static public int hdrpVersion = 1;
+        // 1 changed emissive color
+        // 2 add decal mode in decal material
+        static public int hdrpVersion = 2;
 
         static public int GetCurrentHDRPProjectVersion()
         {
         static HDRPVersion()
         {
             // Compare project version with current version - Trigger an upgrade if user ask for it
-            if (GetCurrentHDRPProjectVersion() < hdrpVersion)
+            if (false) //GetCurrentHDRPProjectVersion() < hdrpVersion) // TODO: Disable for now as it doesn't work correctly
             {
                 if (EditorUtility.DisplayDialog("A newer version of HDRP has been detected",
                                                 "Do you want to upgrade your materials to newer version?\n You can also upgrade manually materials in 'Edit -> Render Pipeline' submenu", "Yes", "No"))

com.unity.render-pipelines.high-definition/HDRP/Editor/Upgraders/UpgradeMenuItem.cs

             return;
         }
 
+        // Update decal material after we added AO and metal selection. It was default to 0 and need to default to 4 now.
+        static bool UpdateMaterial_DecalBlendMode(string path, Material mat)
+        {
+            if (mat.shader.name == "HDRenderPipeline/Decal")
+            {
+                float maskBlendMode = mat.GetFloat("_MaskBlendMode");
+
+                if (maskBlendMode == 0.0f)
+                {
+                    mat.SetFloat("_MaskBlendMode", 4.0f);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         delegate bool UpdateMaterial(string path, Material mat);
         delegate void UpdateMaterialFile(string path);
 
                         mat.shader.name == "HDRenderPipeline/LayeredLit" ||
                         mat.shader.name == "HDRenderPipeline/LayeredLitTessellation" ||
                         mat.shader.name == "HDRenderPipeline/StackLit" ||
-                        mat.shader.name == "HDRenderPipeline/Unlit"
+                        mat.shader.name == "HDRenderPipeline/Unlit" ||
+                        mat.shader.name == "HDRenderPipeline/Decal"
                          )
                     {
                         // Need to be processed in order - All function here should be re-entrant (i.e after upgrade it can be recall)
             UpdateMaterialToNewerVersion("(EmissiveColor)", UpdateMaterial_EmissiveColor, UpdateMaterialFile_EmissiveColor);
         }
 
+        [MenuItem("Edit/Render Pipeline/Single step upgrade script/Upgrade all DecalMaterial MaskBlendMode", priority = CoreUtils.editMenuPriority3)]
+        static public void UpdateMaterialToNewerVersionDecalMaterialMaskBlendMode()
+        {
+            UpdateMaterialToNewerVersion("(DecalMaterial)", UpdateMaterial_DecalBlendMode);
+        }
+
         [MenuItem("Edit/Render Pipeline/Upgrade all Materials to latest version", priority = CoreUtils.editMenuPriority3)]
         static public void UpdateMaterialToNewerVersion()
         {
-            float currentVersion = HDRPVersion.GetCurrentHDRPProjectVersion();
-            if (currentVersion < 1.0)
+            int currentVersion = HDRPVersion.GetCurrentHDRPProjectVersion();
+            if (currentVersion < 1)
+            }
+            if (currentVersion < 2)
+            {
+                // Appear in hdrp version 2.0
+                UpdateMaterialToNewerVersion("(DecalMaterial)", UpdateMaterial_DecalBlendMode);
             }
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Lighting/Light/HDAdditionalLightData.cs

     [ExecuteInEditMode]
     public class HDAdditionalLightData : MonoBehaviour, ISerializationCallbackReceiver
     {
-        public const float currentVersion = 1.1f;
+        private const int currentVersion = 2;
-        [HideInInspector]
+        [HideInInspector, SerializeField]
-        public float version = currentVersion;
+        [System.Obsolete("version is deprecated, use m_Version instead")]
+        private float version = currentVersion;
+// Currently m_Version is not used and produce a warning, remove these pragmas at the next version incrementation
+#pragma warning disable 414
+        [SerializeField]
+        private int m_Version = currentVersion;
+#pragma warning restore 414
 
         // To be able to have correct default values for our lights and to also control the conversion of intensity from the light editor (so it is compatible with GI)
         // we add intensity (for each type of light we want to manage).
 
         public void OnAfterDeserialize()
         {
-            // If we are deserializing an old version, convert the light intensity to the new system
+            // Note: the field version is deprecated but we keep it for retro-compatibility reasons, you should use m_Version instead
+#pragma warning disable 0618
+#pragma warning restore 0618
             {
                 // Note: We can't access to the light component in OnAfterSerialize as it is not init() yet,
                 // so instead we use a boolean to do the upgrade in OnEnable().
 
         public void UpgradeLight()
         {
+// Disable the warning generated by deprecated fields (areaIntensity, directionalIntensity, ...)
+#pragma warning disable 0618
+
+            // If we are deserializing an old version, convert the light intensity to the new system
-// Pragma to disable the warning got by using deprecated properties (areaIntensity, directionalIntensity, ...)
-#pragma warning disable 0618
                 switch (lightTypeExtent)
                 {
                     case LightTypeExtent.Punctual:
                         intensity = areaIntensity;
                         break;
                 }
-#pragma warning restore 0618
+                needsIntensityUpdate_1_0 = false;
+            m_Version = currentVersion;
+            
+#pragma warning restore 0618
         }
     }
 }

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

 #include "LightLoop.cs.hlsl"
-#include "../../Sky/SkyVariables.hlsl"
-
-StructuredBuffer<uint> g_vLightListGlobal;      // don't support Buffer yet in unity
-#define MAX_ENV2D_LIGHT 32
-
-CBUFFER_START(UnityTilePass)
-uint _NumTileFtplX;
-uint _NumTileFtplY;
-
-// these uniforms are only needed for when OPAQUES_ONLY is NOT defined
-// but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
-//#ifdef USE_CLUSTERED_LIGHTLIST
-float4x4 g_mInvScrProjection; // TODO: remove, unused in HDRP
-
-float g_fClustScale;
-float g_fClustBase;
-float g_fNearPlane;
-float g_fFarPlane;
-int g_iLog2NumClusters; // We need to always define these to keep constant buffer layouts compatible
-
-uint g_isLogBaseBufferEnabled;
-//#endif
-
-//#ifdef USE_CLUSTERED_LIGHTLIST
-uint _NumTileClusteredX;
-uint _NumTileClusteredY;
-CBUFFER_END
-
-StructuredBuffer<uint> g_vLayeredOffsetsBuffer;     // don't support Buffer yet in unity
-StructuredBuffer<float> g_logBaseBuffer;            // don't support Buffer yet in unity
-//#endif
-
-#ifdef USE_INDIRECT
-    StructuredBuffer<uint> g_TileFeatureFlags;
-#endif
-
-StructuredBuffer<DirectionalLightData> _DirectionalLightDatas;
-StructuredBuffer<LightData>            _LightDatas;
-StructuredBuffer<EnvLightData>         _EnvLightDatas;
-StructuredBuffer<ShadowData>           _ShadowDatas;
-
-// Used by directional and spot lights
-TEXTURE2D_ARRAY(_CookieTextures);
-
-// Used by point lights
-TEXTURECUBE_ARRAY_ABSTRACT(_CookieCubeTextures);
-
-// Use texture array for reflection (or LatLong 2D array for mobile)
-TEXTURECUBE_ARRAY_ABSTRACT(_EnvCubemapTextures);
-TEXTURE2D_ARRAY(_Env2DTextures);
-float4x4 _Env2DCaptureVP[MAX_ENV2D_LIGHT];
-
-// XRTODO: Need to stereo-ize access
-TEXTURE2D(_DeferredShadowTexture);
-
-CBUFFER_START(UnityPerLightLoop)
-uint _DirectionalLightCount;
-uint _PunctualLightCount;
-uint _AreaLightCount;
-uint _EnvLightCount;
-uint _EnvProxyCount;
-int  _EnvLightSkyEnabled;         // TODO: make it a bool
-CBUFFER_END
 
 // LightLoopContext is not visible from Material (user should not use these properties in Material file)
 // It allow the lightloop to have transmit sampling information (do we use atlas, or texture array etc...)

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

 using UnityEngine.Serialization;
 using UnityEngine.Experimental.Rendering.HDPipeline;
+using System;
-    public class HDAdditionalReflectionData : MonoBehaviour
+    public class HDAdditionalReflectionData : MonoBehaviour, ISerializationCallbackReceiver
-        public float version = 1.0f;
+        const int currentVersion = 1;
+
+        [SerializeField, FormerlySerializedAs("version")]
+        int m_Version;
 
         public ShapeType influenceShape;
         [FormerlySerializedAsAttribute("dimmer")]
 
         public float sphereBlendRadiusOffset { get { return -blendDistancePositive.x; } }
         public float sphereBlendNormalRadiusOffset { get { return -blendNormalDistancePositive.x; } }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            if (m_Version != currentVersion)
+            {
+                // Add here data migration code
+                m_Version = currentVersion;
+            }
+        }
     }
 }

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

 using UnityEngine.Serialization;
 using UnityEngine.Rendering;
+using System;
-    public class PlanarReflectionProbe : MonoBehaviour
+    public class PlanarReflectionProbe : MonoBehaviour, ISerializationCallbackReceiver
+        [HideInInspector]
+        const int currentVersion = 1;
+
+        [SerializeField, FormerlySerializedAs("version")]
+        int m_Version;
+
         public enum CapturePositionMode
         {
             Static,
 
             if (isActiveAndEnabled)
                 ReflectionSystem.RegisterProbe(this);
+        }
+
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            if (m_Version != currentVersion)
+            {
+                // Add here data migration code
+                m_Version = currentVersion;
+            }
         }
     }
 }

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

             RTHandles.Release(m_HTile);
         }
 
-        public void ClearTargets(CommandBuffer cmd, HDCamera camera)
+        public void ClearAndSetTargets(CommandBuffer cmd, HDCamera camera, bool rtCount4, RTHandleSystem.RTHandle cameraDepthStencilBuffer)
+            RenderTargetIdentifier[] RTIDs = new RenderTargetIdentifier[rtCount4 ? 4 :3];
+            // this clears the targets
+            Color clearColorAOSBlend = new Color(1.0f, 1.0f, 1.0f, 1.0f);
+
+            // names IDs have to be set every frame, because they can change
+            RTIDs[0] = m_RTs[0].nameID;
+            RTIDs[1] = m_RTs[1].nameID;
+            RTIDs[2] = m_RTs[2].nameID;
+            if (rtCount4)
+            {
+                HDUtils.SetRenderTarget(cmd, camera, m_RTs[3], ClearFlag.Color, clearColorAOSBlend);
+                RTIDs[3] = m_RTs[3].nameID;
+            }
-        }
-        public void SetHTile(int bindSlot, CommandBuffer cmd)
-        {
-            cmd.SetRandomWriteTarget(bindSlot, m_HTile);
+            // this actually sets the MRTs and HTile RWTexture, this is done separately because we do not have an api to clear MRTs to different colors
+            HDUtils.SetRenderTarget(cmd, camera, RTIDs, cameraDepthStencilBuffer); // do not clear anymore
+            cmd.SetRandomWriteTarget(rtCount4 ? 4 : 3, m_HTile);
         }
 
         public void UnSetHTile(CommandBuffer cmd)

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

+using System;
 using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
             public Vector4 normalWS;
             [SurfaceDataAttributes("Mask", true)]
             public Vector4 mask;
+            [SurfaceDataAttributes("AOSBlend", true)]
+            public Vector2 MAOSBlend;
             [SurfaceDataAttributes("HTileMask")]
             public uint HTileMask;
         };
-        {
-            // Note: This count doesn't include the velocity buffer. On shader and csharp side the velocity buffer will be added by the framework
-            Count = 3
+        {           
+            Count = 4
         };
 
         [GenerateHLSL(PackingRules.Exact)]
         // should this be combined into common class shared with Lit.cs???
         static public int GetMaterialDBufferCount() { return (int)DBufferMaterial.Count; }
 
-        static RenderTextureFormat[] m_RTFormat = { RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32 };
-        static bool[] m_sRGBFlags = { true, false, false };
+        static RenderTextureFormat[] m_RTFormat = { RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32, RenderTextureFormat.RG16 };
+        static bool[] m_sRGBFlags = { true, false, false, false };
 
         static public void GetMaterialDBufferDescription(out RenderTextureFormat[] RTFormat, out bool[] sRGBFlags)
         {
+
+        // relies on the order shader passes are declared in decal.shader
+        [Flags]
+        public enum MaskBlendFlags
+        {
+            Metal = 1 << 0,
+            AO = 1 << 1,
+            Smoothness = 1 << 2,
+        }
+
     }
 
     // normal to world only uses 3x3 for actual matrix so some data is packed in the unused space
         public Vector4 normalScaleBias;
         public Vector4 maskScaleBias;
         public Vector4 baseColor;
+        public Vector3 blendParams; // x normal blend source, y mask blend source, z mask blend mode
     };
 }

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

 #define DEBUGVIEW_DECAL_DECALSURFACEDATA_BASE_COLOR (200)
 #define DEBUGVIEW_DECAL_DECALSURFACEDATA_NORMAL (201)
 #define DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK (202)
-#define DEBUGVIEW_DECAL_DECALSURFACEDATA_HTILE_MASK (203)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_AOSBLEND (203)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_HTILE_MASK (204)
-#define DBUFFERMATERIAL_COUNT (3)
+#define DBUFFERMATERIAL_COUNT (4)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Decal+DBufferHTileBit:  static fields
     float4 baseColor;
     float4 normalWS;
     float4 mask;
+    float2 MAOSBlend;
     uint HTileMask;
 };
 
     float4 normalScaleBias;
     float4 maskScaleBias;
     float4 baseColor;
+    float3 blendParams;
+// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.DecalData
+//
+float4x4 GetWorldToDecal(DecalData value)
+{
+    return value.worldToDecal;
+}
+float4x4 GetNormalToWorld(DecalData value)
+{
+    return value.normalToWorld;
+}
+float4 GetDiffuseScaleBias(DecalData value)
+{
+    return value.diffuseScaleBias;
+}
+float4 GetNormalScaleBias(DecalData value)
+{
+    return value.normalScaleBias;
+}
+float4 GetMaskScaleBias(DecalData value)
+{
+    return value.maskScaleBias;
+}
+float4 GetBaseColor(DecalData value)
+{
+    return value.baseColor;
+}
+float3 GetBlendParams(DecalData value)
+{
+    return value.blendParams;
+}
+
+//
 // Debug functions
 //
 void GetGeneratedDecalSurfaceDataDebug(uint paramId, DecalSurfaceData decalsurfacedata, inout float3 result, inout bool needLinearToSRGB)
             break;
         case DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK:
             result = decalsurfacedata.mask.xyz;
+            break;
+        case DEBUGVIEW_DECAL_DECALSURFACEDATA_AOSBLEND:
+            result = float3(decalsurfacedata.MAOSBlend, 0.0);
             break;
         case DEBUGVIEW_DECAL_DECALSURFACEDATA_HTILE_MASK:
             result = GetIndexColor(decalsurfacedata.HTileMask);

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

 #define DBufferType0 float4
 #define DBufferType1 float4
 #define DBufferType2 float4
-#define DBufferType3 float4
-#ifdef DBUFFERMATERIAL_COUNT
+#ifdef _DECALS_4RT
+#define DBufferType3 float2
-#if DBUFFERMATERIAL_COUNT == 1
+#define OUTPUT_DBUFFER(NAME)							\
+	out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,	\
+	out DBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,	\
+	out DBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,	\
+	out DBufferType3 MERGE_NAME(NAME, 3) : SV_Target3
-#define OUTPUT_DBUFFER(NAME)                            \
-        out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0
+#define DECLARE_DBUFFER_TEXTURE(NAME)	\
+	TEXTURE2D(MERGE_NAME(NAME, 0));		\
+	TEXTURE2D(MERGE_NAME(NAME, 1));		\
+	TEXTURE2D(MERGE_NAME(NAME, 2));		\
+	TEXTURE2D(MERGE_NAME(NAME, 3));
-#define DECLARE_DBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));
+#define FETCH_DBUFFER(NAME, TEX, unCoord2)												\
+	DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2);	\
+	DBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);	\
+	DBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);	\
+	DBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2);
-#define FETCH_DBUFFER(NAME, TEX, unCoord2)                                        \
-        DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2);
+#define ENCODE_INTO_DBUFFER(DECAL_SURFACE_DATA, NAME) EncodeIntoDBuffer(DECAL_SURFACE_DATA, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), MERGE_NAME(NAME,3))
+#define DECODE_FROM_DBUFFER(NAME, DECAL_SURFACE_DATA) DecodeFromDBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), MERGE_NAME(NAME,3), DECAL_SURFACE_DATA)
-#define ENCODE_INTO_DBUFFER(DECAL_SURFACE_DATA, NAME) EncodeIntoDBuffer(DECAL_SURFACE_DATA, MERGE_NAME(NAME,0))
-#define DECODE_FROM_DBUFFER(NAME, DECAL_SURFACE_DATA) DecodeFromDBuffer(MERGE_NAME(NAME,0), DECAL_SURFACE_DATA)
+#else
+#define OUTPUT_DBUFFER(NAME)							\
+	out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,	\
+	out DBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,	\
+	out DBufferType2 MERGE_NAME(NAME, 2) : SV_Target2
-#elif DBUFFERMATERIAL_COUNT == 2
-
-#define OUTPUT_DBUFFER(NAME)                            \
-        out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,  \
-        out DBufferType1 MERGE_NAME(NAME, 1) : SV_Target1
-
-#define DECLARE_DBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));
-
-#define FETCH_DBUFFER(NAME, TEX, unCoord2)                                        \
-        DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        DBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);
-
-#define ENCODE_INTO_DBUFFER(DECAL_SURFACE_DATA, NAME) EncodeIntoDBuffer(DECAL_SURFACE_DATA, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
-#define DECODE_FROM_DBUFFER(NAME, DECAL_SURFACE_DATA) DecodeFromDBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), DECAL_SURFACE_DATA)
-
-#elif DBUFFERMATERIAL_COUNT == 3
-
-#define OUTPUT_DBUFFER(NAME)                            \
-        out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,  \
-        out DBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,  \
-        out DBufferType2 MERGE_NAME(NAME, 2) : SV_Target2
-
-#define DECLARE_DBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));
+#define DECLARE_DBUFFER_TEXTURE(NAME)	\
+	TEXTURE2D(MERGE_NAME(NAME, 0));		\
+	TEXTURE2D(MERGE_NAME(NAME, 1));		\
+	TEXTURE2D(MERGE_NAME(NAME, 2));
-#define FETCH_DBUFFER(NAME, TEX, unCoord2)                                        \
-        DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        DBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        DBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);
+#define FETCH_DBUFFER(NAME, TEX, unCoord2)												\
+	DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2);	\
+	DBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);	\
+	DBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);
-#elif DBUFFERMATERIAL_COUNT == 4
-
-#define OUTPUT_DBUFFER(NAME)                            \
-        out DBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,  \
-        out DBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,  \
-        out DBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,  \
-        out DBufferType3 MERGE_NAME(NAME, 3) : SV_Target3
-
-#define DECLARE_DBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));  \
-        TEXTURE2D(MERGE_NAME(NAME, 3));
-
-#define FETCH_DBUFFER(NAME, TEX, unCoord2)                                        \
-        DBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        DBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        DBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
-        DBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2);
-
-#define ENCODE_INTO_DBUFFER(DECAL_SURFACE_DATA, NAME) EncodeIntoDBuffer(DECAL_SURFACE_DATA, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), MERGE_NAME(NAME,3))
-#define DECODE_FROM_DBUFFER(NAME, DECAL_SURFACE_DATA) DecodeFromDBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), MERGE_NAME(NAME,3), DECAL_SURFACE_DATA)
-
-#endif // #ifdef DBUFFERMATERIAL_COUNT
-
-CBUFFER_START(UnityDecalParameters)
-    uint _EnableDBuffer;
-    float2 _DecalAtlasResolution;
-CBUFFER_END
 
 UNITY_INSTANCING_BUFFER_START(Decal)
     UNITY_DEFINE_INSTANCED_PROP(float4x4, _NormalToWorld)
 SAMPLER(_trilinear_clamp_sampler_DecalAtlas2D);
 
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
-void EncodeIntoDBuffer( DecalSurfaceData surfaceData,
-                        out DBufferType0 outDBuffer0,
-                        out DBufferType1 outDBuffer1,
-                        out DBufferType2 outDBuffer2
+void EncodeIntoDBuffer( DecalSurfaceData surfaceData
+                        , out DBufferType0 outDBuffer0
+                        , out DBufferType1 outDBuffer1
+                        , out DBufferType2 outDBuffer2
+#ifdef _DECALS_4RT
+						, out DBufferType3 outDBuffer3
+#endif
+#ifdef _DECALS_4RT
+	outDBuffer3 = surfaceData.MAOSBlend;
+#endif
-    DBufferType0 inDBuffer0,
-    DBufferType1 inDBuffer1,
-    DBufferType2 inDBuffer2,
-    out DecalSurfaceData surfaceData
+    DBufferType0 inDBuffer0
+    , DBufferType1 inDBuffer1
+    , DBufferType2 inDBuffer2
+#ifdef _DECALS_4RT
+	, DBufferType3 inDBuffer3
+#endif
+    , out DecalSurfaceData surfaceData
 )
 {
     ZERO_INITIALIZE(DecalSurfaceData, surfaceData);
     surfaceData.mask = inDBuffer2;
+#ifdef _DECALS_4RT
+	surfaceData.MAOSBlend = inDBuffer3;
+#else
+	surfaceData.MAOSBlend = float2(surfaceData.mask.w, surfaceData.mask.w);
+#endif
 }

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

         _MaskMap("MaskMap", 2D) = "white" {}
         _DecalBlend("_DecalBlend", Range(0.0, 1.0)) = 0.5
 		[ToggleUI] _AlbedoMode("_AlbedoMode", Range(0.0, 1.0)) = 1.0
+		[HideInInspector] _NormalBlendSrc("_NormalBlendSrc", Float) = 0.0
+		[HideInInspector] _MaskBlendSrc("_MaskBlendSrc", Float) = 1.0
+		[HideInInspector] _MaskBlendMode("_MaskBlendMode", Float) = 4.0 // smoothness 3RT default
+		[ToggleUI] _MaskmapMetal("_MaskmapMetal", Range(0.0, 1.0)) = 0.0
+		[ToggleUI] _MaskmapAO("_MaskmapAO", Range(0.0, 1.0)) = 0.0
+		[ToggleUI] _MaskmapSmoothness("_MaskmapSmoothness", Range(0.0, 1.0)) = 1.0
     }
 
     HLSLINCLUDE
     #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 _ _DECALS_4RT
     //-------------------------------------------------------------------------------------
     // Define
     //-------------------------------------------------------------------------------------
     {
         Tags{ "RenderPipeline" = "HDRenderPipeline"}
 
+		// c# code relies on the order in which the passes are declared, any change will need to be reflected in DecalUI.cs
+
+		// pass 0 is mesh 3RT mode
+		Pass
+		{
+			Name "DBufferMesh_3RT"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_3RT"} // Smoothness 
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+
+			ColorMask BA 2	// smoothness/smoothness alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		// enum MaskBlendFlags
+		//{
+		//	Metal = 1 << 0,
+		//	AO = 1 << 1,
+		//	Smoothness = 1 << 2,
+		//}
+
+		// Projectors
+		//
+		// 1 - Metal
+		// 2 - AO
+		// 3 - Metal + AO
+		// 4 - Smoothness also 3RT 
+		// 5 - Metal + Smoothness
+		// 6 - AO + Smoothness
+		// 7 - Metal + AO + Smoothness
+		//
+
+		Pass
+		{
+			Name "DBufferProjector_M"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_M"} // Metalness 
+			// back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask R 2	// metal 
+			ColorMask R 3	// metal alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferProjector_AO"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_AO"} // AO only
+													  // back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask G 2	// ao
+			ColorMask G 3	// ao alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferProjector_MAO"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_MAO"} // AO + Metalness
+													   // back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask RG 2	// metalness + ao
+			ColorMask RG 3	// metalness alpha + ao alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferProjector_S"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_S"} // Smoothness 
+			// back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+		
+			ColorMask BA 2	// smoothness/smoothness alpha
+		
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferProjector_MS"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_MS"} // Smoothness and Metalness 
+			// back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask RBA 2	// metal/smoothness/smoothness alpha 
+			ColorMask R 3	// metal alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+
+		Pass
+		{
+			Name "DBufferProjector_AOS"  // Name is not used
+			Tags{"LightMode" = "DBufferProjector_AOS"} // AO + Smoothness
+			// back faces with zfail, for cases when camera is inside the decal volume
+			Cull Front
+			ZWrite Off
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask GBA 2	// ao, smoothness, smoothness alpha
+			ColorMask G 3	// ao alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_PROJECTOR
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
-            Name "DBufferProjector"  // Name is not used
-            Tags { "LightMode" = "DBufferProjector" } // This will be only for opaque object based on the RenderQueue index
-
+            Name "DBufferProjector_MAOS"  // Name is not used
+            Tags { "LightMode" = "DBufferProjector_MAOS" } // Metalness AO and Smoothness
-            Blend SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
 
             HLSLPROGRAM
 
             ENDHLSL
         }
 
+		// Mesh 
+		// 8 - Metal
+		// 9 - AO
+		// 10 - Metal + AO
+		// 11 - Smoothness 
+		// 12 - Metal + Smoothness
+		// 13 - AO + Smoothness
+		// 14 - Metal + AO + Smoothness
+
-			Name "DBufferMesh"  // Name is not used
-			Tags{"LightMode" = "DBufferMesh"} // This will be only for opaque object based on the RenderQueue index
-										 
-			Cull Back
+			Name "DBufferMesh_M"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_M"} // Metalness 
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask R 2	// metal 
+			ColorMask R 3	// metal alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferMesh_AO"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_AO"} // AO only
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask G 2	// ao
+			ColorMask G 3	// ao alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferMesh_MAO"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_MAO"} // AO + Metalness
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask RG 2	// metalness + ao
+			ColorMask RG 3	// metalness alpha + ao alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferMesh_S"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_S"} // Smoothness 
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+
+			ColorMask BA 2	// smoothness/smoothness alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+
+		Pass
+		{
+			Name "DBufferMesh_MS"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_MS"} // Smoothness and Metalness 
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask RBA 2	// metal/smoothness/smoothness alpha 
+			ColorMask R 3	// metal alpha
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+
+		Pass
+		{
+			Name "DBufferMesh_AOS"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_AOS"} // AO + Smoothness
-			Blend SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			ColorMask GBA 2	// ao, smoothness, smoothness alpha
+			ColorMask G 3	// ao alpha
 
 			HLSLPROGRAM
 
 
 			ENDHLSL
 		}
-    }
+
+		Pass
+		{
+			Name "DBufferMesh_MAOS"  // Name is not used
+			Tags{"LightMode" = "DBufferMesh_MAOS"} // Metalness AO and Smoothness
+			ZWrite Off
+			ZTest LEqual
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend 0 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 1 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 2 SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
+			Blend 3 Zero OneMinusSrcColor
+
+			HLSLPROGRAM
+
+			#define SHADERPASS SHADERPASS_DBUFFER_MESH
+			#include "../../ShaderVariables.hlsl"
+			#include "Decal.hlsl"
+			#include "ShaderPass/DecalSharePass.hlsl"
+			#include "DecalData.hlsl"
+			#include "../../ShaderPass/ShaderPassDBuffer.hlsl"
+
+			ENDHLSL
+		}
+	}
     CustomEditor "Experimental.Rendering.HDPipeline.DecalUI"
 }

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

     surfaceData.baseColor = _BaseColor;
     surfaceData.normalWS = float4(0,0,0,0);
     surfaceData.mask = float4(0,0,0,0);
+	surfaceData.MAOSBlend = float2(0, 0);
-    float totalBlend = clamp(normalToWorld[0][3], 0.0f, 1.0f);
+    float albedoMapBlend = clamp(normalToWorld[0][3], 0.0f, 1.0f);
-	float totalBlend = _DecalBlend;
+	float albedoMapBlend = _DecalBlend;
 	float2 texCoords = input.texCoord0;
 #endif
 
-	surfaceData.baseColor.w *= totalBlend;
-	totalBlend = surfaceData.baseColor.w;   // base alpha affects all other channels;
-
+	surfaceData.baseColor.w *= albedoMapBlend;
+	albedoMapBlend = surfaceData.baseColor.w;   
 // outside _COLORMAP because we still have base color
 #if _ALBEDOCONTRIBUTION
 	surfaceData.HTileMask |= DBUFFERHTILEBIT_DIFFUSE;
 
+	float maskMapBlend;
+#if _MASKMAP
+    surfaceData.mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, texCoords);
+	maskMapBlend = surfaceData.mask.z * _DecalBlend;	// store before overwriting with smoothness
+    surfaceData.mask.z = surfaceData.mask.w;
+	surfaceData.HTileMask |= DBUFFERHTILEBIT_MASK;
+#if _MASK_BLEND_SRC_B
+	surfaceData.mask.w = maskMapBlend;
+#else
+    surfaceData.mask.w = albedoMapBlend;
+#endif
+#endif
+
+	// needs to be after mask, because blend source could be in the mask map blue
 #if _NORMALMAP
 	float3 normalTS = UnpackNormalmapRGorAG(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, texCoords));
 #if (SHADERPASS == SHADERPASS_DBUFFER_PROJECTOR)
 	GetNormalWS(input, 0, normalTS, normalWS);
 #endif
-    surfaceData.normalWS.xyz = normalWS * 0.5f + 0.5f;
-    surfaceData.normalWS.w = totalBlend;
-    surfaceData.HTileMask |= DBUFFERHTILEBIT_NORMAL;
+	surfaceData.normalWS.xyz = normalWS * 0.5f + 0.5f;
+	surfaceData.HTileMask |= DBUFFERHTILEBIT_NORMAL;
+#if _NORMAL_BLEND_SRC_B
+	surfaceData.normalWS.w = maskMapBlend;
+#else
+	surfaceData.normalWS.w = albedoMapBlend;
+#endif	
-
-#if _MASKMAP
-    surfaceData.mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, texCoords);
-    surfaceData.mask.z = surfaceData.mask.w;
-    surfaceData.mask.w = totalBlend;
-    surfaceData.HTileMask |= DBUFFERHTILEBIT_MASK;
-#endif
+	surfaceData.MAOSBlend.xy = float2(surfaceData.mask.w, surfaceData.mask.w);
 }

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

             }
         }
 
-        public void Update()
+        public void LateUpdate()
         {
             if (m_Handle != null)
             {

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

             }
         }
 
+        public bool perChannelMask
+        {
+            get
+            {
+                HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+                if (hdrp != null)
+                {
+                    return hdrp.renderPipelineSettings.decalSettings.perChannelMask;
+                }
+                return false;
+            }
+        }
+
         public Camera CurrentCamera
         {
             get
                 m_Blend = m_Material.GetFloat("_DecalBlend");
                 m_AlbedoContribution = m_Material.GetFloat("_AlbedoMode");
                 m_BaseColor = m_Material.GetVector("_BaseColor");
+                m_BlendParams = new Vector3(m_Material.GetFloat("_NormalBlendSrc"), m_Material.GetFloat("_MaskBlendSrc"), m_Material.GetFloat("_MaskBlendMode"));                
             }
 
             public DecalSet(Material material)
 
                 Vector3 cameraPos = instance.CurrentCamera.transform.position;
                 Matrix4x4 worldToView = LightLoop.WorldToCamera(instance.CurrentCamera);
+                bool perChannelMask = instance.perChannelMask;
                 for (int resultIndex = 0; resultIndex < m_NumResults; resultIndex++)
                 {
                     int decalIndex = m_ResultIndices[resultIndex];
                             m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
                             m_DecalDatas[m_DecalDatasCount].normalToWorld = normalToWorldBatch[instanceCount];
                             m_DecalDatas[m_DecalDatasCount].baseColor = m_BaseColor;
-
+                            m_DecalDatas[m_DecalDatasCount].blendParams = m_BlendParams;
+                            if(!perChannelMask)
+                            {
+                                m_DecalDatas[m_DecalDatasCount].blendParams.z = (float)Decal.MaskBlendFlags.Smoothness; 
+                            }
+                                                        
                             // we have not allocated the textures in atlas yet, so only store references to them
                             m_DiffuseTextureScaleBias[m_DecalDatasCount] = m_Diffuse;
                             m_NormalTextureScaleBias[m_DecalDatasCount] = m_Normal;
                     return;
                 int batchIndex = 0;
                 int totalToDraw = m_NumResults;
+                HDRenderPipelineAsset hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+                bool perChannelMask = hdrp.renderPipelineSettings.decalSettings.perChannelMask;
+                int shaderPass = perChannelMask ? (int)m_Material.GetFloat("_MaskBlendMode") : (int)Decal.MaskBlendFlags.Smoothness; // relies on the order shader passes are declared in decal.shader and decalUI.cs
+              
-                    cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_DecalToWorld[batchIndex], kDrawIndexedBatchSize, m_PropertyBlock);
+                    cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Material, shaderPass, m_DecalToWorld[batchIndex], kDrawIndexedBatchSize, m_PropertyBlock);
                     totalToDraw -= kDrawIndexedBatchSize;
                 }
 
-                    cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_DecalToWorld[batchIndex], totalToDraw, m_PropertyBlock);
+                    cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Material, shaderPass, m_DecalToWorld[batchIndex], totalToDraw, m_PropertyBlock);
                 }
             }
 
             private float m_Blend = 0;
             private float m_AlbedoContribution = 0;
             private Vector4 m_BaseColor;
+            private Vector3 m_BlendParams;
+            
 
             TextureScaleBias m_Diffuse = new TextureScaleBias();
             TextureScaleBias m_Normal = new TextureScaleBias();

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

     matMask |= mapMask;
 }
 
-void ApplyBlendMask(inout float4 dst, inout int matMask, float2 texCoords, int mapMask, float blend, float lod)
+// albedoBlend is overall decal blend combined with distance fade and albedo alpha
+// decalBlend is decal blend with distance fade to be able to construct normal and mask blend if they come from mask map blue channel
+// normalBlend is calculated in this function and used later to blend the normal
+// blendParams are material settings to determing blend source and mode for normal and mask map
+void ApplyBlendMask(inout float4 dbuffer2, inout float2 dbuffer3, inout int matMask, float2 texCoords, int mapMask, float albedoBlend, float lod, float decalBlend, inout float normalBlend, float3 blendParams) // too many blends!!!
-    src.z = src.w;
-    src.w = blend;
-    dst.xyz = src.xyz * src.w + dst.xyz * (1.0f - src.w);
-    dst.w = dst.w * (1.0f - src.w);
+	float maskBlend;
+	if (blendParams.x == 1.0f)	// normal blend source is mask blue channel
+		normalBlend = src.z * decalBlend;
+	else
+		normalBlend = albedoBlend; // normal blend source is albedo alpha
+
+	if (blendParams.y == 1.0f)	// mask blend source is mask blue channel
+		maskBlend = src.z * decalBlend;
+	else
+		maskBlend = albedoBlend; // mask blend siurce is albedo alpha
+
+    src.z = src.w;	// remap so smoothness goes to blue and mask blend goes to alpha
+    src.w = maskBlend;
+
+	float4 dbuffer2Mask;
+	float2 dbuffer3Mask;
+
+	if (blendParams.z == 0)
+	{
+		dbuffer2Mask = float4(1, 1, 1, 1);	// M, AO, S, S alpha
+		dbuffer3Mask = float2(1, 1); // M alpha, AO alpha
+	}
+	else if (blendParams.z == 1)
+	{
+		dbuffer2Mask = float4(1, 0, 0, 0);	// M, _, _, _
+		dbuffer3Mask = float2(1, 0); // M alpha, _
+	}
+	else if (blendParams.z == 2)
+	{
+		dbuffer2Mask = float4(0, 1, 0, 0);	// _, AO, _, _
+		dbuffer3Mask = float2(0, 1); // _, AO alpha
+	}
+	else if (blendParams.z == 3)
+	{
+		dbuffer2Mask = float4(1, 1, 0, 0);	// M, AO, _, _
+		dbuffer3Mask = float2(1, 1); // M Alpha, AO alpha
+	}
+	else if (blendParams.z == 4)
+	{
+		dbuffer2Mask = float4(0, 0, 1, 1);	// _, _, S, S alpha
+		dbuffer3Mask = float2(0, 0); // _, _
+	}
+	else if (blendParams.z == 5)
+	{
+		dbuffer2Mask = float4(1, 0, 1, 1);	// M, _, S, S alpha
+		dbuffer3Mask = float2(1, 0); // M alpha, _
+	}
+	else if (blendParams.z == 6)
+	{
+		dbuffer2Mask = float4(0, 1, 1, 1);	// _, AO, S, S alpha
+		dbuffer3Mask = float2(0, 1); // _, AO alpha
+	}
+	else if (blendParams.z == 7)
+	{
+		dbuffer2Mask = float4(1, 1, 1, 1);	// M, AO, S, S alpha
+		dbuffer3Mask = float2(1, 1); // M alpha, AO alpha
+	}
+
+	dbuffer2.xyz = (dbuffer2Mask.xyz == 1) ? src.xyz * src.w + dbuffer2.xyz * (1.0f - src.w) : dbuffer2.xyz;
+	dbuffer2.w = (dbuffer2Mask.w == 1) ? dbuffer2.w * (1.0f - src.w) : dbuffer2.w;
+
+	dbuffer3.xy = (dbuffer3Mask.xy == 1) ? dbuffer3.xy * (1.0f - src.w) : dbuffer3.xy;
+
     matMask |= mapMask;
 }
 
         DBuffer0 = float4(0.0f, 0.0f, 0.0f, 1.0f);
         DBuffer1 = float4(0.5f, 0.5f, 0.5f, 1.0f);
         DBuffer2 = float4(0.0f, 0.0f, 0.0f, 1.0f);
+#ifdef _DECALS_4RT
+		DBuffer3 = float2(1.0f, 1.0f);
+#else
+		float2 DBuffer3 = float2(1.0f, 1.0f);
+#endif
 
     #ifdef LIGHTLOOP_TILE_PASS
         GetCountAndStart(posInput, LIGHTCATEGORY_DECAL, decalStart, decalCount);
                 float2 sampleMaskDdy = positionDSDdy.xz * decalData.maskScaleBias.xy;
                 float lodMask = ComputeTextureLOD(sampleMaskDdx, sampleMaskDdy, _DecalAtlasResolution);
 
-                float decalBlend = decalData.normalToWorld[0][3];
+                float albedoBlend = decalData.normalToWorld[0][3];
-				ApplyBlendDiffuse(DBuffer0, mask, sampleDiffuse, src, DBUFFERHTILEBIT_DIFFUSE, decalBlend, lodDiffuse, diffuseTextureBound);		
-				alpha = alpha < decalBlend ? decalBlend : alpha;    // use decal alpha if it is higher than transparent alpha
+				ApplyBlendDiffuse(DBuffer0, mask, sampleDiffuse, src, DBUFFERHTILEBIT_DIFFUSE, albedoBlend, lodDiffuse, diffuseTextureBound);		
+				alpha = alpha < albedoBlend ? albedoBlend : alpha;    // use decal alpha if it is higher than transparent alpha
 
 				float albedoContribution = decalData.normalToWorld[1][3];
 				if (albedoContribution == 0.0f)
 				
+				float normalBlend = albedoBlend;
+				if ((decalData.maskScaleBias.x > 0) && (decalData.maskScaleBias.y > 0))
+				{
+					ApplyBlendMask(DBuffer2, DBuffer3, mask, sampleMask, DBUFFERHTILEBIT_MASK, albedoBlend, lodMask, decalData.normalToWorld[0][3], normalBlend, decalData.blendParams);
+				}
+
-                    ApplyBlendNormal(DBuffer1, mask, sampleNormal, DBUFFERHTILEBIT_NORMAL, (float3x3)decalData.normalToWorld, decalBlend, lodNormal);
-                }
-
-                if ((decalData.maskScaleBias.x > 0) && (decalData.maskScaleBias.y > 0))
-                {
-                    ApplyBlendMask(DBuffer2, mask, sampleMask, DBUFFERHTILEBIT_MASK, decalBlend, lodMask);
+                    ApplyBlendNormal(DBuffer1, mask, sampleNormal, DBUFFERHTILEBIT_NORMAL, (float3x3)decalData.normalToWorld, normalBlend, lodNormal);
                 }
             }
         }
         }
         if(mask & DBUFFERHTILEBIT_MASK)
         {
-            surfaceData.metallic = surfaceData.metallic * decalSurfaceData.mask.w + decalSurfaceData.mask.x;
-            surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.mask.w + decalSurfaceData.mask.y;
+#ifdef _DECALS_4RT // only smoothness in 3RT mode
+            surfaceData.metallic = surfaceData.metallic * decalSurfaceData.MAOSBlend.x + decalSurfaceData.mask.x;
+			surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y;
+#endif
             surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z;
         }
     }

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

         public int drawDistance = 1000;
         public int atlasWidth = 4096;
         public int atlasHeight = 4096;
+        public bool perChannelMask = false;
     }
 }

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

     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
 
+	// decal 3RT or 4RT toggle
+	#pragma multi_compile _ _DECALS_4RT
+
     //enable GPU instancing support
     #pragma multi_compile_instancing
 

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
 
+	// decal 3RT or 4RT toggle
+	#pragma multi_compile _ _DECALS_4RT
+
     // enable GPU instancing
     #pragma multi_compile_instancing
 

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

     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
 
+	// decal 3RT or 4RT toggle
+	#pragma multi_compile _ _DECALS_4RT
+
     //enable GPU instancing support
     #pragma multi_compile_instancing
 

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

     // enable dithering LOD crossfade
     #pragma multi_compile _ LOD_FADE_CROSSFADE
 
+	// decal 3RT or 4RT toggle
+	#pragma multi_compile _ _DECALS_4RT
+
     //enable GPU instancing support
     #pragma multi_compile_instancing
 

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

 #include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
 #include "CoreRP/ShaderLibrary/EntityLighting.hlsl"
 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
-#include "../Sky/AtmosphericScattering/AtmosphericScattering.hlsl"
+#include "HDRP/Lighting/AtmosphericScattering/AtmosphericScattering.hlsl"
 
 // Guidelines for Material Keyword.
 // There is a set of Material Keyword that a HD shaders must define (or not define). We call them system KeyWord.

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

 
 
     #pragma shader_feature _STACKLIT_DEBUG
+
+	// decal 3RT or 4RT toggle
+	#pragma multi_compile _ _DECALS_4RT
+
     //enable GPU instancing support
     #pragma multi_compile_instancing
 

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

 #include "../DiffusionProfile/DiffusionProfile.hlsl"
 
 // ----------------------------------------------------------------------------
-// constant buffer declaration
-// ----------------------------------------------------------------------------
-
-CBUFFER_START(UnitySSSAndTransmissionParameters)
-// Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
-// Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
-uint   _EnableSubsurfaceScattering; // Globally toggles subsurface and transmission scattering on/off
-float  _TexturingModeFlags;       // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
-float  _TransmissionFlags;        // 1 bit/profile; 0 = regular, 1 = thin
-// Old SSS Model >>>
-float4 _HalfRcpVariancesAndWeights[DIFFUSION_PROFILE_COUNT][2]; // 2x Gaussians in RGB, A is interpolation weights
-// <<< Old SSS Model
-// Use float4 to avoid any packing issue between compute and pixel shaders
-float4  _ThicknessRemaps[DIFFUSION_PROFILE_COUNT];   // R: start, G = end - start, BA unused
-float4 _ShapeParams[DIFFUSION_PROFILE_COUNT];        // RGB = S = 1 / D, A = filter radius
-float4 _TransmissionTintsAndFresnel0[DIFFUSION_PROFILE_COUNT];  // RGB = 1/4 * color, A = fresnel0
-float4 _WorldScales[DIFFUSION_PROFILE_COUNT];        // X = meters per world unit; Y = world units per meter
-CBUFFER_END
-
-// ----------------------------------------------------------------------------
 // helper functions
 // ----------------------------------------------------------------------------
 

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

                 // We need to copy depth buffer texture if we want to bind it at this stage
                 CopyDepthBufferIfNeeded(cmd);
 
+                bool rtCount4 = m_Asset.GetRenderPipelineSettings().decalSettings.perChannelMask;
-                m_DbufferManager.ClearTargets(cmd, hdCamera);
-                HDUtils.SetRenderTarget(cmd, hdCamera, m_DbufferManager.GetBuffersRTI(), m_CameraDepthStencilBuffer); // do not clear anymore
-                m_DbufferManager.SetHTile(m_DbufferManager.bufferCount, cmd);
+                m_DbufferManager.ClearAndSetTargets(cmd, hdCamera, rtCount4, m_CameraDepthStencilBuffer);
                 renderContext.ExecuteCommandBuffer(cmd);
                 cmd.Clear();
 
                     sorting = { flags = SortFlags.CommonOpaque }
                 };
-                drawSettings.SetShaderPassName(0, HDShaderPassNames.s_MeshDecalsName);
+
+                if(rtCount4)
+                {
+                    drawSettings.SetShaderPassName(0, HDShaderPassNames.s_MeshDecalsMName);
+                    drawSettings.SetShaderPassName(1, HDShaderPassNames.s_MeshDecalsAOName);
+                    drawSettings.SetShaderPassName(2, HDShaderPassNames.s_MeshDecalsMAOName);
+                    drawSettings.SetShaderPassName(3, HDShaderPassNames.s_MeshDecalsSName);
+                    drawSettings.SetShaderPassName(4, HDShaderPassNames.s_MeshDecalsMSName);
+                    drawSettings.SetShaderPassName(5, HDShaderPassNames.s_MeshDecalsAOSName);
+                    drawSettings.SetShaderPassName(6, HDShaderPassNames.s_MeshDecalsMAOSName);
+                }
+                else
+                {
+                    drawSettings.SetShaderPassName(0, HDShaderPassNames.s_MeshDecals3RTName);
+                }
+                                               
-                renderContext.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, filterRenderersSettings);
+                CoreUtils.SetKeyword(cmd, "_DECALS_4RT", m_Asset.GetRenderPipelineSettings().decalSettings.perChannelMask);
+
+                renderContext.DrawRenderers(cullResults.visibleRenderers, ref drawSettings, filterRenderersSettings);
                 DecalSystem.instance.RenderIntoDBuffer(cmd);
                 m_DbufferManager.UnSetHTile(cmd);
                 m_DbufferManager.SetHTileTexture(cmd);  // mask per 8x8 tile used for optimization when looking up dbuffer values

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDStringConstants.cs

         public static readonly string s_TransparentDepthPostpassStr = "TransparentDepthPostpass";
         public static readonly string s_MetaStr = "Meta";
         public static readonly string s_ShadowCasterStr = "ShadowCaster";
-        public static readonly string s_MeshDecalsStr = "DBufferMesh";
-
+        public static readonly string s_MeshDecalsMStr = "DBufferMesh_M";
+        public static readonly string s_MeshDecalsSStr = "DBufferMesh_S";
+        public static readonly string s_MeshDecalsMSStr = "DBufferMesh_MS";
+        public static readonly string s_MeshDecalsAOStr = "DBufferMesh_AO";
+        public static readonly string s_MeshDecalsMAOStr = "DBufferMesh_MAO";
+        public static readonly string s_MeshDecalsAOSStr = "DBufferMesh_AOS";
+        public static readonly string s_MeshDecalsMAOSStr = "DBufferMesh_MAOS";
+        public static readonly string s_MeshDecals3RTStr = "DBufferMesh_3RT";
+       
         // ShaderPass name
         public static readonly ShaderPassName s_EmptyName = new ShaderPassName(s_EmptyStr);
         public static readonly ShaderPassName s_ForwardName = new ShaderPassName(s_ForwardStr);
         public static readonly ShaderPassName s_TransparentDepthPrepassName = new ShaderPassName(s_TransparentDepthPrepassStr);
         public static readonly ShaderPassName s_TransparentBackfaceName = new ShaderPassName(s_TransparentBackfaceStr);
         public static readonly ShaderPassName s_TransparentDepthPostpassName = new ShaderPassName(s_TransparentDepthPostpassStr);
-        public static readonly ShaderPassName s_MeshDecalsName = new ShaderPassName(s_MeshDecalsStr);
+        public static readonly ShaderPassName s_MeshDecalsMName = new ShaderPassName(s_MeshDecalsMStr);
+        public static readonly ShaderPassName s_MeshDecalsSName = new ShaderPassName(s_MeshDecalsSStr);
+        public static readonly ShaderPassName s_MeshDecalsMSName = new ShaderPassName(s_MeshDecalsMSStr);
+        public static readonly ShaderPassName s_MeshDecalsAOName = new ShaderPassName(s_MeshDecalsAOStr);
+        public static readonly ShaderPassName s_MeshDecalsMAOName = new ShaderPassName(s_MeshDecalsMAOStr);
+        public static readonly ShaderPassName s_MeshDecalsAOSName = new ShaderPassName(s_MeshDecalsAOSStr);
+        public static readonly ShaderPassName s_MeshDecalsMAOSName = new ShaderPassName(s_MeshDecalsMAOSStr);
+        public static readonly ShaderPassName s_MeshDecals3RTName = new ShaderPassName(s_MeshDecals3RTStr);
 
         // Legacy name
         public static readonly ShaderPassName s_AlwaysName = new ShaderPassName("Always");

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   m_Name: HDRenderPipelineResources
   m_EditorClassIdentifier: 
   version: 1
-  defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
-    type: 2}
-  defaultMirrorMaterial: {fileID: 2100000, guid: 6b17274157b33bc45b6a40e7d4ff51fe,
-    type: 2}
-  defaultDecalMaterial: {fileID: 2100000, guid: 500e733574922d04ea961553b1b26a63,
-    type: 2}
+  defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17, type: 2}
+  defaultMirrorMaterial: {fileID: 2100000, guid: 6b17274157b33bc45b6a40e7d4ff51fe, type: 2}
+  defaultDecalMaterial: {fileID: 2100000, guid: 500e733574922d04ea961553b1b26a63, type: 2}
-  debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba,
-    type: 3}
-  debugViewMaterialGBufferShader: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d,
-    type: 3}
-  debugViewTilesShader: {fileID: 4800000, guid: c7c2bd17b06ceb4468e14081aaf1b96f,
-    type: 3}
-  debugFullScreenShader: {fileID: 4800000, guid: e874aca2df8300a488258738c31f85cf,
-    type: 3}
-  debugColorPickerShader: {fileID: 4800000, guid: 8137b807709e178498f22ed710864bb0,
-    type: 3}
+  debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba, type: 3}
+  debugViewMaterialGBufferShader: {fileID: 4800000, guid: 439949ea1bfa91b4ba0d04269fcde33d, type: 3}
+  debugViewTilesShader: {fileID: 4800000, guid: c7c2bd17b06ceb4468e14081aaf1b96f, type: 3}
+  debugFullScreenShader: {fileID: 4800000, guid: e874aca2df8300a488258738c31f85cf, type: 3}
+  debugColorPickerShader: {fileID: 4800000, guid: 8137b807709e178498f22ed710864bb0, type: 3}
   deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
   colorPyramidCS: {fileID: 7200000, guid: 4e3267a1135742441a14298d8dcac04a, type: 3}
   depthPyramidCS: {fileID: 7200000, guid: 64a553bb564274041906f78ffba955e4, type: 3}
-  clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656,
-    type: 3}
-  buildDispatchIndirectShader: {fileID: 7200000, guid: 4eb1b418be7044c40bb5200496c50f14,
-    type: 3}
-  buildScreenAABBShader: {fileID: 7200000, guid: 728dce960f8a9c44bbc3abb3b851d8f6,
-    type: 3}
-  buildPerTileLightListShader: {fileID: 7200000, guid: 65af3444cbf4b3747a4dead7ee00cfee,
-    type: 3}
-  buildPerBigTileLightListShader: {fileID: 7200000, guid: 5ee1f9d6e09abe045b2f5e0b784b9072,
-    type: 3}
-  buildPerVoxelLightListShader: {fileID: 7200000, guid: 0bb1b7e0ddcd5c44baf3ddc7456eb196,
-    type: 3}
-  buildMaterialFlagsShader: {fileID: 7200000, guid: fb3eda953cd6e634e877fb777be2cd08,
-    type: 3}
-  deferredComputeShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259,
-    type: 3}
-  screenSpaceShadowComputeShader: {fileID: 7200000, guid: 3e6900e06dc185a4380af4dacb4db0a4,
-    type: 3}
-  volumeVoxelizationCS: {fileID: 7200000, guid: c20b371db720da244b73830ec74a343a,
-    type: 3}
-  volumetricLightingCS: {fileID: 7200000, guid: b4901a10df2d1e24282725e9fbc77c97,
-    type: 3}
-  subsurfaceScatteringCS: {fileID: 7200000, guid: b06a7993621def248addd55d0fe931b1,
-    type: 3}
-  subsurfaceScattering: {fileID: 4800000, guid: 867b36db983aa0548889a66f8d685ff6,
-    type: 3}
+  clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656, type: 3}
+  buildDispatchIndirectShader: {fileID: 7200000, guid: 4eb1b418be7044c40bb5200496c50f14, type: 3}
+  buildScreenAABBShader: {fileID: 7200000, guid: 728dce960f8a9c44bbc3abb3b851d8f6, type: 3}
+  buildPerTileLightListShader: {fileID: 7200000, guid: 65af3444cbf4b3747a4dead7ee00cfee, type: 3}
+  buildPerBigTileLightListShader: {fileID: 7200000, guid: 5ee1f9d6e09abe045b2f5e0b784b9072, type: 3}
+  buildPerVoxelLightListShader: {fileID: 7200000, guid: 0bb1b7e0ddcd5c44baf3ddc7456eb196, type: 3}
+  buildMaterialFlagsShader: {fileID: 7200000, guid: fb3eda953cd6e634e877fb777be2cd08, type: 3}
+  deferredComputeShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259, type: 3}
+  screenSpaceShadowComputeShader: {fileID: 7200000, guid: 3e6900e06dc185a4380af4dacb4db0a4, type: 3}
+  volumeVoxelizationCS: {fileID: 7200000, guid: c20b371db720da244b73830ec74a343a, type: 3}
+  volumetricLightingCS: {fileID: 7200000, guid: b4901a10df2d1e24282725e9fbc77c97, type: 3}
+  subsurfaceScatteringCS: {fileID: 7200000, guid: b06a7993621def248addd55d0fe931b1, type: 3}
+  subsurfaceScattering: {fileID: 4800000, guid: 867b36db983aa0548889a66f8d685ff6, type: 3}
   combineLighting: {fileID: 4800000, guid: 2e37131331fbdca449b1a2bc47a639ca, type: 3}
   cameraMotionVectors: {fileID: 4800000, guid: 035941b63024d1943af48811c1db20d9, type: 3}
   copyStencilBuffer: {fileID: 4800000, guid: 3d1574f1cdfa0ce4995f9bc79ed7f8ec, type: 3}
-  buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
-    type: 3}
-  computeGgxIblSampleData: {fileID: 7200000, guid: 764a24bb47ef5ba4781d9ae82ca07445,
-    type: 3}
+  buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c, type: 3}
+  computeGgxIblSampleData: {fileID: 7200000, guid: 764a24bb47ef5ba4781d9ae82ca07445, type: 3}
-  opaqueAtmosphericScattering: {fileID: 4800000, guid: 326059e48e5735e46a98047eff4f0295,
-    type: 3}
+  opaqueAtmosphericScattering: {fileID: 4800000, guid: 32f724728cf19904291226f239ec16f0, type: 3}
-  preIntegratedFGD_GGXDisneyDiffuse: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad,
-    type: 3}
-  preIntegratedFGD_CharlieClothLambert: {fileID: 4800000, guid: 3b3bf235775cf8b4baae7f3306787ab0,
-    type: 3}
+  preIntegratedFGD_GGXDisneyDiffuse: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad, type: 3}
+  preIntegratedFGD_CharlieClothLambert: {fileID: 4800000, guid: 3b3bf235775cf8b4baae7f3306787ab0, type: 3}
-  debugShadowMapShader: {fileID: 4800000, guid: ee25e539f5594f44085e0a9000c15d9b,
-    type: 3}
+  debugShadowMapShader: {fileID: 4800000, guid: ee25e539f5594f44085e0a9000c15d9b, type: 3}

com.unity.render-pipelines.high-definition/HDRP/ShaderVariables.hlsl

 
 // ----------------------------------------------------------------------------
 
-CBUFFER_START(UnityPerFrame)
-    float4 glstate_lightmodel_ambient;
-    float4 unity_AmbientSky;
-    float4 unity_AmbientEquator;
-    float4 unity_AmbientGround;
-    float4 unity_IndirectSpecColor;
-
-#if !defined(USING_STEREO_MATRICES)
-    float4x4 glstate_matrix_projection;
-    float4x4 unity_MatrixV;
-    float4x4 unity_MatrixInvV;
-    float4x4 unity_MatrixVP;
-    float4 unity_StereoScaleOffset;
-    int unity_StereoEyeIndex;
-#endif
-
-    float4 unity_ShadowColor;
-CBUFFER_END
-
-// ----------------------------------------------------------------------------
-
 // These are the samplers available in the HDRenderPipeline.
 // Avoid declaring extra samplers as they are 4x SGPR each on GCN.
 SAMPLER(s_point_clamp_sampler);
 
 // ----------------------------------------------------------------------------
 
+// Define that before including all the sub systems ShaderVariablesXXX.hlsl files in order to include constant buffer properties.
+#define SHADER_VARIABLES_INCLUDE_CB
+
-CBUFFER_START(UnityPerView)
+CBUFFER_START(UnityGlobal)
+    // ================================
+    //     PER FRAME CONSTANTS
+    // ================================
+    #if !defined(USING_STEREO_MATRICES)
+        float4x4 glstate_matrix_projection;
+        float4x4 unity_MatrixV;
+        float4x4 unity_MatrixInvV;
+        float4x4 unity_MatrixVP;
+        float4 unity_StereoScaleOffset;
+        int unity_StereoEyeIndex;
+    #endif
+
+    // ================================
+    //     PER VIEW CONSTANTS
+    // ================================
     // TODO: all affine matrices should be 3x4.
     float4x4 _ViewMatrix;
     float4x4 _InvViewMatrix;
     float4 _VBufferPrevUvScaleAndLimit;
     float4 _VBufferPrevDepthEncodingParams;
     float4 _VBufferPrevDepthDecodingParams;
-CBUFFER_END
-CBUFFER_START(UnityLightingParameters)
-// Buffer pyramid
-float4  _ColorPyramidSize;              // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
-float4  _DepthPyramidSize;              // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
-float4  _CameraMotionVectorsSize;       // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
-float4  _ColorPyramidScale;             // (x,y) = Screen Scale, z = lod count, w = unused
-float4  _DepthPyramidScale;             // (x,y) = Screen Scale, z = lod count, w = unused
-float4  _CameraMotionVectorsScale;      // (x,y) = Screen Scale, z = lod count, w = unused
+    #include "Lighting/LightLoop/ShaderVariablesLightLoop.hlsl"
+    #include "Lighting/ScreenSpaceLighting/ShaderVariablesScreenSpaceLighting.hlsl"
+    #include "Lighting/AtmosphericScattering/ShaderVariablesAtmosphericScattering.hlsl"
+    #include "Material/SubsurfaceScattering/ShaderVariablesSubsurfaceScattering.hlsl"
+    #include "Material/Decal/ShaderVariablesDecal.hlsl"
-                                // Screen space lighting
-float   _SSRefractionInvScreenWeightDistance;     // Distance for screen space smoothstep with fallback
-float   _SSReflectionInvScreenWeightDistance;     // Distance for screen space smoothstep with fallback
-int     _SSReflectionEnabled;
-int     _SSReflectionProjectionModel;
-int     _SSReflectionHiZRayMarchBehindObject;
-int     _SSRefractionHiZRayMarchBehindObject;
-
-                                                // Ambiant occlusion
-float4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
-// Rough refraction texture
-// Color pyramid (width, height, lodcount, Unused)
-TEXTURE2D(_ColorPyramidTexture);
-// Depth pyramid (width, height, lodcount, Unused)
-TEXTURE2D(_DepthPyramidTexture);
-// Ambient occlusion texture
-TEXTURE2D(_AmbientOcclusionTexture);
-TEXTURE2D(_CameraMotionVectorsTexture);
+// Undef in order to include all textures and buffers declarations
+#undef SHADER_VARIABLES_INCLUDE_CB
+#include "Lighting/LightLoop/ShaderVariablesLightLoop.hlsl"
+#include "Lighting/AtmosphericScattering/ShaderVariablesAtmosphericScattering.hlsl"
+#include "Lighting/ScreenSpaceLighting/ShaderVariablesScreenSpaceLighting.hlsl"
+#include "Material/Decal/ShaderVariablesDecal.hlsl"
+#include "Material/SubsurfaceScattering/ShaderVariablesSubsurfaceScattering.hlsl"
 
 // Custom generated by HDRP, not from Unity Engine (passed in via HDCamera)
 #if defined(USING_STEREO_MATRICES)

com.unity.render-pipelines.high-definition/HDRP/ShaderVariablesFunctions.hlsl

     return _ScreenToTargetScale.zw;
 }
 
+float4 SampleSkyTexture(float3 texCoord)
+{
+    return SAMPLE_TEXTURECUBE(_SkyTexture, s_trilinear_clamp_sampler, texCoord);
+}
+
+float4 SampleSkyTexture(float3 texCoord, float lod)
+{
+    return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, s_trilinear_clamp_sampler, texCoord, lod);
+}
+
 #endif // UNITY_SHADER_VARIABLES_FUNCTIONS_INCLUDED

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering/OpaqueAtmosphericScattering.shader

 
             #pragma vertex Vert
             #pragma fragment Frag
-            
+
             #pragma multi_compile _ DEBUG_DISPLAY
 
             // #pragma enable_d3d11_debug_symbols
-            #include "../ShaderVariables.hlsl"
-            #include "AtmosphericScattering/AtmosphericScattering.hlsl"
+            #include "HDRP/ShaderVariables.hlsl"
+            #include "HDRP/Lighting/AtmosphericScattering/AtmosphericScattering.hlsl"
 
             struct Attributes
             {

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering/AtmosphericScattering.cs.meta

 fileFormatVersion: 2
 guid: 953beb541740ddc499d005ee80c9ff29
-timeCreated: 1507718592
-licenseType: Pro
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering.meta

+fileFormatVersion: 2
+guid: 41811d2641d454a48819f6e50a816af9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifdef SHADER_VARIABLES_INCLUDE_CB
+
+    #define MAX_ENV2D_LIGHT 32
+
+    uint _DirectionalLightCount;
+    uint _PunctualLightCount;
+    uint _AreaLightCount;
+    uint _EnvLightCount;
+    uint _EnvProxyCount;
+    int  _EnvLightSkyEnabled;         // TODO: make it a bool
+
+    uint _NumTileFtplX;
+    uint _NumTileFtplY;
+
+    // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
+    // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
+    //#ifdef USE_CLUSTERED_LIGHTLIST
+    float4x4 g_mInvScrProjection; // TODO: remove, unused in HDRP
+
+    float g_fClustScale;
+    float g_fClustBase;
+    float g_fNearPlane;
+    float g_fFarPlane;
+    int g_iLog2NumClusters; // We need to always define these to keep constant buffer layouts compatible
+
+    uint g_isLogBaseBufferEnabled;
+    //#endif
+
+    //#ifdef USE_CLUSTERED_LIGHTLIST
+    uint _NumTileClusteredX;
+    uint _NumTileClusteredY;
+
+    float4x4 _Env2DCaptureVP[MAX_ENV2D_LIGHT];
+
+#else
+
+    #include "HDRP/Lighting/LightDefinition.cs.hlsl"
+    #include "CoreRP/Shadow/ShadowBase.cs.hlsl"
+
+    StructuredBuffer<uint>  g_vLightListGlobal;      // don't support Buffer yet in unity
+
+    StructuredBuffer<uint>  g_vLayeredOffsetsBuffer;     // don't support Buffer yet in unity
+    StructuredBuffer<float> g_logBaseBuffer;            // don't support Buffer yet in unity
+                                                        //#endif
+
+    #ifdef USE_INDIRECT
+        StructuredBuffer<uint> g_TileFeatureFlags;
+    #endif
+
+    StructuredBuffer<DirectionalLightData> _DirectionalLightDatas;
+    StructuredBuffer<LightData>            _LightDatas;
+    StructuredBuffer<EnvLightData>         _EnvLightDatas;
+    StructuredBuffer<ShadowData>           _ShadowDatas;
+
+    // Used by directional and spot lights
+    TEXTURE2D_ARRAY(_CookieTextures);
+
+    // Used by point lights
+    TEXTURECUBE_ARRAY_ABSTRACT(_CookieCubeTextures);
+
+    // Use texture array for reflection (or LatLong 2D array for mobile)
+    TEXTURECUBE_ARRAY_ABSTRACT(_EnvCubemapTextures);
+    TEXTURE2D_ARRAY(_Env2DTextures);
+
+    // XRTODO: Need to stereo-ize access
+    TEXTURE2D(_DeferredShadowTexture);
+
+#endif

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

+fileFormatVersion: 2
+guid: 63d561c067f228044bff7c3922047bf2
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting.meta

+fileFormatVersion: 2
+guid: 8201940de2426934dbd592ff5cf182c9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifdef SHADER_VARIABLES_INCLUDE_CB
+    uint    _EnableDBuffer;
+    float2  _DecalAtlasResolution;
+#else
+#endif

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

+fileFormatVersion: 2
+guid: 9f6cea0783427804084f429e8502ad33
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifdef SHADER_VARIABLES_INCLUDE_CB
+    #include "HDRP/Material/DiffusionProfile/DiffusionProfileSettings.cs.hlsl"
+
+    // Warning: Unity is not able to losslessly transfer integers larger than 2^24 to the shader system.
+    // Therefore, we bitcast uint to float in C#, and bitcast back to uint in the shader.
+    uint   _EnableSubsurfaceScattering; // Globally toggles subsurface and transmission scattering on/off
+    float  _TexturingModeFlags;         // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
+    float  _TransmissionFlags;          // 1 bit/profile; 0 = regular, 1 = thin
+    // Old SSS Model >>>
+    float4 _HalfRcpVariancesAndWeights[DIFFUSION_PROFILE_COUNT][2]; // 2x Gaussians in RGB, A is interpolation weights
+    // <<< Old SSS Model
+    // Use float4 to avoid any packing issue between compute and pixel shaders
+    float4  _ThicknessRemaps[DIFFUSION_PROFILE_COUNT];   // R: start, G = end - start, BA unused
+    float4 _ShapeParams[DIFFUSION_PROFILE_COUNT];        // RGB = S = 1 / D, A = filter radius
+    float4 _TransmissionTintsAndFresnel0[DIFFUSION_PROFILE_COUNT];  // RGB = 1/4 * color, A = fresnel0
+    float4 _WorldScales[DIFFUSION_PROFILE_COUNT];        // X = meters per world unit; Y = world units per meter
+#else
+#endif

com.unity.render-pipelines.high-definition/HDRP/Material/SubsurfaceScattering/ShaderVariablesSubsurfaceScattering.hlsl.meta

+fileFormatVersion: 2
+guid: 63af6347132378d43b75aa5e4efeb029
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering/AtmosphericScattering.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 22ede5ad2c67e3148bf5bd9fa48b2734
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifndef UNITY_ATMOSPHERIC_SCATTERING_INCLUDED
+#define UNITY_ATMOSPHERIC_SCATTERING_INCLUDED
+
+#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
+#include "CoreRP/ShaderLibrary/Filtering.hlsl"
+
+#include "AtmosphericScattering.cs.hlsl"
+#include "HDRP/ShaderVariables.hlsl"
+#include "HDRP/Lighting/Volumetrics/VBuffer.hlsl"
+
+#ifdef DEBUG_DISPLAY
+#include "HDRP/Debug/DebugDisplay.hlsl"
+#endif
+
+float3 GetFogColor(PositionInputs posInput)
+{
+    if (_FogColorMode == FOGCOLORMODE_CONSTANT_COLOR)
+    {
+        return _FogColor.rgb;
+    }
+    else if (_FogColorMode == FOGCOLORMODE_SKY_COLOR)
+    {
+        // Based on Uncharted 4 "Mip Sky Fog" trick: http://advances.realtimerendering.com/other/2016/naughty_dog/NaughtyDog_TechArt_Final.pdf
+        float mipLevel = (1.0 - _MipFogMaxMip * saturate((posInput.linearDepth - _MipFogNear) / (_MipFogFar - _MipFogNear))) * _SkyTextureMipCount;
+        float3 dir = -GetWorldSpaceNormalizeViewDir(posInput.positionWS);
+        return SampleSkyTexture(dir, mipLevel).rgb;
+    }
+    else // Should not be possible.
+        return  float3(0.0, 0.0, 0.0);
+}
+
+// Returns fog color in rgb and fog factor in alpha.
+float4 EvaluateAtmosphericScattering(PositionInputs posInput)
+{
+    float3 fogColor = 0;
+    float  fogFactor = 0;
+
+#ifdef DEBUG_DISPLAY
+    // Don't sample atmospheric scattering when lighting debug more are enabled so fog is not visible
+    if (_DebugLightingMode == DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING || _DebugLightingMode == DEBUGLIGHTINGMODE_SPECULAR_LIGHTING || _DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+        return float4(0, 0, 0, 0);
+#endif
+
+    switch (_AtmosphericScatteringType)
+    {
+        case FOGTYPE_LINEAR:
+        {
+            fogColor = GetFogColor(posInput);
+            fogFactor = _FogDensity * saturate((posInput.linearDepth - _LinearFogStart) * _LinearFogOneOverRange) * saturate((_LinearFogHeightEnd - GetAbsolutePositionWS(posInput.positionWS).y) * _LinearFogHeightOneOverRange);
+            break;
+        }
+        case FOGTYPE_EXPONENTIAL:
+        {
+            fogColor = GetFogColor(posInput);
+            float distance = length(GetWorldSpaceViewDir(posInput.positionWS));
+            float fogHeight = max(0.0, GetAbsolutePositionWS(posInput.positionWS).y - _ExpFogBaseHeight);
+            fogFactor = _FogDensity * TransmittanceHomogeneousMedium(_ExpFogHeightAttenuation, fogHeight) * (1.0f - TransmittanceHomogeneousMedium(1.0f / _ExpFogDistance, distance));
+            break;
+        }
+        case FOGTYPE_VOLUMETRIC:
+        {
+            float4 volFog = SampleVolumetricLighting(TEXTURE3D_PARAM(_VBufferLighting, s_linear_clamp_sampler),
+                                                     posInput.positionNDC,
+                                                     posInput.linearDepth,
+                                                     _VBufferResolution,
+                                                     _VBufferSliceCount.xy,
+                                                     _VBufferUvScaleAndLimit.xy,
+                                                     _VBufferUvScaleAndLimit.zw,
+                                                     _VBufferDepthEncodingParams,
+                                                     _VBufferDepthDecodingParams,
+                                                     true, true);
+
+            fogFactor = 1 - volFog.a;                              // Opacity from transmittance
+            fogColor  = volFog.rgb * min(rcp(fogFactor), FLT_MAX); // Un-premultiply, clamp to avoid (0 * INF = NaN)
+            break;
+        }
+    }
+
+    return float4(fogColor, fogFactor);
+}
+
+#endif

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

+fileFormatVersion: 2
+guid: 14cc5dd8542c537438a7b0282cbc2a6f
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering/OpaqueAtmosphericScattering.shader.meta

+fileFormatVersion: 2
+guid: 32f724728cf19904291226f239ec16f0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifdef SHADER_VARIABLES_INCLUDE_CB
+    int     _AtmosphericScatteringType;
+    // Common
+    float   _FogColorMode;
+    float4  _FogColorDensity; // color in rgb, density in alpha
+    float4  _MipFogParameters;
+    // Linear fog
+    float4  _LinearFogParameters;
+    // Exp fog
+    float4  _ExpFogParameters;
+
+    float   _SkyTextureMipCount;
+#else
+    TEXTURE3D(_VBufferLighting);
+    TEXTURECUBE(_SkyTexture);
+
+    #define _MipFogNear                     _MipFogParameters.x
+    #define _MipFogFar                      _MipFogParameters.y
+    #define _MipFogMaxMip                   _MipFogParameters.z
+
+    #define _FogDensity                     _FogColorDensity.w
+    #define _FogColor                       _FogColorDensity
+
+    #define _LinearFogStart                 _LinearFogParameters.x
+    #define _LinearFogOneOverRange          _LinearFogParameters.y
+    #define _LinearFogHeightEnd             _LinearFogParameters.z
+    #define _LinearFogHeightOneOverRange    _LinearFogParameters.w
+
+    #define _ExpFogDistance                 _ExpFogParameters.x
+    #define _ExpFogBaseHeight               _ExpFogParameters.y
+    #define _ExpFogHeightAttenuation        _ExpFogParameters.z
+#endif
+

com.unity.render-pipelines.high-definition/HDRP/Lighting/AtmosphericScattering/ShaderVariablesAtmosphericScattering.hlsl.meta

+fileFormatVersion: 2
+guid: 08e9d756e08b10445b237c82ec588e47
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/ScreenSpaceLighting/ShaderVariablesScreenSpaceLighting.hlsl.meta

+fileFormatVersion: 2
+guid: c78e4b79bf403f44f87fc4f81662898e
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+#ifdef SHADER_VARIABLES_INCLUDE_CB
+    // Buffer pyramid
+    float4  _ColorPyramidSize;              // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
+    float4  _DepthPyramidSize;              // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
+    float4  _CameraMotionVectorsSize;       // (x,y) = Actual Pixel Size, (z,w) = 1 / Actual Pixel Size
+    float4  _ColorPyramidScale;             // (x,y) = Screen Scale, z = lod count, w = unused
+    float4  _DepthPyramidScale;             // (x,y) = Screen Scale, z = lod count, w = unused
+    float4  _CameraMotionVectorsScale;      // (x,y) = Screen Scale, z = lod count, w = unused
+
+                                            // Screen space lighting
+    float   _SSRefractionInvScreenWeightDistance;     // Distance for screen space smoothstep with fallback
+    float   _SSReflectionInvScreenWeightDistance;     // Distance for screen space smoothstep with fallback
+    int     _SSReflectionEnabled;
+    int     _SSReflectionProjectionModel;
+    int     _SSReflectionHiZRayMarchBehindObject;
+    int     _SSRefractionHiZRayMarchBehindObject;
+
+    // Ambiant occlusion
+    float4 _AmbientOcclusionParam; // xyz occlusion color, w directLightStrenght
+#else
+    // Rough refraction texture
+    // Color pyramid (width, height, lodcount, Unused)
+    TEXTURE2D(_ColorPyramidTexture);
+    // Depth pyramid (width, height, lodcount, Unused)
+    TEXTURE2D(_DepthPyramidTexture);
+    // Ambient occlusion texture
+    TEXTURE2D(_AmbientOcclusionTexture);
+    TEXTURE2D(_CameraMotionVectorsTexture);
+#endif

com.unity.render-pipelines.high-definition/HDRP/Sky/AtmosphericScattering.meta

-fileFormatVersion: 2
-guid: d522828bc0314e14cb6faa4291bb64da
-folderAsset: yes
-timeCreated: 1507718579
-licenseType: Pro
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Sky/OpaqueAtmosphericScattering.shader.meta

-fileFormatVersion: 2
-guid: 326059e48e5735e46a98047eff4f0295
-timeCreated: 1507736585
-licenseType: Pro
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Sky/SkyVariables.hlsl.meta

-fileFormatVersion: 2
-guid: 7ed7d57e43fdd874ab5d047358e9fbe1
-timeCreated: 1508156067
-licenseType: Pro
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Sky/SkyVariables.hlsl

-#ifndef UNITY_SKY_VARIABLES_INCLUDED
-#define UNITY_SKY_VARIABLES_INCLUDED
-
-TEXTURECUBE(_SkyTexture);
-
-CBUFFER_START(SkyParameters)
-float _SkyTextureMipCount;
-CBUFFER_END
-
-float4 SampleSkyTexture(float3 texCoord)
-{
-    return SAMPLE_TEXTURECUBE(_SkyTexture, s_trilinear_clamp_sampler, texCoord);
-}
-
-float4 SampleSkyTexture(float3 texCoord, float lod)
-{
-    return SAMPLE_TEXTURECUBE_LOD(_SkyTexture, s_trilinear_clamp_sampler, texCoord, lod);
-}
-
-#endif