Move Lightweight Shader Graph sub-shaders from SG repo

7 年前 · d7929b25
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/com.unity.render-pipelines.lightweight.Editor.asmdef
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/com.unity.render-pipelines.lightweight.Editor.asmdef
        "com.unity.render-pipelines.core.Editor",
        "com.unity.render-pipelines.lightweight.Runtime",
        "com.unity.postprocessing.Runtime",
-        "com.unity.postprocessing.Editor"
+        "com.unity.postprocessing.Editor",
+        "Unity.ShaderGraph.Editor"
    ],
    "optionalUnityReferences": [],
    "includePlatforms": [
--- a/ScriptableRenderPipeline/LightweightPipeline/sub-package.json
+++ b/ScriptableRenderPipeline/LightweightPipeline/sub-package.json
 	"description": "Lightweight Render Pipeline for Unity.",
    "subDependencies": [
        "com.unity.render-pipelines.core"
-    ]
+    ],
+    "dependencies": {
+        "com.unity.shadergraph": "0.1.19"
+    }
 }
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph.meta
+fileFormatVersion: 2
+guid: ae1e56b12b01f3b4d9c9bb9d7154d97f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+
+namespace UnityEditor.Experimental.Rendering.LightweightPipeline
+{
+    [Serializable]
+    [FormerName("UnityEditor.ShaderGraph.LightWeightPBRSubShader")]
+    public class LightWeightPBRSubShader : IPBRSubShader
+    {
+        struct Pass
+        {
+            public string Name;
+            public List<int> VertexShaderSlots;
+            public List<int> PixelShaderSlots;
+        }
+
+        Pass m_ForwardPassMetallic = new Pass
+        {
+            Name = "LightweightForward",
+            PixelShaderSlots = new List<int>
+            {
+                PBRMasterNode.AlbedoSlotId,
+                PBRMasterNode.NormalSlotId,
+                PBRMasterNode.EmissionSlotId,
+                PBRMasterNode.MetallicSlotId,
+                PBRMasterNode.SmoothnessSlotId,
+                PBRMasterNode.OcclusionSlotId,
+                PBRMasterNode.AlphaSlotId,
+                PBRMasterNode.AlphaThresholdSlotId
+            }
+        };
+
+        Pass m_ForwardPassSpecular = new Pass()
+        {
+            Name = "LightweightForward",
+            PixelShaderSlots = new List<int>()
+            {
+                PBRMasterNode.AlbedoSlotId,
+                PBRMasterNode.NormalSlotId,
+                PBRMasterNode.EmissionSlotId,
+                PBRMasterNode.SpecularSlotId,
+                PBRMasterNode.SmoothnessSlotId,
+                PBRMasterNode.OcclusionSlotId,
+                PBRMasterNode.AlphaSlotId,
+                PBRMasterNode.AlphaThresholdSlotId
+            }
+        };
+
+        private static string GetShaderPassFromTemplate(string template, PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)
+        {
+            var builder = new ShaderStringBuilder();
+            builder.IncreaseIndent();
+            builder.IncreaseIndent();
+            var vertexInputs = new ShaderGenerator();
+            var surfaceVertexShader = new ShaderGenerator();
+            var surfaceDescriptionFunction = new ShaderGenerator();
+            var surfaceDescriptionStruct = new ShaderGenerator();
+            var functionRegistry = new FunctionRegistry(builder);
+            var surfaceInputs = new ShaderGenerator();
+
+            var shaderProperties = new PropertyCollector();
+
+            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+            surfaceInputs.Indent();
+
+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
+
+            var requirements = ShaderGraphRequirements.FromNodes(activeNodeList);
+
+            var modelRequiements = ShaderGraphRequirements.none;
+            modelRequiements.requiresNormal |= NeededCoordinateSpace.World;
+            modelRequiements.requiresTangent |= NeededCoordinateSpace.World;
+            modelRequiements.requiresBitangent |= NeededCoordinateSpace.World;
+            modelRequiements.requiresPosition |= NeededCoordinateSpace.World;
+            modelRequiements.requiresViewDir |= NeededCoordinateSpace.World;
+            modelRequiements.requiresMeshUVs.Add(UVChannel.UV1);
+
+            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);
+            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)
+                slots.Add(masterNode.FindSlot<MaterialSlot>(id));
+            GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+
+            var usedSlots = new List<MaterialSlot>();
+            foreach (var id in pass.PixelShaderSlots)
+                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+
+            GraphUtil.GenerateSurfaceDescription(
+                activeNodeList,
+                masterNode,
+                masterNode.owner as AbstractMaterialGraph,
+                surfaceDescriptionFunction,
+                functionRegistry,
+                shaderProperties,
+                requirements,
+                mode,
+                "PopulateSurfaceData",
+                "SurfaceDescription",
+                null,
+                usedSlots);
+
+            var graph = new ShaderGenerator();
+            graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+            graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+            graph.AddShaderChunk(builder.ToString(), false);
+            graph.AddShaderChunk(vertexInputs.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
+
+            var blendingVisitor = new ShaderGenerator();
+            var cullingVisitor = new ShaderGenerator();
+            var zTestVisitor = new ShaderGenerator();
+            var zWriteVisitor = new ShaderGenerator();
+
+            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();
+
+            ShaderGenerator.GenerateStandardTransforms(
+                3,
+                10,
+                interpolators,
+                localVertexShader,
+                localPixelShader,
+                localSurfaceInputs,
+                requirements,
+                modelRequiements,
+                CoordinateSpace.World);
+
+            ShaderGenerator defines = new ShaderGenerator();
+
+            if (masterNode.IsSlotConnected(PBRMasterNode.NormalSlotId))
+                defines.AddShaderChunk("#define _NORMALMAP 1", true);
+
+            if (masterNode.model == PBRMasterNode.Model.Specular)
+                defines.AddShaderChunk("#define _SPECULAR_SETUP 1", true);
+
+            if (masterNode.IsSlotConnected(PBRMasterNode.AlphaThresholdSlotId))
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
+
+            if(masterNode.surfaceType == SurfaceType.Transparent && masterNode.alphaMode == AlphaMode.Premultiply)
+                defines.AddShaderChunk("#define _ALPHAPREMULTIPLY_ON 1", true);
+
+            var templateLocation = GetTemplatePath(template);
+
+            foreach (var slot in usedSlots)
+            {
+                surfaceOutputRemap.AddShaderChunk(string.Format("{0} = surf.{0};", 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}", string.Empty);
+            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));
+            return resultPass;
+        }
+
+        static string GetTemplatePath(string templateName)
+        {
+            string relativeTemplatePath = Path.Combine("LWRP", Path.Combine("Editor", Path.Combine("ShaderGraph", Path.Combine(templateName))));
+            foreach (var path in LightweightIncludePaths.GetPaths())
+            {
+                var templatePath = Path.Combine(path, relativeTemplatePath);
+                if (File.Exists(templatePath))
+                    return templatePath;
+            }
+            throw new FileNotFoundException(string.Format(@"Cannot find a template with name ""{0}"".", templateName));
+        }
+
+        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode)
+        {
+            var masterNode = inMasterNode as PBRMasterNode;
+            var subShader = new ShaderGenerator();
+            subShader.AddShaderChunk("SubShader", true);
+            subShader.AddShaderChunk("{", true);
+            subShader.Indent();
+            subShader.AddShaderChunk("Tags{ \"RenderPipeline\" = \"LightweightPipeline\"}", true);
+
+            var materialOptions = ShaderGenerator.GetMaterialOptions(masterNode.surfaceType, masterNode.alphaMode, masterNode.twoSided.isOn);
+            var tagsVisitor = new ShaderGenerator();
+            materialOptions.GetTags(tagsVisitor);
+            subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);
+
+            subShader.AddShaderChunk(
+                GetShaderPassFromTemplate(
+                    "lightweightPBRForwardPass.template",
+                    masterNode,
+                    masterNode.model == PBRMasterNode.Model.Metallic ? m_ForwardPassMetallic : m_ForwardPassSpecular,
+                    mode,
+                    materialOptions),
+                true);
+
+            var extraPassesTemplateLocation = GetTemplatePath("lightweightPBRExtraPasses.template");
+            if (File.Exists(extraPassesTemplateLocation))
+            {
+                var extraPassesTemplate = File.ReadAllText(extraPassesTemplateLocation);
+                extraPassesTemplate = extraPassesTemplate.Replace("${Culling}", materialOptions.cullMode.ToString());
+                subShader.AddShaderChunk(extraPassesTemplate, true);
+            }
+
+            subShader.Deindent();
+            subShader.AddShaderChunk("}", true);
+
+            return subShader.GetShaderString(0);
+        }
+    }
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs.meta
+fileFormatVersion: 2
+guid: ca91dbeb78daa054c9bbe15fef76361c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor.Experimental.Rendering.LightweightPipeline;
+using UnityEditor.Graphing;
+using UnityEditor.ShaderGraph;
+
+namespace UnityEngine.Experimental.Rendering.LightweightPipeline
+{
+    [Serializable]
+    [FormerName("UnityEditor.ShaderGraph.LightWeightUnlitSubShader")]
+    public class LightWeightUnlitSubShader : IUnlitSubShader
+    {
+        Pass m_UnlitPass = new Pass
+        {
+            Name = "Unlit",
+            PixelShaderSlots = new List<int>
+            {
+                UnlitMasterNode.ColorSlotId,
+                UnlitMasterNode.AlphaSlotId,
+                UnlitMasterNode.AlphaThresholdSlotId
+            }
+        };
+
+        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,
+            SurfaceMaterialOptions materialOptions)
+        {
+            var builder = new ShaderStringBuilder();
+            builder.IncreaseIndent();
+            builder.IncreaseIndent();
+            var vertexInputs = new ShaderGenerator();
+            var surfaceVertexShader = new ShaderGenerator();
+            var surfaceDescriptionFunction = new ShaderGenerator();
+            var surfaceDescriptionStruct = new ShaderGenerator();
+            var functionRegistry = new FunctionRegistry(builder);
+            var surfaceInputs = new ShaderGenerator();
+
+            var shaderProperties = new PropertyCollector();
+
+            surfaceInputs.AddShaderChunk("struct SurfaceInputs{", false);
+            surfaceInputs.Indent();
+
+            var activeNodeList = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
+
+            var requirements = ShaderGraphRequirements.FromNodes(activeNodeList);
+            GraphUtil.GenerateApplicationVertexInputs(requirements, vertexInputs);
+            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);
+            }
+            GraphUtil.GenerateSurfaceDescriptionStruct(surfaceDescriptionStruct, slots, true);
+
+            var usedSlots = new List<MaterialSlot>();
+            foreach (var id in pass.PixelShaderSlots)
+                usedSlots.Add(masterNode.FindSlot<MaterialSlot>(id));
+
+            GraphUtil.GenerateSurfaceDescription(
+                activeNodeList,
+                masterNode,
+                masterNode.owner as AbstractMaterialGraph,
+                surfaceDescriptionFunction,
+                functionRegistry,
+                shaderProperties,
+                requirements,
+                mode,
+                "PopulateSurfaceData",
+                "SurfaceDescription",
+                null,
+                usedSlots);
+
+            var graph = new ShaderGenerator();
+
+            graph.AddShaderChunk(shaderProperties.GetPropertiesDeclaration(2), false);
+            graph.AddShaderChunk(surfaceInputs.GetShaderString(2), false);
+            graph.AddShaderChunk(builder.ToString(), false);
+            graph.AddShaderChunk(vertexInputs.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionStruct.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceVertexShader.GetShaderString(2), false);
+            graph.AddShaderChunk(surfaceDescriptionFunction.GetShaderString(2), false);
+
+            var blendingVisitor = new ShaderGenerator();
+            var cullingVisitor = new ShaderGenerator();
+            var zTestVisitor = new ShaderGenerator();
+            var zWriteVisitor = new ShaderGenerator();
+
+            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;
+
+            ShaderGenerator.GenerateStandardTransforms(
+                3,
+                10,
+                interpolators,
+                localVertexShader,
+                localPixelShader,
+                localSurfaceInputs,
+                requirements,
+                reqs,
+                CoordinateSpace.World);
+
+            ShaderGenerator defines = new ShaderGenerator();
+
+            if (masterNode.IsSlotConnected(UnlitMasterNode.AlphaThresholdSlotId))
+                defines.AddShaderChunk("#define _AlphaClip 1", true);
+
+            if(masterNode.surfaceType == SurfaceType.Transparent && masterNode.alphaMode == AlphaMode.Premultiply)
+                defines.AddShaderChunk("#define _ALPHAPREMULTIPLY_ON 1", true);
+
+            var templateLocation = 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}", string.Empty);
+            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));
+            return resultPass;
+        }
+
+        static string GetTemplatePath(string templateName)
+        {
+            string relativeTemplatePath = Path.Combine("LWRP", Path.Combine("Editor", Path.Combine("ShaderGraph", Path.Combine(templateName))));
+            foreach (var path in LightweightIncludePaths.GetPaths())
+            {
+                var templatePath = Path.Combine(path, relativeTemplatePath);
+                if (File.Exists(templatePath))
+                    return templatePath;
+            }
+            throw new FileNotFoundException(string.Format(@"Cannot find a template with name ""{0}"".", templateName));
+        }
+
+        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode)
+        {
+            var masterNode = inMasterNode as UnlitMasterNode;
+            var subShader = new ShaderGenerator();
+            subShader.AddShaderChunk("SubShader", true);
+            subShader.AddShaderChunk("{", true);
+            subShader.Indent();
+            subShader.AddShaderChunk("Tags{ \"RenderType\" = \"Opaque\" \"RenderPipeline\" = \"LightweightPipeline\"}", true);
+
+            var materialOptions = ShaderGenerator.GetMaterialOptions(masterNode.surfaceType, masterNode.alphaMode, masterNode.twoSided.isOn);
+            var tagsVisitor = new ShaderGenerator();
+            materialOptions.GetTags(tagsVisitor);
+            subShader.AddShaderChunk(tagsVisitor.GetShaderString(0), true);
+
+            subShader.AddShaderChunk(
+                GetShaderPassFromTemplate(
+                    "lightweightUnlitPass.template",
+                    masterNode,
+                    m_UnlitPass,
+                    mode,
+                    materialOptions),
+                true);
+
+            var extraPassesTemplateLocation = GetTemplatePath("lightweightUnlitExtraPasses.template");
+            if (File.Exists(extraPassesTemplateLocation))
+            {
+                var extraPassesTemplate = File.ReadAllText(extraPassesTemplateLocation);
+                extraPassesTemplate = extraPassesTemplate.Replace("${Culling}", materialOptions.cullMode.ToString());
+                subShader.AddShaderChunk(extraPassesTemplate, true);
+            }
+
+            subShader.Deindent();
+            subShader.AddShaderChunk("}", true);
+
+            return subShader.GetShaderString(0);
+        }
+    }
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs.meta
+fileFormatVersion: 2
+guid: 3ef30c5c1d5fc412f88511ef5818b654
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template
+Pass
+{
+    Tags{"LightMode" = "ShadowCaster"}
+
+    ZWrite On
+    ZTest LEqual
+    Cull ${Culling}
+
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+    #pragma target 2.0
+    
+    //--------------------------------------
+    // GPU Instancing
+    #pragma multi_compile_instancing
+
+    #pragma vertex ShadowPassVertex
+    #pragma fragment LitPassFragmentNull
+
+    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
+    ENDHLSL
+}
+
+Pass
+{
+    Tags{"LightMode" = "DepthOnly"}
+
+    ZWrite On
+    ColorMask 0
+
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+    #pragma target 2.0
+    
+    //--------------------------------------
+    // GPU Instancing
+    #pragma multi_compile_instancing
+
+    #pragma vertex LitPassVertex
+    #pragma fragment LitPassFragmentNull
+
+    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+    ENDHLSL
+}
+
+// This pass it not used during regular rendering, only for lightmap baking.
+Pass
+{
+    Tags{"LightMode" = "Meta"}
+
+    Cull Off
+
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+
+    #pragma vertex LightweightVertexMeta
+    #pragma fragment LightweightFragmentMeta
+
+    #pragma shader_feature _SPECULAR_SETUP
+    #pragma shader_feature _EMISSION
+    #pragma shader_feature _METALLICSPECGLOSSMAP
+    #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    #pragma shader_feature EDITOR_VISUALIZATION
+
+    #pragma shader_feature _SPECGLOSSMAP
+
+    #include "LWRP/ShaderLibrary/LightweightPassMeta.hlsl"
+    ENDHLSL
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template.meta
+fileFormatVersion: 2
+guid: 5fa0a7ad9ac73b34691439e5cf40a1c3
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template
+Pass
+{
+	Tags{"LightMode" = "LightweightForward"}
+	${Tags}
+	${Blending}
+	${Culling}
+	${ZTest}
+	${ZWrite}
+
+	HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+	#pragma target 3.0
+
+	// -------------------------------------
+	// Lightweight Pipeline keywords
+	#pragma multi_compile _ _ADDITIONAL_LIGHTS
+	#pragma multi_compile _ _VERTEX_LIGHTS
+	#pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
+	#pragma multi_compile _ FOG_LINEAR FOG_EXP2
+
+	// -------------------------------------
+	// Unity defined keywords
+	#pragma multi_compile _ DIRLIGHTMAP_COMBINED
+	#pragma multi_compile _ LIGHTMAP_ON
+
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
+
+    #pragma vertex vert
+	#pragma fragment frag
+
+	${Defines}
+
+	#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}
+
+	struct GraphVertexOutput
+    {
+        float4 clipPos                : SV_POSITION;
+        float4 lightmapUVOrVertexSH   : TEXCOORD0;
+		half4 fogFactorAndVertexLight : TEXCOORD1; // x: fogFactor, yzw: vertex light
+    	float4 shadowCoord            : TEXCOORD2;
+        ${Interpolators}
+        UNITY_VERTEX_INPUT_INSTANCE_ID
+    };
+
+    GraphVertexOutput vert (GraphVertexInput v)
+	{
+	    v = PopulateVertexData(v);
+
+        GraphVertexOutput o = (GraphVertexOutput)0;
+
+        UNITY_SETUP_INSTANCE_ID(v);
+    	UNITY_TRANSFER_INSTANCE_ID(v, o);
+
+        ${VertexShader}
+
+		float3 lwWNormal = TransformObjectToWorldNormal(v.normal);
+		float3 lwWorldPos = TransformObjectToWorld(v.vertex.xyz);
+		float4 clipPos = TransformWorldToHClip(lwWorldPos);
+
+ 		// We either sample GI from lightmap or SH. lightmap UV and vertex SH coefficients
+	    // are packed in lightmapUVOrVertexSH to save interpolator.
+	    // The following funcions initialize
+	    OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH);
+	    OUTPUT_SH(lwWNormal, o.lightmapUVOrVertexSH);
+
+	    half3 vertexLight = VertexLighting(lwWorldPos, lwWNormal);
+	    half fogFactor = ComputeFogFactor(clipPos.z);
+	    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+	    o.clipPos = clipPos;
+
+	    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+		return o;
+	}
+
+	half4 frag (GraphVertexOutput IN) : SV_Target
+    {
+    	UNITY_SETUP_INSTANCE_ID(IN);
+
+    	${LocalPixelShader}
+
+        SurfaceInputs surfaceInput = (SurfaceInputs)0;
+        ${SurfaceInputs}
+
+        SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
+
+		float3 Albedo = float3(0.5, 0.5, 0.5);
+		float3 Specular = float3(0, 0, 0);
+		float Metallic = 1;
+		float3 Normal = float3(0, 0, 1);
+		float3 Emission = 0;
+		float Smoothness = 0.5;
+		float Occlusion = 1;
+		float Alpha = 1;
+		float AlphaClipThreshold = 0;
+
+        ${SurfaceOutputRemap}
+
+		InputData inputData;
+		inputData.positionWS = WorldSpacePosition;
+
+#ifdef _NORMALMAP
+	    inputData.normalWS = TangentToWorldNormal(Normal, WorldSpaceTangent, WorldSpaceBiTangent, WorldSpaceNormal);
+#else
+	    inputData.normalWS = normalize(WorldSpaceNormal);
+#endif
+
+#ifdef SHADER_API_MOBILE
+	    // viewDirection should be normalized here, but we avoid doing it as it's close enough and we save some ALU.
+	    inputData.viewDirectionWS = WorldSpaceViewDirection;
+#else
+	    inputData.viewDirectionWS = normalize(WorldSpaceViewDirection);
+#endif
+
+	    inputData.shadowCoord = IN.shadowCoord;
+
+	    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
+	    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
+	    inputData.bakedGI = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS);
+
+		half4 color = LightweightFragmentPBR(
+			inputData, 
+			Albedo, 
+			Metallic, 
+			Specular, 
+			Smoothness, 
+			Occlusion, 
+			Emission, 
+			Alpha);
+
+		// Computes fog factor per-vertex
+    	ApplyFog(color.rgb, IN.fogFactorAndVertexLight.x);
+
+#if _AlphaClip
+		clip(Alpha - AlphaClipThreshold);
+#endif
+		return color;
+    }
+
+	ENDHLSL
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template.meta
+fileFormatVersion: 2
+guid: 2353df0680be00447b3e7be2e8f1c71f
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightSubshaderFastBlinn.template
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightSubshaderFastBlinn.template
+SubShader
+{
+	Tags{"RenderType" = "Opaque" "RenderPipeline" = "LightweightPipeline"}
+
+	LOD ${LOD}
+	
+	Pass
+	{
+		Tags{"LightMode" = "LightweightForward"}
+		${Tags}
+		${Blending}
+		${Culling}
+		${ZTest}
+		${ZWrite}
+		
+		CGPROGRAM
+		#pragma target 3.0
+		
+		#pragma multi_compile _ _SINGLE_DIRECTIONAL_LIGHT _SINGLE_SPOT_LIGHT _SINGLE_POINT_LIGHT
+		#pragma multi_compile _ LIGHTWEIGHT_LINEAR
+		#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+		#pragma multi_compile _ LIGHTMAP_ON
+		#pragma multi_compile _ _LIGHT_PROBES_ON
+		#pragma multi_compile _ _HARD_SHADOWS _SOFT_SHADOWS _HARD_SHADOWS_CASCADES _SOFT_SHADOWS_CASCADES
+		#pragma multi_compile _ _VERTEX_LIGHTS
+		#pragma multi_compile_fog
+		#pragma multi_compile_instancing
+
+        #pragma vertex Vertex
+		#pragma fragment LightweightFragmentFastBlinn
+		#pragma glsl
+		#pragma debug
+		
+${Defines}
+		
+		#include "UnityCG.cginc"
+		
+		#define UNITY_SAMPLE_TEX2D(tex, coord) LIGHTWEIGHT_GAMMA_TO_LINEAR4(tex.Sample (sampler##tex,coord)) 
+		
+#define VERTEX_CUSTOM \
+	${VertexShaderBody}
+	
+//#define VERTINPUT_CUSTOM \
+	//${VertexInputs}
+
+#define VERTOUTPUT_CUSTOM \
+	${VertexOutputs}
+	
+		#include "CGIncludes/LightweightFastBlinn.cginc"
+
+${ShaderPropertyUsages}
+${ShaderFunctions}
+		
+		void DefineSurface(VertOutput i, inout SurfaceFastBlinn o)
+		{
+${PixelShaderBody}		
+		}
+	
+		ENDCG
+	}
+	
+	Pass
+	{
+		Tags{"Lightmode" = "ShadowCaster"}
+		ZWrite On ZTest LEqual
+
+		CGPROGRAM
+		#pragma target 2.0
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightPass.cginc"
+		#pragma vertex shadowVert
+		#pragma fragment shadowFrag
+		ENDCG
+	}
+
+	Pass
+	{
+		Tags{"Lightmode" = "DepthOnly"}
+		ZWrite On
+
+		CGPROGRAM
+		#pragma target 2.0
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightPass.cginc"
+		#pragma vertex depthVert
+		#pragma fragment depthFrag
+		ENDCG
+	}
+	
+	/*Pass
+	{
+		Tags{ "LightMode" = "Meta" }
+
+		Cull Off
+
+		CGPROGRAM
+		#define UNITY_SETUP_BRDF_INPUT SpecularSetup
+
+		#pragma shader_feature _EMISSION
+		#pragma shader_feature _SPECGLOSSMAP
+		#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		#pragma shader_feature ___ _DETAIL_MULX2
+		#pragma shader_feature EDITOR_VISUALIZATION
+		
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightPass.cginc"
+		#pragma vertex Vert_Meta
+		#pragma fragment frag_meta_ld
+		
+${ShaderPropertyUsages}
+${ShaderFunctions}
+
+		void DefineSurfaceMeta(VertOutput_Meta i, inout SurfaceFastBlinn o)
+		{
+${PixelShaderBody}	
+		}
+
+		ENDCG
+	}*/
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightSubshaderFastBlinn.template.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightSubshaderFastBlinn.template.meta
+fileFormatVersion: 2
+guid: bc924eeca96fbbf458b692b836fa8e56
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template
+Pass
+{
+    Tags{"LightMode" = "ShadowCaster"}
+
+    ZWrite On
+    ZTest LEqual
+    Cull ${Culling}
+
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+    #pragma target 2.0
+    
+    //--------------------------------------
+    // GPU Instancing
+    #pragma multi_compile_instancing
+
+    #pragma vertex ShadowPassVertex
+    #pragma fragment LitPassFragmentNull
+
+    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
+    ENDHLSL
+}
+
+Pass
+{
+    Tags{"LightMode" = "DepthOnly"}
+
+    ZWrite On
+    ColorMask 0
+
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+    #pragma target 2.0
+    
+    //--------------------------------------
+    // GPU Instancing
+    #pragma multi_compile_instancing
+
+    #pragma vertex LitPassVertex
+    #pragma fragment LitPassFragmentNull
+
+    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+    ENDHLSL
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template.meta
+fileFormatVersion: 2
+guid: 0474c29971caa2a40ae1719012fbe90a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template
+Pass
+{
+	Tags{"LightMode" = "LightweightForward"}
+	${Tags}
+	${Blending}
+	${Culling}
+	${ZTest}
+	${ZWrite}
+	
+    HLSLPROGRAM
+    // Required to compile gles 2.0 with standard srp library
+    #pragma prefer_hlslcc gles
+    #pragma vertex vert
+    #pragma fragment frag
+    #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ENABLE STEREO_MULTIVIEW_ENABLE
+    #pragma multi_compile_fog
+    #pragma shader_feature _SAMPLE_GI
+    #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
+    #pragma multi_compile_instancing
+
+	#pragma vertex vert
+    #pragma fragment frag
+
+    // Lighting include is needed because of GI
+    #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}
+
+    ${Graph}
+
+    struct GraphVertexOutput
+    {
+        float4 position : POSITION;
+        ${Interpolators}
+        UNITY_VERTEX_INPUT_INSTANCE_ID
+    };
+
+    GraphVertexOutput vert (GraphVertexInput v)
+	{
+	    v = PopulateVertexData(v);
+		
+        GraphVertexOutput o = (GraphVertexOutput)0;
+        
+        UNITY_SETUP_INSTANCE_ID(v);
+        UNITY_TRANSFER_INSTANCE_ID(v, o);
+
+        o.position = TransformObjectToHClip(v.vertex.xyz);
+        ${VertexShader}
+        return o;
+	}
+
+    half4 frag (GraphVertexOutput IN) : SV_Target
+    {
+        UNITY_SETUP_INSTANCE_ID(IN);
+
+    	${LocalPixelShader}
+    	
+        SurfaceInputs surfaceInput = (SurfaceInputs)0;
+        ${SurfaceInputs}
+
+        SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
+        float3 Color = float3(0.5, 0.5, 0.5);
+        float Alpha = 1;
+        float AlphaClipThreshold = 0;
+		${SurfaceOutputRemap}
+		
+ #if _AlphaClip
+        clip(Alpha - AlphaClipThreshold);
+#endif
+    	return half4(Color, Alpha);
+    }
+    ENDHLSL
+}
--- a/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template.meta
+++ b/ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template.meta
+fileFormatVersion: 2
+guid: 6076bf8142e1aab42843b38e9585e81c
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: