MaterialUpdater: Updated to work with current state of affairs. Added options for converting keywords to properties, configurable input/output shaders on standard type upgraders, finalizer delegate option for material post-processing (like setting keywords etc).

Assets/ScriptableRenderPipeline/Editor/MaterialUpgrader.cs

 {
     public class MaterialUpgrader
     {
+        public delegate void MaterialFinalizer(Material mat);
+
+        MaterialFinalizer m_Finalizer;
+
+        class KeywordFloatRename
+        {
+            public string keyword;
+            public string property;
+            public float setVal, unsetVal;
+        }
+        List<KeywordFloatRename> m_KeywordFloatRename = new List<KeywordFloatRename>();
 
         [Flags]
         public enum UpgradeFlags
             material.shader = Shader.Find(m_NewShader);
             material.CopyPropertiesFromMaterial(newMaterial);
             UnityEngine.Object.DestroyImmediate(newMaterial);
+
+            if(m_Finalizer != null)
+                m_Finalizer(material);
         }
 
         // Overridable function to implement custom material upgrading functionality
 
             foreach (var t in m_ColorRename)
                 dstMaterial.SetColor(t.Value, srcMaterial.GetColor(t.Key));
+
+            foreach (var t in m_KeywordFloatRename)
+                dstMaterial.SetFloat(t.property, srcMaterial.IsKeywordEnabled(t.keyword) ? t.setVal : t.unsetVal);
-        public void RenameShader(string oldName, string newName)
+        public void RenameShader(string oldName, string newName, MaterialFinalizer finalizer)
+            m_Finalizer = finalizer;
         }
 
         public void RenameTexture(string oldName, string newName)
         public void RenameColor(string oldName, string newName)
         {
             m_ColorRename[oldName] = newName;
+        }
+
+        public void RenameKeywordToFloat(string oldName, string newName, float setVal, float unsetVal)
+        {
+            m_KeywordFloatRename.Add(new KeywordFloatRename { keyword = oldName, property = newName, setVal = setVal, unsetVal = unsetVal });
         }
 
         static bool IsMaterialPath(string path)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/UpgradeStandardShaderMaterials.cs

 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
-	public class UpgradeStandardShaderMaterials
+    public class UpgradeStandardShaderMaterials
-            upgraders.Add(new StandardToHDLitMaterialUpgrader());
-            upgraders.Add(new StandardSpecularToHDLitMaterialUpgrader());
+            upgraders.Add(new StandardToHDLitMaterialUpgrader("Standard", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass));
+            upgraders.Add(new StandardSpecularToHDLitMaterialUpgrader("Standard (Specular setup)", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass));
             return upgraders;
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/StandardSpecularToHDLitMaterialUpgrader.cs

 {
     class StandardSpecularToHDLitMaterialUpgrader : MaterialUpgrader
     {
-        public StandardSpecularToHDLitMaterialUpgrader()
+        public StandardSpecularToHDLitMaterialUpgrader() : this("Standard (Specular setup)", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass) {}
+
+        public StandardSpecularToHDLitMaterialUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer)
-            RenameShader("Standard (Specular setup)", "HDRenderPipeline/LitLegacySupport");
+            RenameShader(sourceShaderName, destShaderName, finalizer);
 
             RenameTexture("_MainTex", "_BaseColorMap");
             RenameColor("_Color", "_BaseColor");
             RenameColor("_EmissionColor", "_EmissiveColor");
             RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+            RenameFloat("_Cutoff", "_AlphaCutoff");
+            RenameKeywordToFloat("_ALPHATEST_ON", "_AlphaCutoffEnable", 1f, 0f);
+
+            // the HD renderloop packs detail albedo and detail normals into a single texture.
+            // mapping the detail normal map, if any, to the detail map, should do the right thing if
+            // there is no detail albedo.
             RenameTexture("_DetailNormalMap", "_DetailMap");
 
             // Anything reasonable that can be done here?
         [Test]
         public void UpgradeMaterial()
         {
-            var newShader = Shader.Find("HDRenderPipeline/LitLegacySupport");
+            var newShader = Shader.Find("HDRenderPipeline/Lit");
             var mat = new Material(Shader.Find("Standard (Specular setup)"));
             var albedo = new Texture2D(1, 1);
             var normals = new Texture2D(1, 1);
             mat.color = color;
             mat.SetTextureScale("_MainTex", baseScale);
 
-            MaterialUpgrader.Upgrade(mat, new StandardSpecularToHDLitMaterialUpgrader(), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+            MaterialUpgrader.Upgrade(mat, this, MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
 
             Assert.AreEqual(newShader, mat.shader);
             Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
+            Assert.IsTrue(mat.IsKeywordEnabled("_NORMALMAP"));
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/StandardToHDLitMaterialUpgrader.cs

 using UnityEngine;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
-
-	class StandardToHDLitMaterialUpgrader : MaterialUpgrader
+    class StandardToHDLitMaterialUpgrader : MaterialUpgrader
-        public StandardToHDLitMaterialUpgrader()
+        public StandardToHDLitMaterialUpgrader() : this("Standard", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass) { }
+
+        public StandardToHDLitMaterialUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer)
-            RenameShader("Standard", "HDRenderPipeline/LitLegacySupport");
+            RenameShader(sourceShaderName, destShaderName, finalizer);
 
             RenameTexture("_MainTex", "_BaseColorMap");
             RenameColor("_Color", "_BaseColor");
             RenameColor("_EmissionColor", "_EmissiveColor");
             RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+            RenameFloat("_Cutoff", "_AlphaCutoff");
+            RenameKeywordToFloat("_ALPHATEST_ON", "_AlphaCutoffEnable", 1f, 0f);
 
             // the HD renderloop packs detail albedo and detail normals into a single texture.
             // mapping the detail normal map, if any, to the detail map, should do the right thing if
         [Test]
         public void UpgradeMaterial()
         {
-            var newShader = Shader.Find("HDRenderPipeline/LitLegacySupport");
+            var newShader = Shader.Find("HDRenderPipeline/Lit");
             var mat = new Material(Shader.Find("Standard"));
             var albedo = new Texture2D(1, 1);
             var normals = new Texture2D(1, 1);
             mat.color = color;
             mat.SetTextureScale("_MainTex", baseScale);
 
-
-            MaterialUpgrader.Upgrade(mat, new StandardToHDLitMaterialUpgrader(), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+            MaterialUpgrader.Upgrade(mat, this, MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
 
             Assert.AreEqual(newShader, mat.shader);
             Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
+            Assert.IsTrue(mat.IsKeywordEnabled("_NORMALMAP"));
         }
     }
 }