Update to latest light weight pipeline.

MaterialGraphProject/Assets/NewNodes/Editor/Keep/HeightToNormalNode.cs

 using System.Linq;
-using System.Reflection;
-using JetBrains.Annotations;
 using UnityEngine;
 using UnityEditor.Graphing;
 
-    public class HeightToNormalNode : AbstractMaterialNode, IGeneratesBodyCode
+    public class HeightToNormalNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireMeshUV
     {
         public const int TextureInput = 0;
         public const int TexCoordInput = 1;
         public override bool hasPreview
         {
             get { return true; }
+        }
+
+        public bool RequiresMeshUV(UVChannel channel)
+        {
+            foreach (var slot in GetInputSlots<MaterialSlot>().OfType<IMayRequireMeshUV>())
+            {
+                if (slot.RequiresMeshUV(channel))
+                    return true;
+            }
+            return false;
         }
     }
 }

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

             }
         };
 
-        private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode)
+        private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)
         {
             var surfaceVertexShader = new ShaderGenerator();
             var surfaceDescriptionFunction = new ShaderGenerator();
             graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
             graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
             graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
-
-            var tagsVisitor = new ShaderGenerator();
+            
-            var materialOptions = new SurfaceMaterialOptions();
-            switch (masterNode.alphaMode)
-            {
-                case PBRMasterNode.AlphaMode.Overwrite:
-                case PBRMasterNode.AlphaMode.Clip:
-                    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;
-            }
-
-            materialOptions.GetTags(tagsVisitor);
+            
             materialOptions.GetBlend(blendingVisitor);
             materialOptions.GetCull(cullingVisitor);
             materialOptions.GetDepthTest(zTestVisitor);
                 CoordinateSpace.World);
 
             ShaderGenerator defines = new ShaderGenerator();
-            defines.AddShaderChunk("#define _GLOSSYREFLECTIONS_ON", true);
-            defines.AddShaderChunk("#define _SPECULARHIGHLIGHTS_ON", true);
-            if (masterNode.model == PBRMasterNode.Model.Metallic)
-                defines.AddShaderChunk("#define _METALLIC_SETUP 1", true);
+            if (masterNode.model == PBRMasterNode.Model.Specular)
+                defines.AddShaderChunk("#define _SPECULAR_SETUP 1", true);
 
             switch (masterNode.alphaMode)
             {
             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{ \"RenderPipeline\" = \"LightweightPipeline\"}", true);
 
+            var materialOptions = new SurfaceMaterialOptions();
+            switch (masterNode.alphaMode)
+            {
+                case PBRMasterNode.AlphaMode.Overwrite:
+                case PBRMasterNode.AlphaMode.Clip:
+                    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 tagsVisitor = new ShaderGenerator();
+            materialOptions.GetTags(tagsVisitor);
+            subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);
+
-                    mode),
+                    mode,
+                    materialOptions),
                 true);
 
             var extraPassesTemplateLocation = ShaderGenerator.GetTemplatePath("lightweightPBRExtraPasses.template");

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Data/Nodes/Input/Texture/Texture2DNode.cs

 
         public bool RequiresMeshUV(UVChannel channel)
         {
-            var uvSlot = FindInputSlot<MaterialSlot>(UVInput) as UVMaterialSlot;
-            if (uvSlot == null)
-                return false;
-
-            if (uvSlot.isConnected)
-                return false;
-
-            return uvSlot.RequiresMeshUV(channel);
+            foreach (var slot in GetInputSlots<MaterialSlot>().OfType<IMayRequireMeshUV>())
+            {
+                if (slot.RequiresMeshUV(channel))
+                    return true;
+            }
+            return false;
         }
     }
 }

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

 Pass
 {
-    Tags{"Lightmode" = "ShadowCaster"}
+    Tags{"LightMode" = "ShadowCaster"}
 
     ZWrite On ZTest LEqual
 
 
 Pass
 {
-    Tags{"Lightmode" = "DepthOnly"}
+    Tags{"LightMode" = "DepthOnly"}
+    ColorMask 0
 
     CGPROGRAM
     #pragma target 2.0

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

 	CGPROGRAM
 	#pragma target 3.0
 	
-    #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+    #pragma multi_compile _ _MAIN_LIGHT_COOKIE
+    #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT
+    #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
+    #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+
     #pragma vertex vert
 	#pragma fragment frag
 	
 	
 	struct GraphVertexOutput
     {
-        float4 position : POSITION;
-        float4 lwCustom : TEXCOORD0;
-		float4 fogCoord : TEXCOORD1; // x: fogCoord, yzw: vertexColor
+        float4 position : SV_POSITION;
+#ifdef LIGHTMAP_ON
+        float4 lightmapUV : TEXCOORD0;
+#else
+		float4 vertexSH : TEXCOORD0;
+#endif
+		half4 fogFactorAndVertexLight : TEXCOORD1; // x: fogFactor, yzw: vertex light
         ${Interpolators}
 		UNITY_VERTEX_OUTPUT_STEREO
     };
 
         GraphVertexOutput o = (GraphVertexOutput)0;
         UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-        o.position = UnityObjectToClipPos(v.vertex);
+
-	#ifdef LIGHTMAP_ON
-		o.lwCustom.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
-	#endif
-
-		float3 lwWorldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
+		float4 lwWorldPos = mul(unity_ObjectToWorld, v.vertex);
+		float4 clipPos = mul(UNITY_MATRIX_VP, lwWorldPos);
-		// TODO: change to only support point lights per vertex. This will greatly simplify shader ALU
-	#if defined(_VERTEX_LIGHTS) && defined(_MULTIPLE_LIGHTS)
-		half3 diffuse = half3(1.0, 1.0, 1.0);
-		// pixel lights shaded = min(pixelLights, perObjectLights)
-		// vertex lights shaded = min(vertexLights, perObjectLights) - pixel lights shaded
-		// Therefore vertexStartIndex = pixelLightCount;  vertexEndIndex = min(vertexLights, perObjectLights)
-		int vertexLightStart = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-		int vertexLightEnd = min(globalLightCount.y, unity_LightIndicesOffsetAndCount.y);
-		for (int lightIter = vertexLightStart; lightIter < vertexLightEnd; ++lightIter)
-		{
-			int lightIndex = unity_4LightIndices0[lightIter];
-			LightInput lightInput;
-			INITIALIZE_LIGHT(lightInput, lightIndex);
+#ifdef LIGHTMAP_ON
+		o.lightmapUV.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
+#else
+		o.vertexSH = half4(EvaluateSHPerVertex(lwWNormal), 0.0);
+#endif
-			half3 lightDirection;
-			half atten = ComputeLightAttenuationVertex(lightInput, lwWNormal, lwWorldPos, lightDirection);
-			o.fogCoord.yzw += LightingLambert(diffuse, lightDirection, lwWNormal, atten);
-		}
-	#endif
+		o.fogFactorAndVertexLight.yzw = VertexLighting(lwWorldPos.xyz, lwWNormal);
+		o.fogFactorAndVertexLight.x = ComputeFogFactor(clipPos.z);
+        o.position = clipPos;
-	#if defined(_LIGHT_PROBES_ON) && !defined(LIGHTMAP_ON)
-		o.fogCoord.yzw += max(half3(0, 0, 0), ShadeSH9(half4(lwWNormal, 1)));
-	#endif
-
-		UNITY_TRANSFER_FOG(o, o.position);
 		return o;
 	}
 
        	Emission = Emission * Emission;
 #endif
 
-		half4 result = LightweightFragmentPBR(
-			IN.lwCustom,
+#if _NORMALMAP
+    half3 normalWS = TangentToWorldNormal(Normal, WorldSpaceTangent, WorldSpaceBiTangent, WorldSpaceNormal);
+#else
+    half3 normalWS = normalize(WorldSpaceNormal);
+#endif
+
+#if LIGHTMAP_ON
+	half3 indirectDiffuse = SampleLightmap(IN.lightmapUV.zw, normalWS);
+#else
+	half3 indirectDiffuse = EvaluateSHPerPixel(normalWS, IN.vertexSH);
+#endif
+
+	half4 color = LightweightFragmentPBR(
-			WorldSpaceNormal,
-			WorldSpaceTangent,
-			WorldSpaceBiTangent,
+			normalWS,
-			IN.fogCoord.x, 
-			
+			indirectDiffuse,
+			IN.fogFactorAndVertexLight.yzw, 
-			Normal,
+	// Computes fog factor per-vertex
+    ApplyFog(color.rgb, IN.fogFactorAndVertexLight.x);
+
-		result.a = Alpha;
+		color.a = Alpha;
-		result.a = 1;
+		color.a = 1;
-		return result;
+		return color;
     }
 
 	ENDCG

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

 
         SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
         float3 Color = 0;
-        float3 Alpha = 0;
+        float Alpha = 0;
 		${SurfaceOutputRemap}
 		
     	return fixed4(Color, Alpha);

MaterialGraphProject/ProjectSettings/GraphicsSettings.asset

   m_PreloadedShaders: []
   m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
     type: 0}
-  m_CustomRenderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26,
+  m_CustomRenderPipeline: {fileID: 11400000, guid: 9c068d834ef325345b87395bd103e074,
     type: 2}
   m_TransparencySortMode: 0
   m_TransparencySortAxis: {x: 0, y: 0, z: 1}

MaterialGraphProject/UnityPackageManager/manifest.json

 {
+	"registry": "https://staging-packages.unity.com",
+		"com.unity.render-pipelines.core" : "0.1.11",
+		"com.unity.render-pipelines.lightweight" : "0.1.11"
-}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/LightWeightShaderPaths.cs.meta

 fileFormatVersion: 2
-guid: d31e09c69e37abe4f862a481501681be
+guid: cddd8645d2052584eaee32f4bfc5cc0b
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

MaterialGraphProject/Assets/LightweightAsset.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bf2edee5c58d82540a51f03df9d42094, type: 3}
+  m_Name: LightweightAsset
+  m_EditorClassIdentifier: 
+  m_MaxPixelLights: 4
+  m_SupportsVertexLight: 0
+  m_SupportSoftParticles: 0
+  m_MSAA: 4
+  m_RenderScale: 1
+  m_ShadowType: 1
+  m_ShadowAtlasResolution: 1024
+  m_ShadowNearPlaneOffset: 2
+  m_ShadowDistance: 50
+  m_ShadowCascades: 1
+  m_Cascade2Split: 0.25
+  m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}
+  m_DefaultShader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
+  m_CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}
+  m_DefaultMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  m_DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
+    type: 2}
+  m_DefaultTerrainMaterial: {fileID: 2100000, guid: 594ea882c5a793440b60ff72d896021e,
+    type: 2}

MaterialGraphProject/Assets/LightweightAsset.asset.meta

+fileFormatVersion: 2
+guid: 9c068d834ef325345b87395bd103e074
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/LightWeightShaderPaths.cs

+using System.Linq;
+using UnityEngine;
+using System.IO;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    static class LightweightIncludePaths
+    {
+        [ShaderIncludePath]
+        public static string[] GetPaths()
+        {
+            return new[]
+            {
+                Path.GetFullPath("Packages/com.unity.render-pipelines.lightweight/Shaders")
+            };
+        }
+    }
+}

MaterialGraphProject/ProjectSettings/EditorSettings.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!159 &1
+EditorSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 7
+  m_ExternalVersionControlSupport: Hidden Meta Files
+  m_SerializationMode: 2
+  m_LineEndingsForNewScripts: 2
+  m_DefaultBehaviorMode: 0
+  m_SpritePackerMode: 0
+  m_SpritePackerPaddingPower: 1
+  m_EtcTextureCompressorBehavior: 1
+  m_EtcTextureFastCompressor: 1
+  m_EtcTextureNormalCompressor: 2
+  m_EtcTextureBestCompressor: 4
+  m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp
+  m_ProjectGenerationRootNamespace: 
+  m_UserGeneratedProjectSuffix: 
+  m_CollabEditorSettings:
+    inProgressEnabled: 1

MaterialGraphProject/ProjectSettings/PresetManager.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1386491679 &1
+PresetManager:
+  m_ObjectHideFlags: 0
+  m_DefaultList: []

MaterialGraphProject/Assets/SRP.meta

-fileFormatVersion: 2
-guid: 612579e2db831754e87f0b4b938dbfaf
-folderAsset: yes
-timeCreated: 1504184175
-licenseType: Pro
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: