Merge remote-tracking branch 'origin/master' into HDRP_GraphicTests

ScriptableRenderPipeline/Core/CoreRP/CoreResources/EncodeBC6H.compute

 #include "CoreRP/ShaderLibrary/BC6H.hlsl"
 #include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;
 int _MipIndex;

ScriptableRenderPipeline/Core/CoreRP/CoreResources/GPUCopy.compute

 
 #include "../ShaderLibrary/Common.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 RWTexture2D<float1> _Result1;
 
 Texture2D<float4> _Source4;

ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowBlurMoments.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/Shadow/ShadowMoments.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #if MAX_MSAA > 1
 Texture2DMS<float> depthTex;
 #else

ScriptableRenderPipeline/Core/CoreRP/TextureCache.cs

 using System;
-using UnityEngine;
 using System.Collections.Generic;
 using UnityEngine.Rendering;
 #if UNITY_EDITOR
 
         public void Release()
         {
-            Texture.DestroyImmediate(m_Cache);      // do I need this?
+            CoreUtils.Destroy(m_Cache);
         }
     }
 
                 {
                     m_CubeMipLevelPropName = Shader.PropertyToID("_cubeMipLvl");
                     m_cubeSrcTexPropName = Shader.PropertyToID("_srcCubeTexture");
+
                 }
             }
             else
         {
             if (m_CacheNoCubeArray)
             {
-                Texture.DestroyImmediate(m_CacheNoCubeArray);
+                CoreUtils.Destroy(m_CacheNoCubeArray);
-                if (m_CubeBlitMaterial) Material.DestroyImmediate(m_CubeBlitMaterial);
+                CoreUtils.Destroy(m_CubeBlitMaterial);
-            if (m_Cache)
-                Texture.DestroyImmediate(m_Cache);
+
+            CoreUtils.Destroy(m_Cache);
         }
 
         private void TransferToPanoCache(CommandBuffer cmd, int sliceIndex, Texture texture)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

         // Core\CoreRP\ShaderLibrary\UnityInstancing.hlsl
         // #if defined(SHADER_API_VULKAN) && defined(SHADER_API_MOBILE)
         //      #define UNITY_INSTANCED_ARRAY_SIZE  250
-        private const int kDrawIndexedBatchSize = 250; 
+        private const int kDrawIndexedBatchSize = 250;
 
         // cube mesh bounds for decal
         static Vector4 kMin = new Vector4(-0.5f, -1.0f, -0.5f, 1.0f);
                 m_DiffuseTexture = m_Material.GetTexture("_BaseColorMap");
                 m_NormalTexture = m_Material.GetTexture("_NormalMap");
                 m_MaskTexture = m_Material.GetTexture("_MaskMap");
-                m_Blend = m_Material.GetFloat("_DecalBlend");                
+                m_Blend = m_Material.GetFloat("_DecalBlend");
             }
 
             public DecalSet(Material material)
                         normalToWorldBatch[instanceCount].m23 = m_NormalTexIndex;
                         normalToWorldBatch[instanceCount].m33 = m_MaskTexIndex;
 
-                        
-                        // clustered forward data                        
-                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse; 
+
+                        // clustered forward data
+                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
-                        
+
                         instanceCount++;
                         if (instanceCount == kDrawIndexedBatchSize)
                         {
                 InitializeMaterialValues(); // refresh in case they changed in the UI
                 UpdateTextureCache(cmd);
             }
-      
+
             public void RenderIntoDBuffer(CommandBuffer cmd)
             {
                 if(m_NumResults == 0)
                 {
                     m_PropertyBlock.SetMatrixArray(HDShaderIDs._NormalToWorldID, m_NormalToWorld[batchIndex]);
                     cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_DecalToWorld[batchIndex], totalToDraw, m_PropertyBlock);
-                }                
+                }
-           
+
             public Material KeyMaterial
             {
                 get
             private int m_NormalTexIndex = -1;
             private int m_MaskTexIndex = -1;
         }
-        
+
         public void AddDecal(DecalProjectorComponent decal)
         {
 			if (decal.CullIndex != DecalProjectorComponent.kInvalidIndex) //do not add the same decal more than once
             foreach (var pair in m_DecalSets)
             {
                 pair.Value.RenderIntoDBuffer(cmd);
-            }            
+            }
         }
 
         public void SetAtlas(CommandBuffer cmd)
 
         public void CreateDrawData()
         {
-            m_DecalDatasCount = 0;           
+            m_DecalDatasCount = 0;
             // reallocate if needed
             if (m_DecalsVisibleThisFrame > m_DecalDatas.Length)
             {
             {
                 pair.Value.CreateDrawData();
             }
+        }
+
+        public void Cleanup()
+        {
+            if (m_DecalAtlas != null)
+                m_DecalAtlas.Release();
+            CoreUtils.Destroy(m_DecalMesh);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             // For debugging
             MousePositionDebug.instance.Cleanup();
 
+            DecalSystem.instance.Cleanup();
+
             m_MaterialList.ForEach(material => material.Cleanup());
 
             CoreUtils.Destroy(m_CopyStencilForNoLighting);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 #include "../ShaderVariables.hlsl"
 #include "Lighting.hlsl" 
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //#pragma enable_d3d11_debug_symbols
 
 RWTexture2D<float4> _DeferredShadowTextureUAV;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 #include "../../Debug/DebugDisplay.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //-------------------------------------------------------------------------------------
 // variable declaration
 //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/builddispatchindirect.compute

 #pragma kernel BuildDispatchIndirect
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "LightLoop.cs.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/cleardispatchindirect.compute

 #pragma kernel ClearDispatchIndirect
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 RWBuffer<uint> g_DispatchIndirectBuffer : register( u0 );	// Indirect arguments have to be in a _buffer_, not a structured buffer
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-bigtile.compute

 #include "LightingConvexHullUtils.hlsl"
 #include "SortingComputeUtils.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild-clustered.compute

 #include "SortingComputeUtils.hlsl"
 #endif
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //#define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 #define CONV_HULL_TEST_ENABLED

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/lightlistbuild.compute

 #include "SortingComputeUtils.hlsl"
 #endif
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define FINE_PRUNING_ENABLED
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/materialflags.compute

 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 #include "../../Lighting/LightDefinition.cs.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/scrbound.compute

 #include "CoreRP/ShaderLibrary/common.hlsl"
 #include "LightLoop.cs.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

 #include "../../Lighting.hlsl" // Includes Material.hlsl
 #include "../../LightEvaluation.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 //--------------------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/BuildProbabilityTables.compute

 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 #include "../../ShaderVariables.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 /* --- Input --- */
 
 #define TEXTURE_HEIGHT 256                // Equiareal texture map: cos(theta) = 1.0 - 2.0 * v

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/ComputeGgxIblSampleData.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #ifdef SHADER_API_MOBILE
 #define MAX_IBL_SAMPLE_CNT 34
 #else

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.compute

 #include "../../Lighting/LightDefinition.cs.hlsl"
 #include "SubsurfaceScattering.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 //--------------------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ApplyDistorsion.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../Material/Builtin/BuiltinData.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 TEXTURE2D(_DistortionTexture);
 TEXTURE2D(_GaussianPyramidColorTexture);
 RW_TEXTURE2D(float4, _CameraColorTexture);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ColorPyramid.compute

 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 Texture2D<float4> _Source;
 RWTexture2D<float4> _Result;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DepthPyramid.compute

 #pragma kernel KMain_8                KERNEL_SIZE=8     KERNEL_NAME=KMain_8
 #pragma kernel KMain_1                KERNEL_SIZE=1     KERNEL_NAME=KMain_1
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 Texture2D<float> _Source;
 RWTexture2D<float> _Result;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyManager.cs

             result.Apply();
 
             UnityEngine.Graphics.SetRenderTarget(null);
-            Object.DestroyImmediate(temp);
-            Object.DestroyImmediate(tempRT);
+            CoreUtils.Destroy(temp);
+            CoreUtils.Destroy(tempRT);
 
             return result;
         }

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": [

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
             #pragma multi_compile_instancing
 
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+            #pragma multi_compile _ LIGHTMAP_ON
+
             // Lighting include is needed because of GI
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
             #include "LWRP/ShaderLibrary/InputSurface.hlsl"
 
 #if _SAMPLE_GI
                 OUTPUT_NORMAL(v, o);
-                half3 normalWS = o.normal;
-                OUTPUT_SH(normalWS, o.lightmapOrVertexSH);
+                OUTPUT_SH(o.normal, o.lightmapOrVertexSH);
 #endif
                 return o;
             }
     #else
                 half3 normalWS = normalize(IN.normal);
     #endif
-                color += SampleGI(IN.lightmapOrVertexSH, normalWS);
+                color *= SampleGI(IN.lightmapOrVertexSH, normalWS);
 #endif
                 ApplyFog(color, IN.uv0AndFogCoord.z);
 

ScriptableRenderPipeline/LightweightPipeline/sub-package.json

 	"description": "Lightweight Render Pipeline for Unity.",
     "subDependencies": [
         "com.unity.render-pipelines.core"
-    ]
+    ],
+    "dependencies": {
+        "com.unity.shadergraph": "0.1.19"
+    }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows.meta

+fileFormatVersion: 2
+guid: c5d39f83747e41446b413632dde29652
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph.meta

+fileFormatVersion: 2
+guid: ae1e56b12b01f3b4d9c9bb9d7154d97f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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: 

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: 

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
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRExtraPasses.template.meta

+fileFormatVersion: 2
+guid: 5fa0a7ad9ac73b34691439e5cf40a1c3
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template.meta

+fileFormatVersion: 2
+guid: 2353df0680be00447b3e7be2e8f1c71f
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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
+	}*/
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightSubshaderFastBlinn.template.meta

+fileFormatVersion: 2
+guid: bc924eeca96fbbf458b692b836fa8e56
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitExtraPasses.template.meta

+fileFormatVersion: 2
+guid: 0474c29971caa2a40ae1719012fbe90a
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGraph/lightweightUnlitPass.template.meta

+fileFormatVersion: 2
+guid: 6076bf8142e1aab42843b38e9585e81c
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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", 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);
+        }
+    }
+}

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", 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);
+        }
+    }
+}