Moved common properties to LightweightShaderGUI. Added alpha premultiply to unlit.

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

+using System;
 using UnityEditor;
 using UnityEngine;
 
         Multiply
     }
 
-    public abstract void FindProperties(MaterialProperty[] props);
-    public abstract void ShaderPropertiesGUI(Material material);
+    private static class Styles
+    {
+        public static string renderingOptionsLabel = "Rendering Options";
+        public static string surfaceType = "Surface Type";
+        public static string blendingMode = "Blending Mode";
+        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 alphaClipThresholdText = new GUIContent("Clip Threshold", "Threshold for alpha clip");
+        public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
+        public static readonly string[] blendNames = Enum.GetNames(typeof(BlendMode));
+    }
+
+    protected MaterialEditor m_MaterialEditor;
+    protected MaterialProperty surfaceTypeProp;
+    protected MaterialProperty blendModeProp;
+    protected MaterialProperty cullingProp;
+    protected MaterialProperty alphaClipProp;
+    protected MaterialProperty alphaCutoffProp;
+    private bool m_FirstTimeApply = true;
+
+    public virtual void FindProperties(MaterialProperty[] properties)
+    {
+        surfaceTypeProp = FindProperty("_Surface", properties);
+        blendModeProp = FindProperty("_Blend", properties);
+        cullingProp = FindProperty("_Cull", properties);
+        alphaClipProp = FindProperty("_AlphaClip", properties);
+        alphaCutoffProp = FindProperty("_Cutoff", properties);
+    }
+
+    public virtual void ShaderPropertiesGUI(Material material)
+    {
+        DoPopup(Styles.surfaceType, surfaceTypeProp, Styles.surfaceNames);
+        if ((SurfaceType)material.GetFloat("_Surface") == SurfaceType.Transparent)
+            DoPopup(Styles.blendingMode, blendModeProp, Styles.blendNames);
+
+        EditorGUI.BeginChangeCheck();
+        bool twoSidedEnabled = EditorGUILayout.Toggle(Styles.twoSidedText, cullingProp.floatValue == 0);
+        if (EditorGUI.EndChangeCheck())
+            cullingProp.floatValue = twoSidedEnabled ? 0 : 2;
+
+        EditorGUI.BeginChangeCheck();
+        bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipText, alphaClipProp.floatValue == 1);
+        if (EditorGUI.EndChangeCheck())
+            alphaClipProp.floatValue = alphaClipEnabled ? 1 : 0;
+
+        if (alphaClipProp.floatValue == 1)
+            m_MaterialEditor.ShaderProperty(alphaCutoffProp, Styles.alphaClipThresholdText, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
+
+        EditorGUILayout.Space();
+    }
+
     public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
     {
         FindProperties(properties); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
         ShaderPropertiesGUI(material);
     }
 
-    protected void DoPopup(string label, MaterialProperty property, string[] options)
-    {
-        EditorGUI.showMixedValue = property.hasMixedValue;
-
-        var mode = property.floatValue;
-        EditorGUI.BeginChangeCheck();
-        mode = EditorGUILayout.Popup(label, (int)mode, options);
-        if (EditorGUI.EndChangeCheck())
-        {
-            m_MaterialEditor.RegisterPropertyChangeUndo(label);
-            property.floatValue = (float)mode;
-        }
-
-        EditorGUI.showMixedValue = false;
-    }
-
-        if(alphaClip)
+        if (alphaClip)
-        if(surfaceType == SurfaceType.Opaque)
+        if (surfaceType == SurfaceType.Opaque)
         {
             material.SetOverrideTag("RenderType", "");
             material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
             material.SetShaderPassEnabled("ShadowCaster", true);
         }
         else
-        { 
+        {
             BlendMode blendMode = (BlendMode)material.GetFloat("_Blend");
             switch (blendMode)
             {
         }
     }
 
-    protected MaterialEditor m_MaterialEditor;
-    private bool m_FirstTimeApply = true;
+    protected void DoPopup(string label, MaterialProperty property, string[] options)
+    {
+        EditorGUI.showMixedValue = property.hasMixedValue;
+
+        var mode = property.floatValue;
+        EditorGUI.BeginChangeCheck();
+        mode = EditorGUILayout.Popup(label, (int)mode, options);
+        if (EditorGUI.EndChangeCheck())
+        {
+            m_MaterialEditor.RegisterPropertyChangeUndo(label);
+            property.floatValue = (float)mode;
+        }
+
+        EditorGUI.showMixedValue = false;
+    }
+
+    protected void DoMaterialRenderingOptions()
+    {
+        EditorGUILayout.Space();
+        GUILayout.Label(Styles.renderingOptionsLabel, EditorStyles.boldLabel);
+        m_MaterialEditor.EnableInstancingField();
+        m_MaterialEditor.DoubleSidedGIField();
+    }
 }

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 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 GUIContent bumpScaleNotSupported = new GUIContent("Bump scale is not supported on mobile platforms");
             public static GUIContent fixNow = new GUIContent("Fix now");
 
-            public static string primaryMapsText = "Main Maps";
-            public static string secondaryMapsText = "Secondary Maps";
-            public static string forwardText = "Forward Rendering Options";
+            public static string surfaceProperties = "Surface Properties";
-            public static string surfaceType = "Surface Type";
-            public static string blendingMode = "Blending Mode";
-            public static string advancedText = "Advanced Options";
-            public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
-            public static readonly string[] blendNames = Enum.GetNames(typeof(BlendMode));
-        private MaterialProperty surfaceType;
-        private MaterialProperty blendMode;
-        private MaterialProperty culling;
-        private MaterialProperty alphaClip;
-        private MaterialProperty alphaThreshold;
-
+        
         private MaterialProperty smoothness;
         private MaterialProperty smoothnessScale;
         private MaterialProperty smoothnessMapChannel;
 
         public override void FindProperties(MaterialProperty[] properties)
         {
+            base.FindProperties(properties);
+
-            surfaceType = FindProperty("_Surface", properties);
-            blendMode = FindProperty("_Blend", properties);
-            culling = FindProperty("_Cull", properties);
-            alphaClip  = FindProperty("_AlphaClip", properties);
-            alphaThreshold = FindProperty("_Cutoff", properties);
-
+            
             smoothness = FindProperty("_Glossiness", properties);
             smoothnessScale = FindProperty("_GlossMapScale", properties, false);
             smoothnessMapChannel = FindProperty("_SmoothnessTextureChannel", properties, false);
             // Detect any changes to the material
             EditorGUI.BeginChangeCheck();
             {
+                base.ShaderPropertiesGUI(material);
+                GUILayout.Label(Styles.surfaceProperties, EditorStyles.boldLabel);
+
-                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);
-                DoAlbedoArea(material);
+                DoAlbedoArea();
                 DoMetallicSpecularArea();
                 DoNormalArea();
 
             }
             if (EditorGUI.EndChangeCheck())
             {
-                foreach (var obj in blendMode.targets)
+                foreach (var obj in blendModeProp.targets)
-            EditorGUILayout.Space();
-
-            // NB renderqueue editor is not shown on purpose: we want to override it based on blend mode
-            GUILayout.Label(Styles.advancedText, EditorStyles.boldLabel);
-            m_MaterialEditor.EnableInstancingField();
-            m_MaterialEditor.DoubleSidedGIField();
+            DoMaterialRenderingOptions();
         }
 
         public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
             MaterialChanged(material);
         }
 
-        void DoAlbedoArea(Material material)
+        void DoAlbedoArea()
-            if (material.GetFloat("_AlphaClip") == 1)
-            {
-                m_MaterialEditor.ShaderProperty(alphaThreshold, Styles.clipThresholdText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
-            }
         }
 
         void DoNormalArea()

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

 public class LightweightStandardSimpleLightingGUI : LightweightShaderGUI
 {
     private const float kMinShininessValue = 0.01f;
-    private MaterialProperty surfaceTypeProp;
-    private MaterialProperty blendModeProp;
-    private MaterialProperty culling;
-    private MaterialProperty alphaClip;
-    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 readonly string[] blendNames = Enum.GetNames(typeof(UpgradeBlendMode));
-        public static string surfaceTypeLabel = "Surface Type";
-        public static string blendingModeLabel = "Blending Mode";
+        public static string surfaceProperties = "Surface Properties";
         public static string specularSourceLabel = "Specular";
         public static string glossinessSourceLabel = "Glossiness Source";
         public static string glossinessSource = "Glossiness Source";
-        public static string clipThresholdLabel = "Clip Threshold";
-        public static string advancedText = "Advanced Options";
-        surfaceTypeProp = FindProperty("_Surface", properties);
-        blendModeProp = FindProperty("_Blend", properties);
-        culling = FindProperty("_Cull", properties);
-        alphaClip  = FindProperty("_AlphaClip", properties);
+        base.FindProperties(properties);
-        alphaThresholdProp = FindProperty("_Cutoff", properties);
         specularSourceProp = FindProperty("_SpecSource", properties);
         glossinessSourceProp = FindProperty("_GlossinessSource", properties);
         specularGlossMapProp = FindProperty("_SpecGlossMap", properties);
     {
         EditorGUI.BeginChangeCheck();
         {
+            base.ShaderPropertiesGUI(material);
+            GUILayout.Label(Styles.surfaceProperties, EditorStyles.boldLabel);
             DoSurfaceArea();
             DoSpecular();
 
             m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
             if (EditorGUI.EndChangeCheck())
                 emissionMapProp.textureScaleAndOffset = albedoMapProp.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
+        }
-            GUILayout.Label(Styles.advancedText, EditorStyles.boldLabel);
-            EditorGUI.indentLevel++;
-            m_MaterialEditor.EnableInstancingField();
-            EditorGUI.indentLevel--;
-        }
         if (EditorGUI.EndChangeCheck())
         {
             foreach (var obj in blendModeProp.targets)
-        EditorGUILayout.Space();
-        EditorGUILayout.Space();
+        DoMaterialRenderingOptions();
     }
 
     public override void MaterialChanged(Material material)
     private bool RequiresAlpha()
     {
         SurfaceType surfaceType = (SurfaceType) surfaceTypeProp.floatValue;
-        return alphaClip.floatValue > 0.0f || surfaceType == SurfaceType.Transparent;
+        return alphaClipProp.floatValue > 0.0f || surfaceType == SurfaceType.Transparent;
-        int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
-        EditorGUI.BeginChangeCheck();
-        surfaceTypeValue = EditorGUILayout.Popup(Styles.surfaceTypeLabel, surfaceTypeValue, Styles.surfaceNames);
-        if (EditorGUI.EndChangeCheck())
-            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;
-        }
-
-        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;
-
+        int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
         if ((SurfaceType)surfaceTypeValue == SurfaceType.Opaque)
         {
             int glossSource = (int)glossinessSourceProp.floatValue;
         {
             m_MaterialEditor.TexturePropertySingleLine(Styles.albedoAlphaLabel, albedoMapProp, albedoColorProp);
         }
-        if (alphaClipEnabled)
-            m_MaterialEditor.ShaderProperty(alphaThresholdProp, Styles.clipThresholdLabel, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
     }
 
     private void DoSpecular()

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

 using System;
 using UnityEditor;
 using UnityEngine;
-using UnityEditor.Experimental.Rendering.LightweightPipeline;
-    public enum UnlitBlendMode
-    {
-        Alpha,   // Old school alpha-blending mode, fresnel does not affect amount of transparency
-        Additive,
-        Multiply
-    }
-
-    private MaterialProperty surfaceTypeProp;
-    private MaterialProperty blendModeProp;
-    private MaterialProperty culling;
-    private MaterialProperty alphaClip;
-    private MaterialProperty alphaCutoffProp;
-        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 string surfaceProperties = "Surface Properties";
-        public static readonly string[] surfaceNames = Enum.GetNames(typeof(SurfaceType));
-        public static readonly string[] blendNames = Enum.GetNames(typeof(UnlitBlendMode));
-
-        public static string surfaceTypeLabel = "Surface Type";
-        public static string blendingModeLabel = "Blending Mode";
-        public static string clipThresholdLabel = "Clip Threshold";
-        surfaceTypeProp = FindProperty("_Surface", properties);
-        blendModeProp = FindProperty("_Blend", properties);
-        culling = FindProperty("_Cull", properties);
-        alphaClip  = FindProperty("_AlphaClip", properties);
+        base.FindProperties(properties);
+        alphaClipProp  = FindProperty("_AlphaClip", properties);
         mainTexProp = FindProperty("_MainTex", properties);
         mainColorProp = FindProperty("_Color", properties);
         alphaCutoffProp = FindProperty("_Cutoff", properties);
     {
         EditorGUI.BeginChangeCheck();
         {
-            DoPopup(Styles.surfaceTypeLabel, surfaceTypeProp, Styles.surfaceNames);
+            base.ShaderPropertiesGUI(material);
+            GUILayout.Label(Styles.surfaceProperties, EditorStyles.boldLabel);
-
-            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;
-
-
-            if (alphaClipEnabled)
-                m_MaterialEditor.ShaderProperty(alphaCutoffProp, Styles.clipThresholdLabel, MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
-
-            m_MaterialEditor.TextureScaleOffsetProperty(mainTexProp);
-
+            
-            EditorGUILayout.Space();
-            EditorGUILayout.Space();
+            m_MaterialEditor.TextureScaleOffsetProperty(mainTexProp);
         }
         if (EditorGUI.EndChangeCheck())
         {
 
-        EditorGUILayout.Space();
-        EditorGUILayout.Space();
+        DoMaterialRenderingOptions();
+        SetupMaterialBlendMode(material);
+        SetMaterialKeywords(material);
+    }
+
+    static void SetMaterialKeywords(Material 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/Shaders/LightweightStandardUnlit.shader

     }
     SubShader
     {
-        Tags { "RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline" "IgnoreProjector" = "True"}
+        Tags { "RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline" }
         LOD 100
 
         Blend [_SrcBlend][_DstBlend]
 
             #pragma vertex vert
             #pragma fragment frag
-            #pragma multi_compile_fog
-            #pragma multi_compile_instancing
+            #pragma shader_feature _ALPHAPREMULTIPLY_ON
+            #pragma multi_compile_fog
+            #pragma multi_compile_instancing
 
             // Lighting include is needed because of GI
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
                 half3 color = texColor.rgb * _Color.rgb;
                 half alpha = texColor.a * _Color.a;
                 AlphaDiscard(alpha, _Cutoff);
+
+#ifdef _ALPHAPREMULTIPLY_ON
+                color *= alpha;
+#endif
+
 
 #if _SAMPLE_GI
     #if _NORMALMAP