Merge pull request #174 from Unity-Technologies/tim-bug-fixes

Misc bug fixes

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightPBRSubShader.cs

             }
         };
 
-        private static void GenerateApplicationVertexInputs(ShaderGraphRequirements graphRequiements, ShaderGenerator vertexInputs)
-        {
-            vertexInputs.AddShaderChunk("struct GraphVertexInput", false);
-            vertexInputs.AddShaderChunk("{", false);
-            vertexInputs.Indent();
-            vertexInputs.AddShaderChunk("float4 vertex : POSITION;", false);
-            vertexInputs.AddShaderChunk("float3 normal : NORMAL;", false);
-            vertexInputs.AddShaderChunk("float4 tangent : TANGENT;", false);
-
-            if (graphRequiements.requiresVertexColor)
-            {
-                vertexInputs.AddShaderChunk("float4 color : COLOR;", false);
-            }
-
-            foreach (var channel in graphRequiements.requiresMeshUVs.Distinct())
-                vertexInputs.AddShaderChunk(string.Format("float4 texcoord{0} : TEXCOORD{0};", (int)channel), false);
-            
-            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", true);
-            vertexInputs.Deindent();
-            vertexInputs.AddShaderChunk("};", false);
-        }
-
         private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)
         {
             var builder = new ShaderStringBuilder();
             modelRequiements.requiresViewDir |= NeededCoordinateSpace.World;
             modelRequiements.requiresMeshUVs.Add(UVChannel.UV1);
 
-            GenerateApplicationVertexInputs(requirements.Union(modelRequiements), vertexInputs);
+            GraphUtil.GenerateApplicationVertexInputs(requirements.Union(modelRequiements), vertexInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
             ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
             if (masterNode.model == PBRMasterNode.Model.Specular)
                 defines.AddShaderChunk("#define _SPECULAR_SETUP 1", true);
 
-            switch (masterNode.alphaMode)
-            {
-                case PBRMasterNode.AlphaMode.AlphaBlend:
-                case PBRMasterNode.AlphaMode.AdditiveBlend:
-                    defines.AddShaderChunk("#define _AlphaOut 1", true);
-                    break;
-            }
-
-                    defines.AddShaderChunk("#define _AlphaClip 1", true);
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
 
             var templateLocation = ShaderGenerator.GetTemplatePath(template);
 
             resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
             resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
 
-
             resultPass = resultPass.Replace("${Tags}", string.Empty);
             resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
             resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
             subShader.Indent();
             subShader.AddShaderChunk("Tags{ \"RenderPipeline\" = \"LightweightPipeline\"}", true);
 
-            var materialOptions = new SurfaceMaterialOptions();
-            switch (masterNode.alphaMode)
-            {
-                case PBRMasterNode.AlphaMode.Opaque:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.Zero;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.On;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Geometry;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Opaque;
-                    break;
-                case PBRMasterNode.AlphaMode.AlphaBlend:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.SrcAlpha;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.OneMinusSrcAlpha;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
-                    break;
-                case PBRMasterNode.AlphaMode.AdditiveBlend:
-                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.One;
-                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
-                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
-                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
-                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
-                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
-                    break;
-            }
-
+            var materialOptions = MasterNode.GetMaterialOptionsFromAlphaMode(masterNode.alphaMode);
             var tagsVisitor = new ShaderGenerator();
             materialOptions.GetTags(tagsVisitor);
             subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightWeightUnlitSubShader.cs

             PixelShaderSlots = new List<int>()
             {
                 UnlitMasterNode.ColorSlotId,
-                UnlitMasterNode.AlphaSlotId
+                UnlitMasterNode.AlphaSlotId,
+                UnlitMasterNode.AlphaThresholdSlotId
             }
         };
 
             public List<int> PixelShaderSlots;
         }
 
-        private static string GetShaderPassFromTemplate(string template, UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
+        private static string GetShaderPassFromTemplate(
+            string template, 
+            UnlitMasterNode masterNode, 
+            Pass pass, 
+            GenerationMode mode,
+            SurfaceMaterialOptions materialOptions)
         {
             var builder = new ShaderStringBuilder();
             builder.IncreaseIndent();
             graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
             graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
 
-            var tagsVisitor = new ShaderGenerator();
-
-            var materialOptions = new SurfaceMaterialOptions();
-            materialOptions.GetTags(tagsVisitor);
+            
             materialOptions.GetBlend(blendingVisitor);
             materialOptions.GetCull(cullingVisitor);
             materialOptions.GetDepthTest(zTestVisitor);
             var surfaceOutputRemap = new ShaderGenerator();
 
             var reqs = ShaderGraphRequirements.none;
-            reqs.requiresNormal |= NeededCoordinateSpace.World;
-            reqs.requiresTangent |= NeededCoordinateSpace.World;
-            reqs.requiresBitangent |= NeededCoordinateSpace.World;
-            reqs.requiresPosition |= NeededCoordinateSpace.World;
-            reqs.requiresViewDir |= NeededCoordinateSpace.World;
 
             ShaderGenerator.GenerateStandardTransforms(
                 3,
                 CoordinateSpace.World);
 
             ShaderGenerator defines = new ShaderGenerator();
+
+            if (masterNode.IsSlotConnected(UnlitMasterNode.AlphaThresholdSlotId))
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
+
             var templateLocation = ShaderGenerator.GetTemplatePath(template);
 
             foreach (var slot in usedSlots)
             resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
             resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
 
-
-            resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${Tags}", string.Empty);
-            resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
             return resultPass;
         }
 
             subShader.Indent();
             subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" \"RenderPipeline\" = \"LightweightPipeline\"}", true);
 
+            var materialOptions = MasterNode.GetMaterialOptionsFromAlphaMode(masterNode.alphaMode);
+            var tagsVisitor = new ShaderGenerator();
+            materialOptions.GetTags(tagsVisitor);
+            subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);
+
-                    mode),
+                    mode,
+                    materialOptions),
                 true);
 
             subShader.Deindent();

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/MasterNodes/PBRMasterNode.cs

 
 namespace UnityEditor.ShaderGraph
 {
+    public enum AlphaMode
+    {
+        Opaque,
+        AlphaBlend,
+        AdditiveBlend
+    }
+
     [Serializable]
     [Title("Master", "PBR")]
     public class PBRMasterNode : MasterNode
             Metallic
         }
 
-        public enum AlphaMode
-        {
-            Opaque,
-            AlphaBlend,
-            AdditiveBlend
-        }
-
         [SerializeField]
         private Model m_Model = Model.Metallic;
 
         public PBRMasterNode()
         {
             UpdateNodeAfterDeserialization();
-        }
-
-        public bool IsSlotConnected(int slotId)
-        {
-            var slot = FindSlot<MaterialSlot>(slotId);
-            return slot != null && owner.GetEdges(slot.slotReference).Any();
         }
 
         public sealed override void UpdateNodeAfterDeserialization()

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/MasterNodes/UnlitMasterNode.cs

 using System.Collections.Generic;
 using System.Linq;
 using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
 using UnityEngine;
 
 namespace UnityEditor.ShaderGraph
     {
         public const string ColorSlotName = "Color";
         public const string AlphaSlotName = "Alpha";
+        public const string AlphaClipThresholdSlotName = "AlphaClipThreshold";
+        public const int AlphaThresholdSlotId = 8;
+
+        [SerializeField]
+        private AlphaMode m_AlphaMode;
+
+        [EnumControl("")]
+        public AlphaMode alphaMode
+        {
+            get { return m_AlphaMode; }
+            set
+            {
+                if (m_AlphaMode == value)
+                    return;
+
+                m_AlphaMode = value;
+                Dirty(ModificationScope.Graph);
+            }
+        }
 
         public UnlitMasterNode()
         {
             name = "Unlit Master";
             AddSlot(new ColorRGBMaterialSlot(ColorSlotId, ColorSlotName, ColorSlotName, SlotType.Input, Color.grey, ShaderStage.Fragment));
             AddSlot(new Vector1MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, 1, ShaderStage.Fragment));
+            AddSlot(new Vector1MaterialSlot(AlphaThresholdSlotId, AlphaClipThresholdSlotName, AlphaClipThresholdSlotName, SlotType.Input, 0f, ShaderStage.Fragment));
 
             // clear out slot names that do not match the slots
             // we support
                 ColorSlotId,
-                AlphaSlotId
+                AlphaSlotId,
+                AlphaThresholdSlotId
             });
         }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/AbstractMaterialNode.cs

 
         public virtual void UpdateNodeAfterDeserialization()
         {}
+
+        public bool IsSlotConnected(int slotId)
+        {
+            var slot = FindSlot<MaterialSlot>(slotId);
+            return slot != null && owner.GetEdges(slot.slotReference).Any();
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/MasterNode.cs

         }
 
         public abstract string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures);
+        
+        public static SurfaceMaterialOptions GetMaterialOptionsFromAlphaMode(AlphaMode alphaMode)
+        {
+            var materialOptions = new SurfaceMaterialOptions();
+            switch (alphaMode)
+            {
+                case AlphaMode.Opaque:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.Zero;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.On;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Geometry;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Opaque;
+                    break;
+                case AlphaMode.AlphaBlend:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.SrcAlpha;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.OneMinusSrcAlpha;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
+                    break;
+                case AlphaMode.AdditiveBlend:
+                    materialOptions.srcBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.dstBlend = SurfaceMaterialOptions.BlendMode.One;
+                    materialOptions.cullMode = SurfaceMaterialOptions.CullMode.Back;
+                    materialOptions.zTest = SurfaceMaterialOptions.ZTest.LEqual;
+                    materialOptions.zWrite = SurfaceMaterialOptions.ZWrite.Off;
+                    materialOptions.renderQueue = SurfaceMaterialOptions.RenderQueue.Transparent;
+                    materialOptions.renderType = SurfaceMaterialOptions.RenderType.Transparent;
+                    break;
+            }
+            return materialOptions;
+        }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/GraphUtil.cs

             foreach (var channel in graphRequiements.requiresMeshUVs.Distinct())
                 vertexInputs.AddShaderChunk(string.Format("float4 texcoord{0} : TEXCOORD{0};", (int)channel), false);
 
+            vertexInputs.AddShaderChunk("UNITY_VERTEX_INPUT_INSTANCE_ID", true);
             vertexInputs.Deindent();
             vertexInputs.AddShaderChunk("};", false);
         }
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Common.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Packing.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/Color.hlsl""");
+                finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/UnityInstancing.hlsl""");
                 finalBuilder.AppendLine(@"#include ""CoreRP/ShaderLibrary/EntityLighting.hlsl""");
                 finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariables.hlsl""");
                 finalBuilder.AppendLine(@"#include ""ShaderGraphLibrary/ShaderVariablesFunctions.hlsl""");
                         var foundEdges = graph.GetEdges(input.slotReference).ToArray();
                         if (foundEdges.Any())
                         {
-                            var outputRef = foundEdges[0].outputSlot;
-                            var fromNode = graph.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
-                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(input.shaderOutputName), fromNode.GetVariableNameForSlot(outputRef.slotId)), true);
+                            surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(input.shaderOutputName), masterNode.GetSlotValue(input.id, mode)), true);
                         }
                         else
                         {
                 else if (masterNode.hasPreview)
                 {
                     foreach (var slot in masterNode.GetOutputSlots<MaterialSlot>())
-                        surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetVariableNameForSlot(slot.id)), true);
+                        surfaceDescriptionFunction.AddShaderChunk(string.Format("surface.{0} = {1};", NodeUtils.GetHLSLSafeName(slot.shaderOutputName), masterNode.GetSlotValue(slot.id, mode)), true);
                 }
             }
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Util/ShaderGenerator.cs

 
         private const string kErrorString = @"ERROR!";
 
-        public static string AdaptNodeOutput(AbstractMaterialNode node, int outputSlotId, ConcreteSlotValueType convertToType, bool textureSampleUVHack = false)
+        public static string AdaptNodeOutput(AbstractMaterialNode node, int outputSlotId, ConcreteSlotValueType convertToType)
         {
             var outputSlot = node.FindOutputSlot<MaterialSlot>(outputSlotId);
 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/PreviewManager.cs

             m_PreviewPropertyBlock.SetFloat(m_OutputIdName, renderData.shaderData.node.tempId.index);
             if (m_PreviewMaterial.shader != renderData.shaderData.shader)
                 m_PreviewMaterial.shader = renderData.shaderData.shader;
-            m_SceneResources.camera.targetTexture = renderData.renderTexture;
-            RenderTexture.active = renderData.renderTexture;
+
+
+            //Temp workaround for alpha previews...
+            var temp = RenderTexture.GetTemporary(renderData.renderTexture.descriptor);
+            RenderTexture.active = temp;
-            Graphics.Blit(Texture2D.whiteTexture, renderData.renderTexture, m_SceneResources.checkerboardMaterial);
+            Graphics.Blit(Texture2D.whiteTexture, temp, m_SceneResources.checkerboardMaterial);
+            m_SceneResources.camera.targetTexture = temp;
             Graphics.DrawMesh(mesh, transform, m_PreviewMaterial, 1, m_SceneResources.camera, 0, m_PreviewPropertyBlock, ShadowCastingMode.Off, false, null, false);
 
             var previousUseSRP = Unsupported.useScriptableRenderPipeline;
+
+            Graphics.Blit(temp, renderData.renderTexture, m_SceneResources.blitNoAlphaMaterial);
+            RenderTexture.ReleaseTemporary(temp);
+
             RenderTexture.active = previousRenderTexure;
             renderData.texture = renderData.renderTexture;
         }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Views/PreviewSceneResources.cs

         public Light light1 { get; private set; }
 
         Material m_CheckerboardMaterial;
+        Material m_BlitNoAlphaMaterial;
 
         static readonly Mesh[] s_Meshes = { null, null, null, null, null };
         static readonly GUIContent[] s_MeshIcons = { null, null, null, null, null };
             light1.color = new Color(.4f, .4f, .45f, 0f) * .7f;
 
             m_CheckerboardMaterial = new Material(Shader.Find("Hidden/Checkerboard"));
+            m_BlitNoAlphaMaterial = new Material(Shader.Find("Hidden/BlitNoAlpha"));
+            blitNoAlphaMaterial.hideFlags = HideFlags.HideAndDontSave;
 
             if (s_Meshes[0] == null)
             {
             get { return m_CheckerboardMaterial; }
         }
 
+        public Material blitNoAlphaMaterial
+        {
+            get { return m_BlitNoAlphaMaterial; }
+        }
+
         public Camera camera
         {
             get { return m_Camera; }
             {
                 UnityEngine.Object.DestroyImmediate(checkerboardMaterial, true);
                 m_CheckerboardMaterial = null;
+            }
+            if (blitNoAlphaMaterial != null)
+            {
+                UnityEngine.Object.DestroyImmediate(blitNoAlphaMaterial, true);
+                m_BlitNoAlphaMaterial = null;
             }
 
             EditorSceneManager.ClosePreviewScene(m_Scene);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightPBRForwardPass.template

 	#include "LWRP/ShaderLibrary/Core.hlsl"
 	#include "LWRP/ShaderLibrary/Lighting.hlsl"
 	#include "CoreRP/ShaderLibrary/Color.hlsl"
+	#include "CoreRP/ShaderLibrary/UnityInstancing.hlsl"
 	#include "ShaderGraphLibrary/Functions.hlsl"
 
 	${Graph}
 
 	half4 frag (GraphVertexOutput IN) : SV_Target
     {
-
     	UNITY_SETUP_INSTANCE_ID(IN);
 
     	${LocalPixelShader}
 
 		// Computes fog factor per-vertex
     	ApplyFog(color.rgb, IN.fogFactorAndVertexLight.x);
-
-#if _AlphaOut
-		color.a = Alpha;
-#else
-		color.a = 1;
-#endif
 
 #if _AlphaClip
 		clip(Alpha - AlphaClipThreshold);

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightUnlitPass.template

 	${ZTest}
 	${ZWrite}
 	
-	HLSLPROGRAM
+    HLSLPROGRAM
+    #pragma vertex vert
+    #pragma fragment frag
+    #pragma shader_feature _SAMPLE_GI
+    #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
     #pragma multi_compile_instancing
 
 	#pragma vertex vert
     #include "LWRP/ShaderLibrary/Core.hlsl"
     #include "LWRP/ShaderLibrary/Lighting.hlsl"
     #include "CoreRP/ShaderLibrary/Color.hlsl"
+    #include "LWRP/ShaderLibrary/InputSurface.hlsl"
     #include "ShaderGraphLibrary/Functions.hlsl"
 
     ${Defines}
     {
         float4 position : POSITION;
         ${Interpolators}
+        UNITY_VERTEX_INPUT_INSTANCE_ID
     };
 
     GraphVertexOutput vert (GraphVertexInput v)
-        GraphVertexOutput o;
+        GraphVertexOutput o = (GraphVertexOutput)0;
+        
+        UNITY_SETUP_INSTANCE_ID(v);
+        UNITY_TRANSFER_INSTANCE_ID(v, o);
+
         o.position = TransformObjectToHClip(v.vertex.xyz);
         ${VertexShader}
         return o;
     {
+        UNITY_SETUP_INSTANCE_ID(IN);
+
-        SurfaceInputs surfaceInput;
+        SurfaceInputs surfaceInput = (SurfaceInputs)0;
-        float3 Color = 0;
-        float Alpha = 0;
+        float3 Color = float3(0.5, 0.5, 0.5);
+        float Alpha = 1;
+        float AlphaClipThreshold = 0;
+ #if _AlphaClip
+        clip(Alpha - AlphaClipThreshold);
+#endif
     	return half4(Color, Alpha);
     }
     ENDHLSL

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Shaders/BlitNoAlpha.shader

+Shader "Hidden/BlitNoAlpha"
+{
+    Properties
+    {
+        _MainTex ("Texture", any) = "" {}
+    }
+    SubShader {
+        Pass {
+            ZTest Always Cull Off ZWrite Off
+
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "UnityCG.cginc"
+
+            UNITY_DECLARE_SCREENSPACE_TEXTURE(_MainTex);
+            uniform float4 _MainTex_ST;
+
+            struct appdata_t {
+                float4 vertex : POSITION;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f {
+                float4 vertex : SV_POSITION;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            v2f vert (appdata_t v)
+            {
+                v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                o.texcoord = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
+                return o;
+            }
+
+            fixed4 frag (v2f i) : SV_Target
+            {
+                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+                return half4(UNITY_SAMPLE_SCREENSPACE_TEXTURE(_MainTex, i.texcoord).xyz, 1.0);
+            }
+            ENDCG
+
+        }
+    }
+    Fallback Off
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Resources/Shaders/BlitNoAlpha.shader.meta

+fileFormatVersion: 2
+guid: 50b406436c6214c49aaaa6011b71dde8
+timeCreated: 1502007198
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: