Merge remote-tracking branch 'refs/remotes/origin/master' into Update-ClearCoat

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1101_Unlit.unity.png.meta

   serializedVersion: 5
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 0
+    enableMipMap: 1
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: 1
-    wrapV: 1
-    wrapW: 1
-  nPOTScale: 0
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 0
+  alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1
   textureType: 0
   platformSettings:
   - serializedVersion: 2
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Standalone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: iPhone
-    maxTextureSize: 2048
-    resizeAlgorithm: 0
-    textureFormat: -1
-    textureCompression: 0
-    compressionQuality: 50
-    crunchedCompression: 0
-    allowsAlphaSplitting: 0
-    overridden: 0
-    androidETC2FallbackOverride: 0
-  - serializedVersion: 2
-    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1

SampleScenes/HDTest/GraphicTest/Common/Textures/FourShapesReliefHeightmap.tga.meta

 fileFormatVersion: 2
 guid: 870243a1ef675dd4cac0433df1aa80a3
-timeCreated: 1484821420
-licenseType: Pro
-  serializedVersion: 4
+  externalObjects: {}
+  serializedVersion: 5
-    sRGBTexture: 1
+    sRGBTexture: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
     mipMapFadeDistanceStart: 1
     mipMapFadeDistanceEnd: 3
   bumpmap:
   alphaUsage: 1
   alphaIsTransparency: 0
   spriteTessellationDetail: -1
-  textureType: 0
+  textureType: 10
+  singleChannelComponent: 1
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
-  - buildTarget: Standalone
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
-    textureFormat: 26
+    resizeAlgorithm: 0
+    textureFormat: -1
-    overridden: 1
-  - buildTarget: iPhone
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
-  - buildTarget: tvOS
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: tvOS
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
-  - buildTarget: PS4
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: PS4
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
-  - buildTarget: Windows Store Apps
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
-  - buildTarget: WebGL
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: WebGL
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
+    androidETC2FallbackOverride: 0
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

                     QuickSort(arr, pivot + 1, right);
             }
         }
+
+        public static Mesh CreateDecalMesh()
+        {
+            Mesh mesh = new Mesh();
+
+            Vector3[] vertices = new Vector3[8];
+
+            vertices[0] = new Vector3(-0.5f, -1.0f, -0.5f);
+            vertices[1] = new Vector3(0.5f, -1.0f, -0.5f);
+            vertices[2] = new Vector3(0.5f, 0.0f, -0.5f);
+            vertices[3] = new Vector3(-0.5f, 0.0f, -0.5f);
+            vertices[4] = new Vector3(-0.5f, -1.0f, 0.5f);
+            vertices[5] = new Vector3(0.5f, -1.0f, 0.5f);
+            vertices[6] = new Vector3(0.5f, 0.0f, 0.5f);
+            vertices[7] = new Vector3(-0.5f, 0.0f, 0.5f);
+
+            mesh.vertices = vertices;
+
+            int[] triangles = new int[36];
+
+            triangles[0] = 0; triangles[1] = 2; triangles[2] = 1;
+            triangles[3] = 0; triangles[4] = 3; triangles[5] = 2;
+            triangles[6] = 1; triangles[7] = 6; triangles[8] = 5;
+            triangles[9] = 1; triangles[10] = 2; triangles[11] = 6;
+            triangles[12] = 5; triangles[13] = 7; triangles[14] = 4;
+            triangles[15] = 5; triangles[16] = 6; triangles[17] = 7;
+            triangles[18] = 4; triangles[19] = 3; triangles[20] = 0;
+            triangles[21] = 4; triangles[22] = 7; triangles[23] = 3;
+            triangles[24] = 3; triangles[25] = 6; triangles[26] = 2;
+            triangles[27] = 3; triangles[28] = 7; triangles[29] = 6;
+            triangles[30] = 4; triangles[31] = 1; triangles[32] = 5;
+            triangles[33] = 4; triangles[34] = 0; triangles[35] = 1;
+
+            mesh.triangles = triangles;
+            return mesh;
+        }
+
+        public static BoundingSphere GetDecalMeshBoundingSphere(Matrix4x4 decalToWorld)
+        {
+
+            Vector4 min = new Vector4(-0.5f, -1.0f, -0.5f, 1.0f);
+            Vector4 max = new Vector4(0.5f, 0.0f, 0.5f, 1.0f);
+            min = decalToWorld * min;
+            max = decalToWorld * max;
+            BoundingSphere res = new BoundingSphere();
+            res.position = (max + min) / 2;
+            res.radius = ((Vector3)(max - min)).magnitude / 2;
+            return res;
+        }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs

         private static readonly int m_DecalToWorldR = Shader.PropertyToID("_DecalToWorldR");
 
         public Material m_Material;
+        private MaterialPropertyBlock m_PropertyBlock;
+        public const int kInvalidIndex = -1;
+        private int m_CullIndex = kInvalidIndex;
-        private MaterialPropertyBlock m_PropertyBlock;
+        public int CullIndex
+        {
+            get
+            {
+                return this.m_CullIndex;
+            }
+            set
+            {
+                this.m_CullIndex = value;
+            }
+        }
 
         public void OnEnable()
         {
 
         public void OnValidate()
         {
+            BoundingSphere sphere = CoreUtils.GetDecalMeshBoundingSphere(transform.localToWorldMatrix);
             if (m_Material != null)
             {
                 Shader shader = m_Material.shader;
                 }
             }
         }
-
 
         private void DrawGizmo(bool selected)
         {
         public void OnDrawGizmosSelected()
         {
             DrawGizmo(true);
+            // if this object is selected there is a chance the transform was changed so update culling info
+            DecalSystem.instance.UpdateBoundingSphere(this);
         }
 
 		public void UpdatePropertyBlock(Vector3 cameraPos)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

                 return m_Instance;
             }
         }
-
-        internal HashSet<DecalProjectorComponent> m_Decals = new HashSet<DecalProjectorComponent>();
-        Mesh m_CubeMesh;
-
+        
+        private Mesh m_DecalMesh = null;
+        private CullingGroup m_CullingGroup = null;
+		private const int kDecalBlockSize = 128;
+		private BoundingSphere[] m_BoundingSpheres = new BoundingSphere[kDecalBlockSize];
+		private DecalProjectorComponent[] m_Decals = new DecalProjectorComponent[kDecalBlockSize];
+		private int[] m_ResultIndices = new int[kDecalBlockSize];
+		private int m_NumResults = 0;
+		private int m_DecalsCount = 0;
+     
-            CreateCubeMesh();
+            m_DecalMesh = CoreUtils.CreateDecalMesh();            
-        void CreateCubeMesh()
+        // update bounding sphere for a single decal
+        public void UpdateBoundingSphere(DecalProjectorComponent decal)
-            m_CubeMesh = new Mesh();
+			m_BoundingSpheres[decal.CullIndex] = CoreUtils.GetDecalMeshBoundingSphere(decal.transform.localToWorldMatrix);
+        }
-            Vector3[] vertices = new Vector3[8];
-
-            vertices[0] = new Vector3(-0.5f, -1.0f, -0.5f);
-            vertices[1] = new Vector3( 0.5f, -1.0f, -0.5f);
-            vertices[2] = new Vector3( 0.5f, 0.0f, -0.5f);
-            vertices[3] = new Vector3(-0.5f, 0.0f, -0.5f);
-            vertices[4] = new Vector3(-0.5f, -1.0f,  0.5f);
-            vertices[5] = new Vector3( 0.5f, -1.0f,  0.5f);
-            vertices[6] = new Vector3( 0.5f, 0.0f,  0.5f);
-            vertices[7] = new Vector3(-0.5f, 0.0f,  0.5f);
+        public void AddDecal(DecalProjectorComponent decal)
+        {
+			if (decal.CullIndex != DecalProjectorComponent.kInvalidIndex) //do not add the same decal more than once
+				return;
-            m_CubeMesh.vertices = vertices;
+			// increase array size if no space left
+            if(m_DecalsCount == m_Decals.Length)
+            {
+				DecalProjectorComponent[] newDecals = new DecalProjectorComponent[m_DecalsCount + kDecalBlockSize];
+				BoundingSphere[] newSpheres = new BoundingSphere[m_DecalsCount + kDecalBlockSize];
+				m_ResultIndices = new int[m_DecalsCount + kDecalBlockSize];
-            int[] triangles = new int[36];
+                m_Decals.CopyTo(newDecals, 0);
+				m_BoundingSpheres.CopyTo(newSpheres, 0);
-            triangles[0] = 0; triangles[1] = 2; triangles[2] = 1;
-            triangles[3] = 0; triangles[4] = 3; triangles[5] = 2;
-            triangles[6] = 1; triangles[7] = 6; triangles[8] = 5;
-            triangles[9] = 1; triangles[10] = 2; triangles[11] = 6;
-            triangles[12] = 5; triangles[13] = 7; triangles[14] = 4;
-            triangles[15] = 5; triangles[16] = 6; triangles[17] = 7;
-            triangles[18] = 4; triangles[19] = 3; triangles[20] = 0;
-            triangles[21] = 4; triangles[22] = 7; triangles[23] = 3;
-            triangles[24] = 3; triangles[25] = 6; triangles[26] = 2;
-            triangles[27] = 3; triangles[28] = 7; triangles[29] = 6;
-            triangles[30] = 4; triangles[31] = 1; triangles[32] = 5;
-            triangles[33] = 4; triangles[34] = 0; triangles[35] = 1;
+				m_Decals = newDecals;
+				m_BoundingSpheres = newSpheres;
+			}
-            m_CubeMesh.triangles = triangles;
+			m_Decals[m_DecalsCount] = decal;
+			m_Decals[m_DecalsCount].CullIndex = m_DecalsCount;
+			UpdateBoundingSphere(m_Decals[m_DecalsCount]);
+			m_DecalsCount++;            
-        public void AddDecal(DecalProjectorComponent d)
+        public void RemoveDecal(DecalProjectorComponent decal)
-            // If no decal material assign, don't add it
-            if (d.m_Material == null)
-                return;
+			if (decal.CullIndex == DecalProjectorComponent.kInvalidIndex) //do not remove decal that has not been added
+				return;
+
+			int removeAtIndex = decal.CullIndex;
+			// replace with last decal in the list and update index
+			m_Decals[removeAtIndex] = m_Decals[m_DecalsCount - 1]; // move the last decal in list 
+			m_Decals[removeAtIndex].CullIndex = removeAtIndex;
+			m_Decals[m_DecalsCount - 1] = null;
-            if (d.m_Material.GetTexture("_BaseColorMap") || d.m_Material.GetTexture("_NormalMap"))
+			// update the bounding spheres array
+			m_BoundingSpheres[removeAtIndex] = m_BoundingSpheres[m_DecalsCount - 1];
+			m_DecalsCount--;
+			decal.CullIndex = DecalProjectorComponent.kInvalidIndex;
+        }
+
+        public void BeginCull(Camera camera)
+        {
+            if (m_CullingGroup != null)
-                RemoveDecal(d);
-                m_Decals.Add(d);
+                Debug.LogError("Begin/EndCull() called out of sequence for decal projectors.");                
+			m_NumResults = 0;
+            m_CullingGroup = new CullingGroup();
+            m_CullingGroup.targetCamera = camera;
+            m_CullingGroup.SetBoundingSpheres(m_BoundingSpheres);
+			m_CullingGroup.SetBoundingSphereCount(m_DecalsCount);
-        public void RemoveDecal(DecalProjectorComponent d)
+		public int QueryCullResults()
+		{
+			m_NumResults = m_CullingGroup.QueryIndices(true, m_ResultIndices, 0);
+			return m_NumResults;
+		}
+
+        public void Render(ScriptableRenderContext renderContext, HDCamera camera, CommandBuffer cmd)
-            m_Decals.Remove(d);
+            if (m_DecalMesh == null)
+                m_DecalMesh = CoreUtils.CreateDecalMesh();
+
+            for (int resultIndex = 0; resultIndex < m_NumResults; resultIndex++)
+            {
+                int decalIndex = m_ResultIndices[resultIndex];
+
+                // If no decal material assigned, don't draw it
+                if (m_Decals[decalIndex].m_Material == null)
+                    continue;
+
+                // don't draw decals that do not have textures assigned
+                if (!m_Decals[decalIndex].m_Material.GetTexture("_BaseColorMap") && !m_Decals[decalIndex].m_Material.GetTexture("_NormalMap") &&
+                    !m_Decals[decalIndex].m_Material.GetTexture("_MaskMap"))
+                    continue;
+
+                m_Decals[decalIndex].UpdatePropertyBlock(camera.cameraPos);
+                cmd.DrawMesh(m_DecalMesh, m_Decals[decalIndex].transform.localToWorldMatrix, m_Decals[decalIndex].m_Material, 0, 0,
+                    m_Decals[decalIndex].GetPropertyBlock());
+            }
-        public void Render(ScriptableRenderContext renderContext, Vector3 cameraPos, CommandBuffer cmd)
+        public void EndCull()
-            if (m_CubeMesh == null)
-                CreateCubeMesh();
-            foreach (var decal in m_Decals)
+            if (m_CullingGroup == null)
+            {
+                Debug.LogError("Begin/EndCull() called out of sequence for decal projectors.");
+            }
+            else
-				decal.UpdatePropertyBlock(cameraPos);
-                cmd.DrawMesh(m_CubeMesh, decal.transform.localToWorldMatrix, decal.m_Material, 0, 0, decal.GetPropertyBlock());
+                m_CullingGroup.Dispose();
+                m_CullingGroup = null;               
             }
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineMenuItems.cs

 using System.IO;
+using UnityEditor.SceneManagement;
+using UnityEngine.SceneManagement;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
                     camera.gameObject.AddComponent<HDAdditionalCameraData>();
             }
         }
-        static void CheckOutFile(bool VSCEnabled, Material mat)
+        static void CheckOutFile(bool VSCEnabled, Object mat)
         {
             if (VSCEnabled)
             {
         {
             try
             {
-                var materials = Resources.FindObjectsOfTypeAll<Material>();
-
-                bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
-
-                for (int i = 0, length = materials.Length; i < length; i++)
-                {
-                    EditorUtility.DisplayProgressBar(
-                        "Setup materials Keywords...",
-                        string.Format("{0} / {1} materials cleaned.", i, length),
-                        i / (float)(length - 1));
-
-                    CheckOutFile(VSCEnabled, materials[i]);
-                    HDEditorUtils.ResetMaterialKeywords(materials[i]);
-                }
+                ResetAllLoadedMaterialKeywords(string.Empty, 1, 0);
             }
             finally
             {
 
-        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Reset All Materials Keywords (Materials in Project)", priority = CoreUtils.editMenuPriority2)]
-        static void ResetAllMaterialKeywordsInProject()
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Reset All Material Asset's Keywords (Materials in Project)", priority = CoreUtils.editMenuPriority2)]
+        static void ResetAllMaterialAssetsKeywords()
-                var matIds = AssetDatabase.FindAssets("t:Material");
+                ResetAllMaterialAssetsKeywords(1, 0);
+            }
+            finally
+            {
+                EditorUtility.ClearProgressBar();
+            }
+        }
-                bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Reset All Materials Keywords (Materials in Project and scenes)", priority = CoreUtils.editMenuPriority2)]
+        static void ResetAllMaterialKeywordsInProjectAndScenes()
+        {
+            var openedScenes = new string[EditorSceneManager.loadedSceneCount];
+            for (var i = 0; i < openedScenes.Length; ++i)
+                openedScenes[i] = SceneManager.GetSceneAt(i).path;
-                for (int i = 0, length = matIds.Length; i < length; i++)
+            bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+
+            try
+            {
+                var scenes = AssetDatabase.FindAssets("t:Scene");
+                var scale = 1f / Mathf.Max(1, scenes.Length);
+                for (var i = 0; i < scenes.Length; ++i)
-                    var path = AssetDatabase.GUIDToAssetPath(matIds[i]);
-                    var mat = AssetDatabase.LoadAssetAtPath<Material>(path);
-
-                    EditorUtility.DisplayProgressBar(
-                        "Setup materials Keywords...",
-                        string.Format("{0} / {1} materials cleaned.", i, length),
-                        i / (float)(length - 1));
+                    var scenePath = AssetDatabase.GUIDToAssetPath(scenes[i]);
+                    var sceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(scenePath);
+                    CheckOutFile(VSCEnabled, sceneAsset);
+                    EditorSceneManager.OpenScene(scenePath);
-                    CheckOutFile(VSCEnabled, mat);
-                    HDEditorUtils.ResetMaterialKeywords(mat);
+                    var sceneName = Path.GetFileNameWithoutExtension(scenePath);
+                    var description = string.Format("{0} {1}/{2} - ", sceneName, i + 1, scenes.Length);
+                    ResetAllLoadedMaterialKeywords(description, scale, scale * i);
+
+                ResetAllMaterialAssetsKeywords(scale, scale * (scenes.Length - 1));
+
+                if (openedScenes.Length > 0)
+                {
+                    EditorSceneManager.OpenScene(openedScenes[0]);
+                    for (var i = 1; i < openedScenes.Length; i++)
+                        EditorSceneManager.OpenScene(openedScenes[i], OpenSceneMode.Additive);
+                }
             }
         }
 
         {
             var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetSubsurfaceScatteringSettings>(), "New SSS Settings.asset", icon, null);
+        }
+
+        static void ResetAllMaterialAssetsKeywords(float progressScale, float progressOffset)
+        {
+            var matIds = AssetDatabase.FindAssets("t:Material");
+
+            bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+
+            for (int i = 0, length = matIds.Length; i < length; i++)
+            {
+                var path = AssetDatabase.GUIDToAssetPath(matIds[i]);
+                var mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+
+                EditorUtility.DisplayProgressBar(
+                    "Setup material asset's Keywords...",
+                    string.Format("{0} / {1} materials cleaned.", i, length),
+                    (i / (float)(length - 1)) * progressScale + progressOffset);
+
+                CheckOutFile(VSCEnabled, mat);
+                HDEditorUtils.ResetMaterialKeywords(mat);
+            }
+        }
+
+        static void ResetAllLoadedMaterialKeywords(string descriptionPrefix, float progressScale, float progressOffset)
+        {
+            var materials = Resources.FindObjectsOfTypeAll<Material>();
+
+            bool VSCEnabled = (UnityEditor.VersionControl.Provider.enabled && UnityEditor.VersionControl.Provider.isActive);
+
+            for (int i = 0, length = materials.Length; i < length; i++)
+            {
+                EditorUtility.DisplayProgressBar(
+                    "Setup materials Keywords...",
+                    string.Format("{0}{1} / {2} materials cleaned.", descriptionPrefix, i, length),
+                    (i / (float)(length - 1)) * progressScale + progressOffset);
+
+                CheckOutFile(VSCEnabled, materials[i]);
+                HDEditorUtils.ResetMaterialKeywords(materials[i]);
+            }
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalUI.cs

 
             public static GUIContent baseColorText = new GUIContent("Base Color + Blend", "Albedo (RGB) and Blend Factor (A)");
             public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))");
-            public static GUIContent decalBlendText = new GUIContent("Decal Blend", "Combines with Base Color (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");
         }
 
         protected MaterialProperty baseColorMap = new MaterialProperty();
         protected const string kNormalMap = "_NormalMap";
 
+		protected MaterialProperty maskMap = new MaterialProperty();
+		protected const string kMaskMap = "_MaskMap";
+
         protected MaterialProperty decalBlend = new MaterialProperty();
         protected const string kDecalBlend = "_DecalBlend";
 
         {
             baseColorMap = FindProperty(kBaseColorMap, props);
             normalMap = FindProperty(kNormalMap, props);
+			maskMap = FindProperty(kMaskMap, props);
             decalBlend = FindProperty(kDecalBlend, props);
         }
 
         {
             CoreUtils.SetKeyword(material, "_COLORMAP", material.GetTexture(kBaseColorMap));
             CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap));
+			CoreUtils.SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap));
         }
 
         protected void SetupMaterialKeywordsAndPassInternal(Material material)
 
                 m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap);
                 m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap);
+				m_MaterialEditor.TexturePropertySingleLine(Styles.maskMapText, maskMap);
                 m_MaterialEditor.ShaderProperty(decalBlend, Styles.decalBlendText);
 
                 EditorGUI.indentLevel--;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

             SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
             CoreUtils.SetKeyword(material, "_SURFACE_TYPE_TRANSPARENT", surfaceType == SurfaceType.Transparent);
 
-            bool enableBlendModePreserveSpecularLighting = material.HasProperty(kEnableBlendModePreserveSpecularLighting) && material.GetFloat(kEnableBlendModePreserveSpecularLighting) > 0.0f;
+            bool enableBlendModePreserveSpecularLighting = (surfaceType == SurfaceType.Transparent) && material.HasProperty(kEnableBlendModePreserveSpecularLighting) && material.GetFloat(kEnableBlendModePreserveSpecularLighting) > 0.0f;
             CoreUtils.SetKeyword(material, "_BLENDMODE_PRESERVE_SPECULAR_LIGHTING", enableBlendModePreserveSpecularLighting);
 
             // These need to always been set either with opaque or transparent! So a users can switch to opaque and remove the keyword correctly

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

         public const int k_MaxDbuffer = 4;
 
         public int dbufferCount { get; set; }
+        public int vsibleDecalCount { get; set; }
 
         RenderTargetIdentifier[] m_ColorMRTs;
         RenderTargetIdentifier[] m_RTIDs = new RenderTargetIdentifier[k_MaxDbuffer];
             }
 
             return m_ColorMRTs;
+        }
+
+        public void PushGlobalParams(CommandBuffer cmd)
+        {
+            cmd.SetGlobalInt(HDShaderIDs._EnableDBuffer, vsibleDecalCount > 0 ? 1 : 0);
         }
     }
 
                 hdCamera.SetupGlobalParams(cmd);
 
                 m_SSSBufferManager.PushGlobalParams(cmd, sssParameters, m_FrameSettings);
+
+                m_DbufferManager.PushGlobalParams(cmd);
             }
         }
 
                         ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
                     }
 #endif
+                    // decal system needs to be updated with current camera
+					if (m_FrameSettings.enableDBuffer)
+						DecalSystem.instance.BeginCull(camera);
 
                     using (new ProfilingSample(cmd, "CullResults.Cull", GetSampler(CustomSamplerId.CullResultsCull)))
                     {
+                    m_DbufferManager.vsibleDecalCount = 0;
+                    if (m_FrameSettings.enableDBuffer)
+                    {
+                        m_DbufferManager.vsibleDecalCount = DecalSystem.instance.QueryCullResults();
+                        DecalSystem.instance.EndCull();
+                    }
+
                     var postProcessLayer = camera.GetComponent<PostProcessLayer>();
                     var hdCamera = HDCamera.Get(camera, postProcessLayer, m_FrameSettings);
 
 
 	                InitAndClearBuffer(hdCamera, enableBakeShadowMask, cmd);
 
-                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd);
+                    bool forcePrepassForDecals = m_DbufferManager.vsibleDecalCount > 0;
+                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, forcePrepassForDecals);
-                    RenderDBuffer(hdCamera.cameraPos, renderContext, cmd);
+                    RenderDBuffer(hdCamera, renderContext, cmd);
 
                     RenderGBuffer(m_CullResults, hdCamera, renderContext, cmd);
 
         // Forward only renderer: We always render everything
         // Deferred renderer: We render a depth prepass only if engine request it. We can decide if we render everything or only opaque alpha tested object.
         // Forward opaque with deferred renderer (DepthForwardOnly pass): We always render everything
-        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
+        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool forcePrepass)
         {
             // In case of deferred renderer, we can have forward opaque material. These materials need to be render in the depth buffer to correctly build the light list.
             // And they will tag the stencil to not be lit during the deferred lighting pass.
             using (new ProfilingSample(cmd, addAlphaTestedOnly ? "Depth Prepass alpha test" : "Depth Prepass", GetSampler(CustomSamplerId.DepthPrepass)))
             {
                 CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
-                if (m_FrameSettings.enableDBuffer || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
+				if (forcePrepass || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
                 {
                     // We render first the opaque object as opaque alpha tested are more costly to render and could be reject by early-z (but not Hi-z as it is disable with clip instruction)
                     // This is handled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
             }
         }
 
-        void RenderDBuffer(Vector3 cameraPos, ScriptableRenderContext renderContext, CommandBuffer cmd)
+        void RenderDBuffer(HDCamera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             if (!m_FrameSettings.enableDBuffer)
                 return;
                 cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
 
                 CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
-				DecalSystem.instance.Render(renderContext, cameraPos, cmd);
+				DecalSystem.instance.Render(renderContext, camera, cmd);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset

     supportSSR: 1
     supportSSAO: 1
     supportSSSAndTransmission: 1
-    supportDBuffer: 0
+    supportDBuffer: 1
     supportMSAA: 0
     supportAsyncCompute: 0
     lightLoopSettings:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset.meta

 fileFormatVersion: 2
-guid: 449281dd2b4fbee49b8397de0541ea3c
+guid: 1fa8c4c8604deee4e99ff30888538ca5
 NativeFormatImporter:
   externalObjects: {}
   mainObjectFileID: 11400000

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _CameraFilteringBuffer          = Shader.PropertyToID("_CameraFilteringTexture");
         public static readonly int _IrradianceSource               = Shader.PropertyToID("_IrradianceSource");
 
+        public static readonly int _EnableDBuffer = Shader.PropertyToID("_EnableDBuffer");
+
         public static readonly int[] _GBufferTexture =
         {
             Shader.PropertyToID("_GBufferTexture0"),

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

         static ComputeBuffer s_EnvLightDatas = null;
         static ComputeBuffer s_shadowDatas = null;
 
-        static Texture2DArray m_DefaultTexture2DArray;
-        static Cubemap m_DefaultTextureCube;
+        static Texture2DArray s_DefaultTexture2DArray;
+        static Cubemap s_DefaultTextureCube;
+
+        static HDAdditionalReflectionData defaultHDAdditionalReflectionData { get { return ComponentSingleton<HDAdditionalReflectionData>.instance; } }
+        static HDAdditionalLightData defaultHDAdditionalLightData { get { return ComponentSingleton<HDAdditionalLightData>.instance; } }
+        static HDAdditionalCameraData defaultHDAdditionalCameraData { get { return ComponentSingleton<HDAdditionalCameraData>.instance; } }
 
         ReflectionProbeCache m_ReflectionProbeCache;
         TextureCache2D m_CookieTexArray;
 
         FrameSettings m_FrameSettings = null;
         RenderPipelineResources m_Resources = null;
-
-        // this defualt additionalLightData is use for lights that don't have any (like preview light)
-        HDAdditionalLightData defaultHDAdditionalLightData = new HDAdditionalLightData();
-        HDAdditionalReflectionData defaultHDAdditionalReflectionData = new HDAdditionalReflectionData();
 
         // Following is an array of material of size eight for all combination of keyword: OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
         Material[] m_deferredLightingMaterial;
 
             m_DebugViewTilesMaterial = CoreUtils.CreateEngineMaterial(m_Resources.debugViewTilesShader);
 
-            m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
-            m_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
-            m_DefaultTexture2DArray.Apply();
+            s_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
+            s_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
+            s_DefaultTexture2DArray.Apply();
-            m_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
-            m_DefaultTextureCube.Apply();
+            s_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
+            s_DefaultTextureCube.Apply();
 
 #if UNITY_EDITOR
             UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
             // TODO: Currently m_maxShadowDistance is based on shadow settings, but this value is define for a whole level. We should be able to change this value during gameplay
             float scale;
             float bias;
-            GetSCaleAndBiasForLinearDistanceFade(m_maxShadowDistance, out scale, out bias);
+            GetScaleAndBiasForLinearDistanceFade(m_maxShadowDistance, out scale, out bias);
             directionalLightData.fadeDistanceScaleAndBias = new Vector2(scale, bias);
             directionalLightData.shadowMaskSelector = Vector4.zero;
 
             return true;
         }
 
-        void GetSCaleAndBiasForLinearDistanceFade(float fadeDistance, out float scale, out float bias)
+        void GetScaleAndBiasForLinearDistanceFade(float fadeDistance, out float scale, out float bias)
         {
             // Fade with distance calculation is just a linear fade from 90% of fade distance to fade distance. 90% arbitrarily chosen but should work well enough.
             float distanceFadeNear = 0.9f * fadeDistance;
         {
             float scale;
             float bias;
-            GetSCaleAndBiasForLinearDistanceFade(fadeDistance, out scale, out bias);
+            GetScaleAndBiasForLinearDistanceFade(fadeDistance, out scale, out bias);
 
             return 1.0f - Mathf.Clamp01(distanceToCamera * scale + bias);
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.cs

             public Vector4 baseColor;
             [SurfaceDataAttributes("Normal", true)]
             public Vector4 normalWS;
+            [SurfaceDataAttributes("Mask", true)]
+            public Vector4 mask; 
         };
 
         [GenerateHLSL(PackingRules.Exact)]
-            Count = 2
+            Count = 3
         };
 
         //-----------------------------------------------------------------------------
 		// 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};
-       static RenderTextureReadWrite[] m_RTReadWrite = { RenderTextureReadWrite.sRGB, RenderTextureReadWrite.Linear};
+	   static RenderTextureFormat[] m_RTFormat = { RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB32 };
+	   static RenderTextureReadWrite[] m_RTReadWrite = { RenderTextureReadWrite.sRGB, RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear };
 
        static public void GetMaterialDBufferDescription(out RenderTextureFormat[] RTFormat, out RenderTextureReadWrite[] RTReadWrite)
        {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.cs.hlsl

 //
 #define DEBUGVIEW_DECAL_DECALSURFACEDATA_BASE_COLOR (10000)
 #define DEBUGVIEW_DECAL_DECALSURFACEDATA_NORMAL_WS (10001)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK (10002)
-#define DBUFFERMATERIAL_COUNT (2)
+#define DBUFFERMATERIAL_COUNT (3)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Decal+DecalSurfaceData
 // PackingRules = Exact
     float4 normalWS;
+    float4 mask;
 };
 
 //
             break;
         case DEBUGVIEW_DECAL_DECALSURFACEDATA_NORMAL_WS:
             result = decalsurfacedata.normalWS.xyz;
+            break;
+        case DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK:
+            result = decalsurfacedata.mask.xyz;
             break;
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.hlsl

 #endif
 #endif // #ifdef DBUFFERMATERIAL_COUNT
 
+CBUFFER_START(UnityDecalParameters)
+	uint _EnableDBuffer;
+CBUFFER_END
-                        out DBufferType1 outDBuffer1
+                        out DBufferType1 outDBuffer1,
+						out DBufferType2 outDBuffer2
+	outDBuffer2 = surfaceData.mask;	
+    DBufferType2 inDBuffer2,
     out DecalSurfaceData surfaceData
 )
 {
 	surfaceData.normalWS.w = inDBuffer1.w;
+	surfaceData.mask = inDBuffer2;
 }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.shader

     {      
         _BaseColorMap("BaseColorMap", 2D) = "white" {}
 		_NormalMap("NormalMap", 2D) = "bump" {}     // Tangent space normal map
+		_MaskMap("MaskMap", 2D) = "white" {}    
 		_DecalBlend("_DecalBlend", Range(0.0, 1.0)) = 0.5
     }
 
     //-------------------------------------------------------------------------------------
 	#pragma shader_feature _COLORMAP
 	#pragma shader_feature _NORMALMAP
+	#pragma shader_feature _MASKMAP
 
 
     //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalData.hlsl

 {
 	surfaceData.baseColor = float4(0,0,0,0);
 	surfaceData.normalWS = float4(0,0,0,0);
+	surfaceData.mask = float4(0,0,0,0);
-	totalBlend *= surfaceData.baseColor.w;
-	surfaceData.baseColor.w = totalBlend;
+	surfaceData.baseColor.w *= totalBlend;
 #endif
 	UVMapping texCoord;
 	ZERO_INITIALIZE(UVMapping, texCoord);
 	surfaceData.normalWS.w = totalBlend;
 #endif
+#if _MASKMAP
+	surfaceData.mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, texCoordDS.xy); 
+	surfaceData.mask.z = totalBlend;
+#endif
+
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalProperties.hlsl

 SAMPLER(sampler_BaseColorMap);
 TEXTURE2D(_NormalMap);
 SAMPLER(sampler_NormalMap);
+TEXTURE2D(_MaskMap);
+SAMPLER(sampler_MaskMap);
 
 float _DecalBlend;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalUtilities.hlsl

 
 void AddDecalContribution(uint2 unPositionSS, inout SurfaceData surfaceData)
 {
-    // Currently disabled
-#if 0
-	FETCH_DBUFFER(DBuffer, _DBufferTexture, unPositionSS);
-	DecalSurfaceData decalSurfaceData;
-	DECODE_FROM_DBUFFER(DBuffer, decalSurfaceData);
+	if(_EnableDBuffer)
+	{
+		FETCH_DBUFFER(DBuffer, _DBufferTexture, unPositionSS);
+		DecalSurfaceData decalSurfaceData;
+		DECODE_FROM_DBUFFER(DBuffer, decalSurfaceData);
-	surfaceData.baseColor.xyz = lerp(surfaceData.baseColor.xyz, decalSurfaceData.baseColor.xyz, decalSurfaceData.baseColor.w);
-	surfaceData.normalWS.xyz = normalize(lerp(surfaceData.normalWS.xyz, decalSurfaceData.normalWS.xyz, decalSurfaceData.normalWS.w));
-#endif
+		surfaceData.baseColor.xyz = lerp(surfaceData.baseColor.xyz, decalSurfaceData.baseColor.xyz, decalSurfaceData.baseColor.w);
+		surfaceData.normalWS.xyz = normalize(lerp(surfaceData.normalWS.xyz, decalSurfaceData.normalWS.xyz, decalSurfaceData.normalWS.w));
+		surfaceData.metallic = lerp(surfaceData.metallic, decalSurfaceData.mask.x, decalSurfaceData.mask.z);
+		surfaceData.ambientOcclusion = lerp(surfaceData.ambientOcclusion, decalSurfaceData.mask.y, decalSurfaceData.mask.z);
+		surfaceData.perceptualSmoothness = lerp(surfaceData.perceptualSmoothness, decalSurfaceData.mask.w, decalSurfaceData.mask.z);
+	}
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitProperties.hlsl

 
 #endif
 
-CBUFFER_START(_PerMaterial)
+CBUFFER_START(UnityPerMaterial)
 
 // shared constant between lit and layered lit
 float _AlphaCutoff;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Unlit/UnlitProperties.hlsl

-float4  _UnlitColor;
-TEXTURE2D(_UnlitColorMap);
-SAMPLER(sampler_UnlitColorMap);
-float4 _UnlitColorMap_ST;
-
-float3 _EmissiveColor;
+TEXTURE2D(_UnlitColorMap);
+SAMPLER(sampler_UnlitColorMap);
+
+
+CBUFFER_START(UnityPerMaterial)
+
+float4  _UnlitColor;
+float4 _UnlitColorMap_ST;
+
+float3 _EmissiveColor;
 float4 _EmissiveColorMap_ST;
 
 float _EmissiveIntensity;
 // In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it.
 // TODO: Fix the code in legacy unity so we can customize the behavior for GI
 float3 _EmissionColor;
+
+CBUFFER_END

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableSSSAndTransmission, () => frameSettings.enableSSSAndTransmission, (value) => frameSettings.enableSSSAndTransmission = (bool)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kForwardOnly, () => frameSettings.enableForwardRenderingOnly, (value) => frameSettings.enableForwardRenderingOnly = (bool)value);
-            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kDeferredDepthPrepassATestOnly, () => frameSettings.enableDepthPrepassWithDeferredRendering, (value) => frameSettings.enableDepthPrepassWithDeferredRendering = (bool)value);
-            DebugMenuManager.instance.AddDebugItem<bool>(menuName, KEnableTransparentPrepass, () => frameSettings.enableAlphaTestOnlyInDeferredPrepass, (value) => frameSettings.enableAlphaTestOnlyInDeferredPrepass = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kDeferredDepthPrepass, () => frameSettings.enableDepthPrepassWithDeferredRendering, (value) => frameSettings.enableDepthPrepassWithDeferredRendering = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>(menuName, kDeferredDepthPrepassATestOnly, () => frameSettings.enableAlphaTestOnlyInDeferredPrepass, (value) => frameSettings.enableAlphaTestOnlyInDeferredPrepass = (bool)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, KEnableTransparentPrepass, () => frameSettings.enableTransparentPrepass, (value) => frameSettings.enableTransparentPrepass = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>(menuName, kEnableMotionVectors, () => frameSettings.enableMotionVectors, (value) => frameSettings.enableMotionVectors = (bool)value);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 // As I haven't change the variables name yet, I simply don't define anything, and I put the transform function at the end of the file outside the guard header.
 // This need to be fixed.
 
-#if defined (DIRECTIONAL_COOKIE) || defined (DIRECTIONAL)
-    #define USING_DIRECTIONAL_LIGHT
-#endif
-
 #if defined(UNITY_SINGLE_PASS_STEREO) || defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
     #define USING_STEREO_MATRICES
 #endif
 
 // ----------------------------------------------------------------------------
 
-CBUFFER_START(UnityPerDraw : register(b0))
-#ifdef UNITY_USE_PREMULTIPLIED_MATRICES
-    float4x4 glstate_matrix_mvp;
-    float4x4 glstate_matrix_modelview0;
-    float4x4 glstate_matrix_invtrans_modelview0;
-#endif
+CBUFFER_START(UnityPerDraw)
 
     float4x4 unity_ObjectToWorld;
     float4x4 unity_WorldToObject;
     // This contain occlusion factor from 0 to 1 for dynamic objects (no SH here)
     float4 unity_ProbesOcclusion;
 
+    // Velocity
+    float4x4 unity_MatrixPreviousM;
+    float4x4 unity_MatrixPreviousMI;
+    //X : Use last frame positions (right now skinned meshes are the only objects that use this
+    //Y : Force No Motion
+    //Z : Z bias value
+    float4 unity_MotionVectorsParams;
+
 CBUFFER_END
 
 #if defined(USING_STEREO_MATRICES)
 // TODO: Change code here so probe volume use only one transform instead of all this parameters!
 TEXTURE3D(unity_ProbeVolumeSH);
 SAMPLER(samplerunity_ProbeVolumeSH);
-
-CBUFFER_START(UnityVelocityPass)
-    float4x4 unity_MatrixNonJitteredVP;
-    float4x4 unity_MatrixPreviousVP;
-    float4x4 unity_MatrixPreviousM;
-	float4x4 unity_MatrixPreviousMI;
-    //X : Use last frame positions (right now skinned meshes are the only objects that use this
-    //Y : Force No Motion
-    //Z : Z bias value
-    float4 unity_MotionVectorsParams;
-CBUFFER_END
 
 // ----------------------------------------------------------------------------
 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset

   m_EditorClassIdentifier: 
   m_RenderPipelineResources: {fileID: 11400000, guid: 3ce144cff5783da45aa5d4fdc2da14b7,
     type: 2}
-  globalRenderingSettings:
-    useForwardRenderingOnly: 0
-    useDepthPrepassWithDeferredRendering: 0
-    renderAlphaTestOnlyInDeferredPrepass: 0
-  globalTextureSettings:
-    spotCookieSize: 128
-    pointCookieSize: 512
-    reflectionCubemapSize: 128
-    reflectionCacheCompressed: 0
+  serializedFrameSettings:
+    enableShadow: 1
+    enableSSR: 1
+    enableSSAO: 1
+    enableSSSAndTransmission: 1
+    diffuseGlobalDimmer: 1
+    specularGlobalDimmer: 1
+    enableForwardRenderingOnly: 0
+    enableDepthPrepassWithDeferredRendering: 0
+    enableAlphaTestOnlyInDeferredPrepass: 0
+    enableTransparentPrepass: 1
+    enableMotionVectors: 1
+    enableObjectMotionVectors: 1
+    enableDBuffer: 1
+    enableAtmosphericScattering: 1
+    enableRoughRefraction: 1
+    enableTransparentPostpass: 1
+    enableDistortion: 1
+    enablePostprocess: 1
+    enableStereo: 0
+    enableAsyncCompute: 0
+    enableOpaqueObjects: 1
+    enableTransparentObjects: 1
+    enableMSAA: 0
+    enableShadowMask: 1
+    lightLoopSettings:
+      enableTileAndCluster: 1
+      enableComputeLightEvaluation: 1
+      enableComputeLightVariants: 1
+      enableComputeMaterialVariants: 1
+      enableFptlForForwardOpaque: 1
+      enableBigTilePrepass: 1
+      isFptlEnabled: 1
+  renderPipelineSettings:
+    supportShadowMask: 1
+    supportSSR: 1
+    supportSSAO: 1
+    supportSSSAndTransmission: 1
+    supportDBuffer: 0
+    supportMSAA: 0
+    supportAsyncCompute: 0
+    lightLoopSettings:
+      spotCookieSize: 128
+      cookieTexArraySize: 16
+      pointCookieSize: 512
+      cubeCookieTexArraySize: 16
+      reflectionProbeCacheSize: 128
+      reflectionCubemapSize: 128
+      reflectionCacheCompressed: 0
+      skyReflectionSize: 256
+      skyLightingOverrideLayerMask:
+        serializedVersion: 2
+        m_Bits: 0
+    shadowInitParams:
+      shadowAtlasWidth: 4096
+      shadowAtlasHeight: 4096
-  lightLoopSettings:
-    enableTileAndCluster: 1
-    enableComputeLightEvaluation: 1
-    enableComputeLightVariants: 1
-    enableComputeMaterialVariants: 1
-    enableFptlForForwardOpaque: 1
-    enableBigTilePrepass: 1
-    enableAsyncCompute: 0
-  shadowInitParams:
-    shadowAtlasWidth: 4096
-    shadowAtlasHeight: 4096
-  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
-    type: 2}
-  m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Materials/HDRP_Default_Material.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: HDRP_Default_Material
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _MAPPING_PLANAR _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT
+  m_ShaderKeywords: _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _MAPPING_PLANAR _NORMALMAP_TANGENT_SPACE
-  m_CustomRenderQueue: 3000
-  stringTagMap:
-    RenderType: Transparent
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
   disabledShaderPasses:
   - DistortionVectors
   - TransparentDepthPrepass
     - _AlphaCutoffPostpass: 0.5
     - _AlphaCutoffPrepass: 0.5
     - _Anisotropy: 0
-    - _BlendMode: 0
+    - _BlendMode: 4
     - _CoatCoverage: 1
     - _CoatIOR: 0.5
     - _CullMode: 2
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
-    - _DstBlend: 10
+    - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _EmissiveIntensity: 0
     - _EnableBlendModePreserveSpecularLighting: 1
     - _Stiffness: 1
     - _SubsurfaceProfile: 0
     - _SubsurfaceRadius: 1
-    - _SurfaceType: 1
+    - _SurfaceType: 0
     - _TexWorldScale: 1
     - _Thickness: 1
     - _ThicknessMultiplier: 1
     - _UVBase: 4
     - _UVDetail: 0
     - _ZTestMode: 8
-    - _ZWrite: 0
+    - _ZWrite: 1
     m_Colors:
     - _BaseColor: {r: 0.7294118, g: 0.7294118, b: 0.7294118, a: 1}
     - _Color: {r: 0.7294118, g: 0.7294118, b: 0.7294118, a: 1}

ImageTemplates/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask.unity.png.meta

+fileFormatVersion: 2
+guid: 2251e56c7d653754d8312d70aa2dd2e8
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/Core/CoreRP/ComponentSingleton.cs

+namespace UnityEngine.Experimental.Rendering
+{
+    // Use this class to get a static instance of a component
+    // Mainly used to have a default instance
+    public static class ComponentSingleton<TType>
+        where TType : Component
+    {
+        static TType s_Instance = null;
+        public static TType instance
+        {
+            get
+            {
+                return s_Instance ?? (s_Instance = new GameObject("Default " + typeof(TType))
+                {
+                    hideFlags = HideFlags.HideAndDontSave
+                }.AddComponent<TType>());
+            }
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/ComponentSingleton.cs.meta

+fileFormatVersion: 2
+guid: f78c611171f4b4946b5cf8394378931f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask.unity.meta

+fileFormatVersion: 2
+guid: 1029947770f955b4290bbdd8b641f7f1
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/LightingData.asset.meta

+fileFormatVersion: 2
+guid: 543a6061485cba84e9be181cc70a2380
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 25800000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/Lightmap-0_comp_dir.png.meta

+fileFormatVersion: 2
+guid: 5eedfaeaa2a1c3b43b273659ca71366e
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 3
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/Lightmap-0_comp_light.exr.meta

+fileFormatVersion: 2
+guid: a7160c7cb29c6ab4aab21cd07fc4d5b1
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 3
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 0
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 6
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/Lightmap-0_comp_shadowmask.png.meta

+fileFormatVersion: 2
+guid: d2614e41e9e7dba459ff0344ea63f964
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 3
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 2
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/ReflectionProbe-0.exr

+v/1
channelschlist7B


G


R


compressioncompression
dataWindowbox2i�displayWindowbox2i�lineOrderlineOrder
pixelAspectRatiofloat�?screenWindowCenterv2fscreenWindowWidthfloat�?Y
�u�
�~

@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������ �
�~

@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������@�
�~

@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������`�
�~

@������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/ReflectionProbe-0.exr.meta

+fileFormatVersion: 2
+guid: 5a8eb32869aac434daf4ea01808cb4e4
+TextureImporter:
+  fileIDToRecycleName:
+    8900000: generatedCubemap
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 1
+  seamlessCubemap: 1
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 2
+    aniso: 0
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 2
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 100
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: