Upgrade Lightweight shaders and UI to closer match HD and Shader Graph

- Upgrades to Standard, Simple Standard and Unlit
- Split Rendering Mode into Surface Type and Blending Mode
- Add premultiply option to Simple Standard
- Make Alpha Clip Orthogonal
- Add two sided toggle
- Add Additive and Multiply blend modes
- Rename all blend modes to match HD and SG
- Rename Alpha Cutoff to Clip Threshold
- Remove unused "_ALPHABLEND" keyword
- Split premultiply and clip keywords
- Update material upgrader to reflect changes
- Various shader GUI fixes

Keywords: Adds 1 to Simple, Removes 1 from Unlit, PBR stays the same

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightMaterialUpgrader.cs

     {
         static public UpgradeParams diffuseOpaque = new UpgradeParams()
         {
-            blendMode = UpgradeBlendMode.Opaque,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = false,
             specularSource = SpecularSource.NoSpecular,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
-            blendMode = UpgradeBlendMode.Opaque,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = false,
             specularSource = SpecularSource.SpecularTextureAndColor,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
+            surfaceType = UpgradeSurfaceType.Transparent,
+            alphaClip = false,
             specularSource = SpecularSource.NoSpecular,
             glosinessSource = GlossinessSource.SpecularAlpha,
         };
+            surfaceType = UpgradeSurfaceType.Transparent,
+            alphaClip = false,
             specularSource = SpecularSource.SpecularTextureAndColor,
             glosinessSource = GlossinessSource.SpecularAlpha,
         };
-            blendMode = UpgradeBlendMode.Cutout,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = true,
             specularSource = SpecularSource.NoSpecular,
             glosinessSource = GlossinessSource.SpecularAlpha,
         };
-            blendMode = UpgradeBlendMode.Cutout,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = true,
             specularSource = SpecularSource.SpecularTextureAndColor,
             glosinessSource = GlossinessSource.SpecularAlpha,
         };
-            blendMode = UpgradeBlendMode.Opaque,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = false,
             specularSource = SpecularSource.NoSpecular,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
-            blendMode = UpgradeBlendMode.Opaque,
+            surfaceType = UpgradeSurfaceType.Opaque,
+            blendMode = UpgradeBlendMode.Alpha,
+            alphaClip = false,
             specularSource = SpecularSource.SpecularTextureAndColor,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
+            surfaceType = UpgradeSurfaceType.Transparent,
+            alphaClip = false,
             specularSource = SpecularSource.NoSpecular,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
+            surfaceType = UpgradeSurfaceType.Transparent,
+            alphaClip = false,
             specularSource = SpecularSource.SpecularTextureAndColor,
             glosinessSource = GlossinessSource.BaseAlpha,
         };
         public StandardSimpleLightingUpgrader(string oldShaderName, UpgradeParams upgradeParams)
         {
             RenameShader(oldShaderName, LightweightShaderUtils.GetShaderPath(ShaderPathID.STANDARD_SIMPLE_LIGHTING), UpdateMaterialKeywords);
-            SetFloat("_Mode", (float)upgradeParams.blendMode);
+            SetFloat("_Surface", (float)upgradeParams.surfaceType);
+            SetFloat("_Blend", (float)upgradeParams.blendMode);
+            SetFloat("_AlphaClip", upgradeParams.alphaClip ? 1 : 0);
             SetFloat("_SpecSource", (float)upgradeParams.specularSource);
             SetFloat("_GlossinessSource", (float)upgradeParams.glosinessSource);
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightShaderGUI.cs

 
 public abstract class LightweightShaderGUI : ShaderGUI
 {
-    public enum BlendMode
+    public enum SurfaceType
-        Cutout,
-        Fade,   // Old school alpha-blending mode, fresnel does not affect amount of transparency
-        Transparent // Physically plausible transparency mode, implemented as alpha pre-multiply
+        Transparent
+    }
+
+    public enum BlendMode
+    {
+        Alpha,   // Old school alpha-blending mode, fresnel does not affect amount of transparency
+        Premultiply, // Physically plausible transparency mode, implemented as alpha pre-multiply
+        Additive,
+        Multiply
     }
 
     public abstract void FindProperties(MaterialProperty[] props);
 
     public static void SetupMaterialBlendMode(Material material)
     {
-        BlendMode blendMode = (BlendMode)material.GetFloat("_Mode");
-        switch (blendMode)
+        bool alphaClip = material.GetFloat("_AlphaClip") == 1;
+        if(alphaClip)
+            material.EnableKeyword("_ALPHATEST_ON");
+        else
+            material.DisableKeyword("_ALPHATEST_ON");
+
+        SurfaceType surfaceType = (SurfaceType)material.GetFloat("_Surface");
+        if(surfaceType == SurfaceType.Opaque)
-            case BlendMode.Opaque:
-                material.SetOverrideTag("RenderType", "");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.DisableKeyword("_ALPHATEST_ON");
-                material.DisableKeyword("_ALPHABLEND_ON");
-                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
-                material.renderQueue = -1;
-                material.SetShaderPassEnabled("ShadowCaster", true);
-                break;
-            case BlendMode.Cutout:
-                material.SetOverrideTag("RenderType", "TransparentCutout");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.EnableKeyword("_ALPHATEST_ON");
-                material.DisableKeyword("_ALPHABLEND_ON");
-                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
-                material.SetShaderPassEnabled("ShadowCaster", true);
-                break;
-            case BlendMode.Fade:
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                material.SetInt("_ZWrite", 0);
-                material.DisableKeyword("_ALPHATEST_ON");
-                material.EnableKeyword("_ALPHABLEND_ON");
-                material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
-                material.SetShaderPassEnabled("ShadowCaster", false);
-                break;
-            case BlendMode.Transparent:
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                material.SetInt("_ZWrite", 0);
-                material.DisableKeyword("_ALPHATEST_ON");
-                material.DisableKeyword("_ALPHABLEND_ON");
-                material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
-                material.SetShaderPassEnabled("ShadowCaster", false);
-                break;
+            material.SetOverrideTag("RenderType", "");
+            material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+            material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+            material.SetInt("_ZWrite", 1);
+            material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+            material.renderQueue = -1;
+            material.SetShaderPassEnabled("ShadowCaster", true);
+        }
+        else
+        { 
+            BlendMode blendMode = (BlendMode)material.GetFloat("_Blend");
+            switch (blendMode)
+            {
+                case BlendMode.Alpha:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+                case BlendMode.Premultiply:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                    material.SetInt("_ZWrite", 0);
+                    material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+                case BlendMode.Additive:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+                case BlendMode.Multiply:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+            }
         }
     }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardGUI.cs

 
         private static class Styles
         {
+            public static GUIContent twoSidedText = new GUIContent("Two Sided", "Render front and back faces");
+            public static GUIContent alphaClipText = new GUIContent("Alpha Clip", "Enable Alpha Clip");
-            public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+            public static GUIContent clipThresholdText = new GUIContent("Clip Threshold", "Threshold for alpha clip");
             public static GUIContent specularMapText = new GUIContent("Specular", "Specular (RGB) and Smoothness (A)");
             public static GUIContent metallicMapText = new GUIContent("Metallic", "Metallic (R) and Smoothness (A)");
             public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness value");
             public static string secondaryMapsText = "Secondary Maps";
             public static string forwardText = "Forward Rendering Options";
             public static string workflowModeText = "Workflow Mode";
-            public static string renderingMode = "Rendering Mode";
+            public static string surfaceType = "Surface Type";
+            public static string blendingMode = "Blending Mode";
+            public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
             public static readonly string[] blendNames = Enum.GetNames(typeof(BlendMode));
             public static readonly string[] metallicSmoothnessChannelNames = {"Metallic Alpha", "Albedo Alpha"};
             public static readonly string[] specularSmoothnessChannelNames = {"Specular Alpha", "Albedo Alpha"};
+        private MaterialProperty surfaceType;
+        private MaterialProperty culling;
+        private MaterialProperty alphaClip;
-        private MaterialProperty alphaCutoff;
+        private MaterialProperty alphaThreshold;
 
         private MaterialProperty smoothness;
         private MaterialProperty smoothnessScale;
         public override void FindProperties(MaterialProperty[] properties)
         {
             workflowMode = FindProperty("_WorkflowMode", properties);
-            blendMode = FindProperty("_Mode", properties);
+            surfaceType = FindProperty("_Surface", properties);
+            blendMode = FindProperty("_Blend", properties);
+            culling = FindProperty("_Cull", properties);
+            alphaClip  = FindProperty("_AlphaClip", properties);
-            alphaCutoff = FindProperty("_Cutoff", properties);
+            alphaThreshold = FindProperty("_Cutoff", properties);
 
             smoothness = FindProperty("_Glossiness", properties);
             smoothnessScale = FindProperty("_GlossMapScale", properties, false);
             EditorGUI.BeginChangeCheck();
             {
                 DoPopup(Styles.workflowModeText, workflowMode, Styles.workflowNames);
-                DoPopup(Styles.renderingMode, blendMode, Styles.blendNames);
+                DoPopup(Styles.surfaceType, surfaceType, Styles.surfaceNames);
+                if ((SurfaceType)material.GetFloat("_Surface") == SurfaceType.Transparent)
+                    DoPopup(Styles.blendingMode, blendMode, Styles.blendNames);
+
+                EditorGUI.BeginChangeCheck();
+                bool twoSidedEnabled = EditorGUILayout.Toggle(Styles.twoSidedText, culling.floatValue == 0);
+                if (EditorGUI.EndChangeCheck())
+                    culling.floatValue = twoSidedEnabled ? 0 : 2;
+
+                EditorGUI.BeginChangeCheck();
+                bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipText, alphaClip.floatValue == 1);
+                if (EditorGUI.EndChangeCheck())
+                    alphaClip.floatValue = alphaClipEnabled ? 1 : 0;
 
                 // Primary properties
                 GUILayout.Label(Styles.primaryMapsText, EditorStyles.boldLabel);
                 return;
             }
 
-            BlendMode blendMode = BlendMode.Opaque;
+            SurfaceType surfaceType = SurfaceType.Opaque;
+            BlendMode blendMode = BlendMode.Alpha;
-                blendMode = BlendMode.Cutout;
+                surfaceType = SurfaceType.Opaque;
+                material.SetFloat("_AlphaClip", 1);
-                blendMode = BlendMode.Fade;
+                surfaceType = SurfaceType.Transparent;
+                blendMode = BlendMode.Alpha;
-            material.SetFloat("_Mode", (float)blendMode);
+            material.SetFloat("_Surface", (float)surfaceType);
+            material.SetFloat("_Blend", (float)blendMode);
 
             if (oldShader.name.Equals("Standard (Specular setup)"))
             {
         void DoAlbedoArea(Material material)
         {
             m_MaterialEditor.TexturePropertySingleLine(Styles.albedoText, albedoMap, albedoColor);
-            if (((BlendMode)material.GetFloat("_Mode") == BlendMode.Cutout))
+            if (material.GetFloat("_AlphaClip") == 1)
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
+                m_MaterialEditor.ShaderProperty(alphaThreshold, Styles.clipThresholdText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
             }
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardSimpleLightingGUI.cs

 public class LightweightStandardSimpleLightingGUI : LightweightShaderGUI
 {
     private const float kMinShininessValue = 0.01f;
+    private MaterialProperty surfaceTypeProp;
+    private MaterialProperty culling;
+    private MaterialProperty alphaClip;
-    private MaterialProperty alphaCutoffProp;
+    private MaterialProperty alphaThresholdProp;
     private MaterialProperty specularSourceProp;
     private MaterialProperty glossinessSourceProp;
     private MaterialProperty specularGlossMapProp;
 
     private static class Styles
     {
+        public static GUIContent twoSidedLabel = new GUIContent("Two Sided", "Render front and back faces");
+        public static GUIContent alphaClipLabel = new GUIContent("Alpha Clip", "Enable Alpha Clip");
+
         public static GUIContent[] albedoGlosinessLabels =
         {
             new GUIContent("Base (RGB) Glossiness (A)", "Base Color (RGB) and Glossiness (A)"),
         public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map");
         public static GUIContent emissionMapLabel = new GUIContent("Emission Map", "Emission Map");
 
+        public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
-        public static string renderingModeLabel = "Rendering Mode";
+        public static string surfaceTypeLabel = "Surface Type";
+        public static string blendingModeLabel = "Blending Mode";
         public static string specularSourceLabel = "Specular";
         public static string glossinessSourceLabel = "Glossiness Source";
         public static string glossinessSource = "Glossiness Source";
-        public static string alphaCutoffLabel = "Alpha Cutoff";
+        public static string clipThresholdLabel = "Clip Threshold";
         public static string shininessLabel = "Shininess";
         public static string normalMapLabel = "Normal map";
         public static string emissionColorLabel = "Emission Color";
     public override void FindProperties(MaterialProperty[] properties)
     {
-        blendModeProp = FindProperty("_Mode", properties);
+        surfaceTypeProp = FindProperty("_Surface", properties);
+        blendModeProp = FindProperty("_Blend", properties);
+        culling = FindProperty("_Cull", properties);
+        alphaClip  = FindProperty("_AlphaClip", properties);
-
-        alphaCutoffProp = FindProperty("_Cutoff", properties);
+        alphaThresholdProp = FindProperty("_Cutoff", properties);
         specularSourceProp = FindProperty("_SpecSource", properties);
         glossinessSourceProp = FindProperty("_GlossinessSource", properties);
         specularGlossMapProp = FindProperty("_SpecGlossMap", properties);
     {
         EditorGUI.BeginChangeCheck();
         {
-            DoBlendMode();
-
-            EditorGUILayout.Space();
+            DoSurfaceArea();
             DoSpecular();
 
             EditorGUILayout.Space();
         StandardSimpleLightingUpgrader.UpdateMaterialKeywords(material);
     }
 
-    private void DoBlendMode()
+    private void DoSurfaceArea()
-        int modeValue = (int)blendModeProp.floatValue;
+        int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
-        modeValue = EditorGUILayout.Popup(Styles.renderingModeLabel, modeValue, Styles.blendNames);
+        surfaceTypeValue = EditorGUILayout.Popup(Styles.surfaceTypeLabel, surfaceTypeValue, Styles.surfaceNames);
-            blendModeProp.floatValue = modeValue;
+            surfaceTypeProp.floatValue = surfaceTypeValue;
+
+        if((SurfaceType)surfaceTypeValue == SurfaceType.Transparent)
+        {
+            int blendModeValue = (int)blendModeProp.floatValue;
+            EditorGUI.BeginChangeCheck();
+            blendModeValue = EditorGUILayout.Popup(Styles.blendingModeLabel, blendModeValue, Styles.blendNames);
+            if (EditorGUI.EndChangeCheck())
+                blendModeProp.floatValue = blendModeValue;
+        }
-        UpgradeBlendMode mode = (UpgradeBlendMode)blendModeProp.floatValue;
+        EditorGUI.BeginChangeCheck();
+        bool twoSidedEnabled = EditorGUILayout.Toggle(Styles.twoSidedLabel, culling.floatValue == 0);
+        if (EditorGUI.EndChangeCheck())
+            culling.floatValue = twoSidedEnabled ? 0 : 2;
+        EditorGUI.BeginChangeCheck();
+        bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipLabel, alphaClip.floatValue == 1);
+        if (EditorGUI.EndChangeCheck())
+            alphaClip.floatValue = alphaClipEnabled ? 1 : 0;
+        
-        if (mode == UpgradeBlendMode.Opaque)
+        if ((SurfaceType)surfaceTypeValue == SurfaceType.Opaque)
-            m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
-            if (mode == UpgradeBlendMode.Cutout)
-                m_MaterialEditor.RangeProperty(alphaCutoffProp, "Cutoff");
+        if (alphaClipEnabled)
+            m_MaterialEditor.ShaderProperty(alphaThresholdProp, Styles.clipThresholdLabel, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
     }
 
     private void DoSpecular()
 
         if (oldShaderName.Contains("Transp"))
         {
+            shaderUpgradeParams.surfaceType = UpgradeSurfaceType.Transparent;
+            shaderUpgradeParams.alphaClip = false;
-            shaderUpgradeParams.blendMode = UpgradeBlendMode.Cutout;
+            shaderUpgradeParams.surfaceType = UpgradeSurfaceType.Opaque;
+            shaderUpgradeParams.blendMode = UpgradeBlendMode.Alpha;
+            shaderUpgradeParams.alphaClip = true;
-            shaderUpgradeParams.blendMode = UpgradeBlendMode.Opaque;
+            shaderUpgradeParams.surfaceType = UpgradeSurfaceType.Opaque;
+            shaderUpgradeParams.blendMode = UpgradeBlendMode.Alpha;
+            shaderUpgradeParams.alphaClip = false;
             shaderUpgradeParams.glosinessSource = GlossinessSource.BaseAlpha;
         }
 
             shaderUpgradeParams.specularSource = SpecularSource.NoSpecular;
 
-        material.SetFloat("_Mode", (float)shaderUpgradeParams.blendMode);
+        material.SetFloat("_Surface", (float)shaderUpgradeParams.surfaceType);
+        material.SetFloat("_Blend", (float)shaderUpgradeParams.blendMode);
         material.SetFloat("_SpecSource", (float)shaderUpgradeParams.specularSource);
         material.SetFloat("_GlossinessSource", (float)shaderUpgradeParams.glosinessSource);
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightUnlitGUI.cs

 
 public class LightweightUnlitGUI : LightweightShaderGUI
 {
+    public enum UnlitBlendMode
+    {
+        Alpha,   // Old school alpha-blending mode, fresnel does not affect amount of transparency
+        Additive,
+        Multiply
+    }
+
+    private MaterialProperty surfaceTypeProp;
+    private MaterialProperty culling;
+    private MaterialProperty alphaClip;
     private MaterialProperty mainTexProp;
     private MaterialProperty mainColorProp;
     private MaterialProperty alphaCutoffProp;
     private static class Styles
     {
+        public static GUIContent twoSidedLabel = new GUIContent("Two Sided", "Render front and back faces");
+        public static GUIContent alphaClipLabel = new GUIContent("Alpha Clip", "Enable Alpha Clip");
+
         public static GUIContent[] mainTexLabels =
         {
             new GUIContent("MainTex (RGB)", "Base Color"),
         public static GUIContent normalMapLabel = new GUIContent("Normal Map", "Normal Map");
-        public static readonly string[] blendNames = Enum.GetNames(typeof(UpgradeBlendMode));
+        public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
+        public static readonly string[] blendNames = Enum.GetNames(typeof(UnlitBlendMode));
-        public static string renderingModeLabel = "Rendering Mode";
-        public static string alphaCutoffLabel = "Alpha Cutoff";
+        public static string surfaceTypeLabel = "Surface Type";
+        public static string blendingModeLabel = "Blending Mode";
+        public static string clipThresholdLabel = "Clip Threshold";
-        blendModeProp = FindProperty("_Mode", properties);
+        surfaceTypeProp = FindProperty("_Surface", properties);
+        blendModeProp = FindProperty("_Blend", properties);
+        culling = FindProperty("_Cull", properties);
+        alphaClip  = FindProperty("_AlphaClip", properties);
         mainTexProp = FindProperty("_MainTex", properties);
         mainColorProp = FindProperty("_Color", properties);
         alphaCutoffProp = FindProperty("_Cutoff", properties);
     {
         EditorGUI.BeginChangeCheck();
         {
-            DoPopup(Styles.renderingModeLabel, blendModeProp, Styles.blendNames);
-            int modeValue = (int)blendModeProp.floatValue;
+            DoPopup(Styles.surfaceTypeLabel, surfaceTypeProp, Styles.surfaceNames);
+            int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
+
+            if((SurfaceType)surfaceTypeValue == SurfaceType.Transparent)
+                DoPopup(Styles.blendingModeLabel, blendModeProp, Styles.blendNames);
+
+            EditorGUI.BeginChangeCheck();
+            bool twoSidedEnabled = EditorGUILayout.Toggle(Styles.twoSidedLabel, culling.floatValue == 0);
+            if (EditorGUI.EndChangeCheck())
+                culling.floatValue = twoSidedEnabled ? 0 : 2;
+
+            EditorGUI.BeginChangeCheck();
+            bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipLabel, alphaClip.floatValue == 1);
+            if (EditorGUI.EndChangeCheck())
+                alphaClip.floatValue = alphaClipEnabled ? 1 : 0;
-            GUIContent mainTexLabel = Styles.mainTexLabels[Math.Min(modeValue, 1)];
+            GUIContent mainTexLabel = Styles.mainTexLabels[Math.Min(surfaceTypeValue, 1)];
-            m_MaterialEditor.TextureScaleOffsetProperty(mainTexProp);
-            if ((UpgradeBlendMode)modeValue == UpgradeBlendMode.Cutout)
-                m_MaterialEditor.RangeProperty(alphaCutoffProp, Styles.alphaCutoffLabel);
+            if (alphaClipEnabled)
+                m_MaterialEditor.ShaderProperty(alphaCutoffProp, Styles.clipThresholdLabel, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
+
+            m_MaterialEditor.TextureScaleOffsetProperty(mainTexProp);
 
             EditorGUILayout.Space();
             m_MaterialEditor.ShaderProperty(sampleGIProp, Styles.sampleGILabel);
     {
         material.shaderKeywords = null;
         bool sampleGI = material.GetFloat("_SampleGI") >= 1.0f;
-        SetupMaterialBlendMode(material);
+
+        bool alphaClip = material.GetFloat("_AlphaClip") == 1;
+        if(alphaClip)
+            material.EnableKeyword("_ALPHATEST_ON");
+        else
+            material.DisableKeyword("_ALPHATEST_ON");
+
+        SurfaceType surfaceType = (SurfaceType)material.GetFloat("_Surface");
+        if(surfaceType == SurfaceType.Opaque)
+        {
+            material.SetOverrideTag("RenderType", "");
+            material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+            material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+            material.SetInt("_ZWrite", 1);
+            material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+            material.renderQueue = -1;
+            material.SetShaderPassEnabled("ShadowCaster", true);
+        }
+        else
+        { 
+            UnlitBlendMode blendMode = (UnlitBlendMode)material.GetFloat("_Blend");
+            switch (blendMode)
+            {
+                case UnlitBlendMode.Alpha:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+                case UnlitBlendMode.Additive:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+                case UnlitBlendMode.Multiply:
+                    material.SetOverrideTag("RenderType", "Transparent");
+                    material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                    material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                    material.SetInt("_ZWrite", 0);
+                    material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+                    material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                    material.SetShaderPassEnabled("ShadowCaster", false);
+                    break;
+            }
+        }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/UpgradeCommon.cs

 namespace UnityEditor.Experimental.Rendering.LightweightPipeline
 {
+    public enum UpgradeSurfaceType
+    {
+        Opaque,
+        Transparent
+    }
+
-        Opaque,
-        Cutout,
-        Alpha
+        Alpha,
+        Premultiply,
+        Additive,
+        Multiply
     }
 
     public enum SpecularSource
 
     public struct UpgradeParams
     {
+        public UpgradeSurfaceType surfaceType;
+        public bool alphaClip;
         public SpecularSource specularSource;
         public GlossinessSource glosinessSource;
     }

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

 
     half alpha = diffuseAlpha.a * _Color.a;
     AlphaDiscard(alpha, _Cutoff);
+#ifdef _ALPHAPREMULTIPLY_ON
+    diffuse *= alpha;
+#endif
 
 #ifdef _NORMALMAP
     half3 normalTS = Normal(uv);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

         [Enum(UV0,0,UV1,1)] _UVSec("UV Set for secondary textures", Float) = 0
 
         // Blending state
-        [HideInInspector] _Mode("__mode", Float) = 0.0
+        [HideInInspector] _Surface("__surface", Float) = 0.0
+        [HideInInspector] _Blend("__blend", Float) = 0.0
+        [HideInInspector] _AlphaClip("__clip", Float) = 0.0
+        [HideInInspector] _Cull("__cull", Float) = 2.0
     }
 
     SubShader
 
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
+            Cull[_Cull]
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard SRP library
             // -------------------------------------
             // Material Keywords
             #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
             #pragma shader_feature _METALLICSPECGLOSSMAP
             #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
 
             ZWrite On
             ZTest LEqual
+            Cull[_Cull]
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             // -------------------------------------
             // Material Keywords
             #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
             #pragma shader_feature _METALLICSPECGLOSSMAP
             #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
             // -------------------------------------
             // Material Keywords
             #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
             #pragma shader_feature _METALLICSPECGLOSSMAP
             #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

         [Enum(UV0,0,UV1,1)] _UVSec("UV Set for secondary textures", Float) = 0
 
         // Blending state
-        [HideInInspector] _Mode("__mode", Float) = 0.0
+        [HideInInspector] _Surface("__surface", Float) = 0.0
+        [HideInInspector] _Blend("__blend", Float) = 0.0
+        [HideInInspector] _AlphaClip("__clip", Float) = 0.0
+        [HideInInspector] _Cull("__cull", Float) = 2.0
     }
 
     SubShader
             // Use same blending / depth states as Standard shader
             Blend[_SrcBlend][_DstBlend]
             ZWrite[_ZWrite]
+            Cull[_Cull]
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             // -------------------------------------
             // Material Keywords
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
             #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
             #pragma shader_feature _NORMALMAP
 
             ZWrite On
             ZTest LEqual
+            Cull[_Cull]
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             // -------------------------------------
             // Material Keywords
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
             #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
             #pragma shader_feature _NORMALMAP
 
             // -------------------------------------
             // Material Keywords
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
             #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
             #pragma shader_feature _NORMALMAP

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

         _BumpMap("Normal Map", 2D) = "bump" {}
 
         // BlendMode
-        [HideInInspector] _Mode("Mode", Float) = 0.0
+        [HideInInspector] _Surface("__surface", Float) = 0.0
+        [HideInInspector] _Blend("__blend", Float) = 0.0
+        [HideInInspector] _AlphaClip("__clip", Float) = 0.0
+        [HideInInspector] _Cull("__cull", Float) = 2.0
     }
     SubShader
     {
         Blend [_SrcBlend][_DstBlend]
         ZWrite [_ZWrite]
+        Cull [_Cull]
 
         Pass
         {
             #pragma fragment frag
             #pragma multi_compile_fog
             #pragma shader_feature _SAMPLE_GI
-            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+            #pragma shader_feature _ALPHATEST_ON
             #pragma multi_compile_instancing
 
             // Lighting include is needed because of GI
                 half2 uv = IN.uv0AndFogCoord.xy;
                 half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                 half3 color = texColor.rgb * _Color.rgb;
-                half alpha = texColor.a * _Color.a;
-
+                half alpha = texColor.a * _Color.a;     
                 AlphaDiscard(alpha, _Cutoff);
 
 #if _SAMPLE_GI
                 color += SampleGI(IN.lightmapOrVertexSH, normalWS);
 #endif
                 ApplyFog(color, IN.uv0AndFogCoord.z);
-
-#ifdef _ALPHABLEND_ON
+       
-#else
-                return half4(color, 1.0);
-#endif
             }
             ENDHLSL
         }