Generalised PBR / Unlit master

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

                 PBRMasterNode.AlphaSlotId
             }
         };
-        
+
         private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode)
         {
             var surfaceVertexShader = new ShaderGenerator();
                 CoordinateSpace.World);
 
             ShaderGenerator defines = new ShaderGenerator();
+            defines.AddShaderChunk("#define _GLOSSYREFLECTIONS_ON", true);
+            defines.AddShaderChunk("#define _SPECULARHIGHLIGHTS_ON", true);
+
+            if (masterNode.IsSlotConnected(PBRMasterNode.NormalSlotId))
+                defines.AddShaderChunk("#define _NORMALMAP 1", true);
+
+            if (masterNode.model == PBRMasterNode.Model.Metallic)
+                defines.AddShaderChunk("#define _METALLIC_SETUP 1", true);
+
+
-           foreach (var slot in usedSlots)
+            foreach (var slot in usedSlots)
             {
                 surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
                     + " = surf."
             var extraPassesTemplateLocation = ShaderGenerator.GetTemplatePath("lightweightPBRExtraPasses.template");
             if (File.Exists(extraPassesTemplateLocation))
                 subShader.AddShaderChunk(File.ReadAllText(extraPassesTemplateLocation), true);
-            
+
             subShader.Deindent();
             subShader.AddShaderChunk("}", true);
 
-}
+}

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

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Controls/EnumControl.cs

         void OnValueChanged(ChangeEvent<Enum> evt)
         {
             var value = (Enum) m_PropertyInfo.GetValue(m_Node, null);
-            if (evt.newValue.Equals(value))
+            if (!evt.newValue.Equals(value))
             {
                 m_Node.owner.owner.RegisterCompleteObjectUndo("Change " + m_Node.name);
                 m_PropertyInfo.SetValue(m_Node, evt.newValue, null);

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

-SubShader
+Pass
-	Tags{"RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline"}
-	LOD ${LOD}
+	Tags{"LightMode" = "LightweightForward"}
+	${Tags}
+	${Blending}
+	${Culling}
+	${ZTest}
+	${ZWrite}
+	
+	CGPROGRAM
+	#pragma target 3.0
+	#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+    #pragma multi_compile_fog
+	#pragma multi_compile_instancing
-    Pass
-    {
-    	Tags{"LightMode" = "LightweightForward"}
-		${Tags}
-		${Blending}
-		${Culling}
-		${ZTest}
-		${ZWrite}
-		
-		CGPROGRAM
-		#pragma target 3.0
-		#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
-        #pragma multi_compile_fog
-		#pragma multi_compile_instancing
+	#pragma vertex vert
+    #pragma fragment frag
+	#pragma glsl
+	#pragma debug
-		#pragma vertex vert
-        #pragma fragment frag
-		#pragma glsl
-		#pragma debug
+    #include "UnityCG.cginc"
-        #include "UnityCG.cginc"
+    ${Defines}
-        ${Defines}
+    ${Graph}
-        struct GraphVertexOutput
-        {
-            float4 position : POSITION;
-            ${Interpolators}
-			UNITY_VERTEX_OUTPUT_STEREO
-        };
+    struct GraphVertexOutput
+    {
+        float4 position : POSITION;
+        ${Interpolators}
+		UNITY_VERTEX_OUTPUT_STEREO
+    };
-        GraphVertexOutput vert (GraphVertexInput v)
-		{
-		    v = PopulateVertexData(v);
-			
-			UNITY_SETUP_INSTANCE_ID(v);
+    GraphVertexOutput vert (GraphVertexInput v)
+	{
+	    v = PopulateVertexData(v);
+		
+		UNITY_SETUP_INSTANCE_ID(v);
-            GraphVertexOutput o;
-            UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-            o.position = UnityObjectToClipPos(v.vertex);
-            ${VertexShader}
-            return o;
-		}
+        GraphVertexOutput o;
+        UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+        o.position = UnityObjectToClipPos(v.vertex);
+        ${VertexShader}
+        return o;
+	}
-        fixed4 frag (GraphVertexOutput IN) : SV_Target
-        {
-        	${LocalPixelShader}
-        	
-            SurfaceInputs surfaceInput;
-            ${SurfaceInputs}
+    fixed4 frag (GraphVertexOutput IN) : SV_Target
+    {
+    	${LocalPixelShader}
+    	
+        SurfaceInputs surfaceInput;
+        ${SurfaceInputs}
-            SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
-            float3 Color = 0;
-            float3 Alpha = 0;
-			${SurfaceOutputRemap}
-			
-			#ifdef _ALPHABLEND_ON
-				return fixed4(Color, Alpha);
-			#else
-				return fixed4(Color, 1.0);
-			#endif
-        }
-        ENDCG
+        SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
+        float3 Color = 0;
+        float3 Alpha = 0;
+		${SurfaceOutputRemap}
+		
+    	return fixed4(Color, Alpha);
+    ENDCG
 }

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

+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor.Graphing;
+
+namespace UnityEditor.ShaderGraph
+{
+    public class LightWeightUnlitSubShader
+    {
+        Pass m_UnlitPass = new Pass()
+        {
+            Name = "Unlit",
+            PixelShaderSlots = new List<int>()
+            {
+                UnlitMasterNode.ColorSlotId,
+                UnlitMasterNode.AlphaSlotId
+            }
+        };
+
+        struct Pass
+        {
+            public string Name;
+            public List<int> VertexShaderSlots;
+            public List<int> PixelShaderSlots;
+        }
+
+        private static string GetShaderPassFromTemplate(string template, UnlitMasterNode masterNode, Pass pass, GenerationMode mode)
+        {
+            var surfaceVertexShader = new ShaderGenerator();
+            var surfaceDescriptionFunction = new ShaderGenerator();
+            var surfaceDescriptionStruct = new ShaderGenerator();
+            var shaderFunctionVisitor = new ShaderGenerator();
+            var surfaceInputs = new ShaderGenerator();
+
+            var shaderProperties = new PropertyCollector();
+
+            var graphVertexInput = @"
+struct GraphVertexInput
+{
+     float4 vertex : POSITION;
+     float3 normal : NORMAL;
+     float4 tangent : TANGENT;
+     float4 color : COLOR;
+     float4 texcoord0 : TEXCOORD0;
+     float4 lightmapUV : TEXCOORD1;
+     UNITY_VERTEX_INPUT_INSTANCE_ID
+};";
+
+            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+            surfaceInputs.Indent();
+
+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
+
+            var requirements = AbstractMaterialGraph.GetRequirements(activeNodeList);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresNormal, InterpolatorType.Normal, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresTangent, InterpolatorType.Tangent, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresBitangent, InterpolatorType.BiTangent, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresViewDir, InterpolatorType.ViewDirection, surfaceInputs);
+            ShaderGenerator.GenerateSpaceTranslationSurfaceInputs(requirements.requiresPosition, InterpolatorType.Position, surfaceInputs);
+
+            if (requirements.requiresVertexColor)
+                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.VertexColor), false);
+
+            if (requirements.requiresScreenPosition)
+                surfaceInputs.AddShaderChunk(string.Format("float4 {0};", ShaderGeneratorNames.ScreenPosition), false);
+
+            foreach (var channel in requirements.requiresMeshUVs.Distinct())
+                surfaceInputs.AddShaderChunk(string.Format("half4 {0};", channel.GetUVName()), false);
+
+            surfaceInputs.Deindent();
+            surfaceInputs.AddShaderChunk("};", false);
+
+            surfaceVertexShader.AddShaderChunk("GraphVertexInput PopulateVertexData(GraphVertexInput v){", false);
+            surfaceVertexShader.Indent();
+            surfaceVertexShader.AddShaderChunk("return v;", false);
+            surfaceVertexShader.Deindent();
+            surfaceVertexShader.AddShaderChunk("}", false);
+
+            var slots = new List<MaterialSlot>();
+            foreach (var id in pass.PixelShaderSlots)
+            {
+                var slot = masterNode.FindSlot<MaterialSlot>(id);
+                if (slot != null)
+                    slots.Add(slot);
+            }
+            AbstractMaterialGraph.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+
+            var usedSlots = new List<MaterialSlot>();
+            foreach (var id in pass.PixelShaderSlots)
+                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+
+            AbstractMaterialGraph.GenerateSurfaceDescription(
+                activeNodeList,
+                masterNode,
+                masterNode.owner as AbstractMaterialGraph,
+                surfaceDescriptionFunction,
+                shaderFunctionVisitor,
+                shaderProperties,
+                requirements,
+                mode,
+                "PopulateSurfaceData",
+                "SurfaceDescription",
+                null,
+                null,
+                usedSlots);
+
+            var graph = new ShaderGenerator();
+            graph.AddShaderChunk(shaderFunctionVisitor.GetShaderString(2), false);
+            graph.AddShaderChunk(graphVertexInput, false);
+            graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+            graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+            graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
+
+            var tagsVisitor = new ShaderGenerator();
+            var blendingVisitor = new ShaderGenerator();
+            var cullingVisitor = new ShaderGenerator();
+            var zTestVisitor = new ShaderGenerator();
+            var zWriteVisitor = new ShaderGenerator();
+
+            var materialOptions = new SurfaceMaterialOptions();
+            materialOptions.GetTags(tagsVisitor);
+            materialOptions.GetBlend(blendingVisitor);
+            materialOptions.GetCull(cullingVisitor);
+            materialOptions.GetDepthTest(zTestVisitor);
+            materialOptions.GetDepthWrite(zWriteVisitor);
+
+            var interpolators = new ShaderGenerator();
+            var localVertexShader = new ShaderGenerator();
+            var localPixelShader = new ShaderGenerator();
+            var localSurfaceInputs = new ShaderGenerator();
+            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,
+                10,
+                interpolators,
+                localVertexShader,
+                localPixelShader,
+                localSurfaceInputs,
+                requirements,
+                reqs,
+                CoordinateSpace.World);
+
+            ShaderGenerator defines = new ShaderGenerator();
+            var templateLocation = ShaderGenerator.GetTemplatePath(template);
+
+            foreach (var slot in usedSlots)
+            {
+                surfaceOutputRemap.AddShaderChunk(slot.shaderOutputName
+                    + " = surf."
+                    + slot.shaderOutputName + ";", true);
+            }
+
+            if (!File.Exists(templateLocation))
+                return string.Empty;
+
+            var subShaderTemplate = File.ReadAllText(templateLocation);
+            var resultPass = subShaderTemplate.Replace("${Defines}", defines.GetShaderString(3));
+            resultPass = resultPass.Replace("${Graph}", graph.GetShaderString(3));
+            resultPass = resultPass.Replace("${Interpolators}", interpolators.GetShaderString(3));
+            resultPass = resultPass.Replace("${VertexShader}", localVertexShader.GetShaderString(3));
+            resultPass = resultPass.Replace("${LocalPixelShader}", localPixelShader.GetShaderString(3));
+            resultPass = resultPass.Replace("${SurfaceInputs}", localSurfaceInputs.GetShaderString(3));
+            resultPass = resultPass.Replace("${SurfaceOutputRemap}", surfaceOutputRemap.GetShaderString(3));
+
+
+            resultPass = resultPass.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${Blending}", blendingVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${Culling}", cullingVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+            resultPass = resultPass.Replace("${LOD}", "" + materialOptions.lod);
+            return resultPass;
+        }
+
+        public IEnumerable<string> GetSubshader(UnlitMasterNode masterNode, GenerationMode mode)
+        {
+            var subShader = new ShaderGenerator();
+            subShader.AddShaderChunk("SubShader", true);
+            subShader.AddShaderChunk("{", true);
+            subShader.Indent();
+            subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" \"RenderPipeline\" = \"LightweightPipeline\"}", true);
+
+            subShader.AddShaderChunk(
+                GetShaderPassFromTemplate(
+                    "lightweightUnlitPass.template",
+                    masterNode,
+                    m_UnlitPass,
+                    mode),
+                true);
+
+            subShader.Deindent();
+            subShader.AddShaderChunk("}", true);
+
+            return new[] { subShader.GetShaderString(0) };
+        }
+    }
+}

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

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

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

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph.Drawing.Controls;
+using UnityEngine;
+
+namespace UnityEditor.ShaderGraph
+{
+    [Serializable]
+    [Title("Master/Unlit")]
+    public class UnlitMasterNode : MasterNode
+    {
+        public const string ColorSlotName = "Color";
+        public const string AlphaSlotName = "Alpha";
+        public const string VertexOffsetName = "VertexPosition";
+
+        public const int ColorSlotId = 0;
+        public const int AlphaSlotId = 7;
+
+        public UnlitMasterNode()
+        {
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            name = "Unlit Master";
+            AddSlot(new Vector3MaterialSlot(ColorSlotId, ColorSlotName, ColorSlotName, SlotType.Input, new Vector3(0.5f, 0.5f, 0.5f), ShaderStage.Fragment));
+            AddSlot(new Vector1MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, 0, ShaderStage.Fragment));
+
+            // clear out slot names that do not match the slots
+            // we support
+            RemoveSlotsNameNotMatching(
+                new[]
+                {
+                    ColorSlotId,
+                    AlphaSlotId
+                });
+        }
+
+        public override string GetShader(GenerationMode mode, string outputName, out List<PropertyCollector.TextureInfo> configuredTextures)
+        {
+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+
+            var shaderProperties = new PropertyCollector();
+
+            var abstractMaterialGraph = owner as AbstractMaterialGraph;
+            if (abstractMaterialGraph != null)
+                abstractMaterialGraph.CollectShaderProperties(shaderProperties, mode);
+
+            foreach (var activeNode in activeNodeList.OfType<AbstractMaterialNode>())
+                activeNode.CollectShaderProperties(shaderProperties, mode);
+
+            var finalShader = new ShaderGenerator();
+            finalShader.AddShaderChunk(string.Format(@"Shader ""{0}""", outputName), false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+
+            finalShader.AddShaderChunk("Properties", false);
+            finalShader.AddShaderChunk("{", false);
+            finalShader.Indent();
+            finalShader.AddShaderChunk(shaderProperties.GetPropertiesBlock(2), false);
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+
+            var lwSub = new LightWeightUnlitSubShader();
+            foreach (var subshader in lwSub.GetSubshader(this, mode))
+                finalShader.AddShaderChunk(subshader, true);
+
+            finalShader.Deindent();
+            finalShader.AddShaderChunk("}", false);
+
+            configuredTextures = shaderProperties.GetConfiguredTexutres();
+            return finalShader.GetShaderString(0);
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/UnlitMasterNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/LightweightPipeline/LightweightMetallicMasterNode.cs.meta

-fileFormatVersion: 2
-guid: 4b9e77744d433de4186738959cadcfca
-timeCreated: 1478188276
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: