Initial attempt

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Editor/ShaderGUI/LightweightUnlitGUI.cs

     {
         blendModeProp = FindProperty("_Mode", properties);
         mainTexProp = FindProperty("_MainTex", properties);
-        mainColorProp = FindProperty("_MainColor", properties);
+        mainColorProp = FindProperty("_Color", properties);
         alphaCutoffProp = FindProperty("_Cutoff", properties);
     }
 

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightBRDF.cginc

     specularTerm = clamp(specularTerm, 0.0, 100.0); // Prevent FP16 overflow on mobiles
 #endif
 
-    return diffColor + specularTerm * specColor;
+	return diffColor + specularTerm * specColor;
 #else
     return diffColor;
 #endif

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightCore.cginc

 #endif
 }
 
+void ModifyVertex(inout LightweightVertexInput v);
+
 LightweightVertexOutput LightweightVertex(LightweightVertexInput v)
 {
     LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+	ModifyVertex(v);
 
     o.uv01.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
 #ifdef LIGHTMAP_ON

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightInput.cginc

 {
     float4 vertex : POSITION;
     float3 normal : NORMAL;
-    float4 tangent : TANGENT;
-    float2 texcoord : TEXCOORD0;
+    float4 tangent : TANGENT;		// normal map
+    float2 texcoord : TEXCOORD0;	// uv
     float2 lightmapUV : TEXCOORD1;
     UNITY_VERTEX_INPUT_INSTANCE_ID
 };
-    float4 uv01 : TEXCOORD0; // uv01.xy: uv0, uv01.zw: uv1
-    float4 posWS : TEXCOORD1;
+    float4 uv01 : TEXCOORD0; // uv01.xy: uv0, uv01.zw: uv1 // uv
+    float4 posWS : TEXCOORD1;	// lighting
-    half3 tangentToWorld0 : TEXCOORD2; // tangentToWorld matrix
+    half3 tangentToWorld0 : TEXCOORD2; // tangentToWorld matrix // normal map
-    half3 normal : TEXCOORD2;
+    half3 normal : TEXCOORD2; // no normal map
-    half4 viewDir : TEXCOORD5; // xyz: viewDir
-    half4 fogCoord : TEXCOORD6; // x: fogCoord, yzw: vertexColor
-    float4 hpos : SV_POSITION;
+    half4 viewDir : TEXCOORD5; // xyz: viewDir // lighting
+    half4 fogCoord : TEXCOORD6; // x: fogCoord, yzw: vertexColor // fog
+    float4 hpos : SV_POSITION; // lighting
     UNITY_VERTEX_OUTPUT_STEREO
 };
 

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightPBR.cginc

 #define LIGHTWEIGHT_PBR_INCLUDED
 
 #include "UnityStandardInput.cginc"
+#include "LightweightShadows.cginc"
 #include "LightweightBRDF.cginc"
 #include "LightweightCore.cginc"
 

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightShadows.cginc

 #ifndef LIGHTWEIGHT_SHADOWS_INCLUDED
 #define LIGHTWEIGHT_SHADOWS_INCLUDED
 
+#include "LightweightInput.cginc"
+
 #define MAX_SHADOW_CASCADES 4
 
 sampler2D_float _ShadowMap;

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightFastBlinn.shader

 			#pragma vertex LightweightVertex
             #pragma fragment LightweightFragmentFastBlinn
 
+			void ModifyVertex(inout LightweightVertexInput v)
+			{
+
+			}
+
 			void DefineSurface(LightweightVertexOutput i, inout SurfaceFastBlinn s)
 			{
 				// Albedo
 			#include "UnityCG.cginc"
 			#include "CGIncludes/LightweightPass.cginc"
             #pragma vertex vert_meta
-            #pragma fragment frag_meta_ld   
+            #pragma fragment frag_meta_ld
 
 			void DefineSurfaceMeta(v2f_meta i, inout SurfaceFastBlinn s)
 			{

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPBR.shader

             #pragma vertex LightweightVertex
             #pragma fragment LightweightFragmentPBR
 
+			void ModifyVertex(inout LightweightVertexInput v)
+			{
+
+			}
+
 			void DefineSurface(LightweightVertexOutput i, inout SurfacePBR s)
 			{
 				// Albedo

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightUnlit.shader

     Properties
     {
         _MainTex("Texture", 2D) = "white" {}
-        _MainColor("MainColor", Color) = (1, 1, 1, 1)
+        _Color("Color", Color) = (1, 1, 1, 1)
         _Cutoff("AlphaCutout", Range(0.0, 1.0)) = 0.5
 
         // BlendMode
         Pass
         {
             CGPROGRAM
-            #pragma vertex vert
-            #pragma fragment frag
+            
+			#include "CGIncludes/LightweightUnlit.cginc"
-            struct appdata
-            {
-                float4 vertex : POSITION;
-                float2 uv : TEXCOORD0;
-                UNITY_VERTEX_INPUT_INSTANCE_ID
-            };
-
-            struct v2f
-            {
-                float2 uv : TEXCOORD0;
-                UNITY_FOG_COORDS(1)
-                float4 vertex : SV_POSITION;
-                UNITY_VERTEX_OUTPUT_STEREO
-            };
-
-            sampler2D _MainTex;
-            float4 _MainTex_ST;
-            half4 _MainColor;
-            half _Cutoff;
-
-            v2f vert(appdata v)
-            {
-                v2f o;
-
-                UNITY_SETUP_INSTANCE_ID(v);
-                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+			#pragma vertex LightweightVertexUnlit
+            #pragma fragment LightweightFragmentUnlit
-                o.vertex = UnityObjectToClipPos(v.vertex);
-                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
-                UNITY_TRANSFER_FOG(o,o.vertex);
-                return o;
-            }
+			void ModifyVertex(inout appdata_unlit v)
+			{
-            fixed4 frag(v2f i) : SV_Target
-            {
-                fixed4 texColor = tex2D(_MainTex, i.uv);
-                fixed alpha = texColor.a * _MainColor.a;
-                fixed3 color = texColor.rgb * _MainColor.rgb;
+			}
+			void DefineSurface(LightweightVertexOutputUnlit i, inout SurfaceUnlit s)
+			{
+				// Albedo
+				float4 c = tex2D(_MainTex, i.uv);
+				s.Color = c.rgb * _Color.rgb;
+				// Alpha
+				s.Alpha = c.a * _Color.a;
-                clip(alpha - _Cutoff);
-#endif
-                UNITY_APPLY_FOG(i.fogCoord, color);
-
-#ifdef _ALPHABLEND_ON
-                return fixed4(color, alpha);
-#else
-                return fixed4(color, 1.0);
+				clip(s.Alpha - _Cutoff);
-            }
+			}
+            
             ENDCG
         }
     }

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightUnlit.cginc

+#ifndef LIGHTWEIGHT_UNLIT_INCLUDED
+#define LIGHTWEIGHT_UNLIT_INCLUDED
+
+//#include "UnityStandardInput.cginc"
+
+struct appdata_unlit
+{
+	float4 vertex : POSITION;
+	float2 uv : TEXCOORD0;
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutputUnlit
+{
+	float2 uv : TEXCOORD0;
+	UNITY_FOG_COORDS(1)
+		float4 vertex : SV_POSITION;
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+struct SurfaceUnlit
+{
+	float3 Color;     // color
+	float Alpha;        // alpha for transparencies
+};
+
+SurfaceUnlit InitializeSurfaceUnlit()
+{
+	SurfaceUnlit s;
+	s.Color = float3(0.5, 0.5, 0.5);
+	s.Alpha = 1;
+	return s;
+}
+
+void DefineSurface(LightweightVertexOutputUnlit i, inout SurfaceUnlit s);
+
+sampler2D _MainTex;
+float4 _MainTex_ST;
+half4 _Color;
+half _Cutoff;
+
+void ModifyVertex(inout appdata_unlit v);
+
+LightweightVertexOutputUnlit LightweightVertexUnlit(appdata_unlit v)
+{
+	LightweightVertexOutputUnlit o;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	ModifyVertex(v);
+
+    o.vertex = UnityObjectToClipPos(v.vertex);
+    o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+    UNITY_TRANSFER_FOG(o,o.vertex);
+    return o;
+}
+
+half4 LightweightFragmentUnlit(LightweightVertexOutputUnlit i) : SV_Target
+{
+	SurfaceUnlit s = InitializeSurfaceUnlit();
+	DefineSurface(i, s);
+
+	UNITY_APPLY_FOG(i.fogCoord, s.Color);
+
+#ifdef _ALPHABLEND_ON
+	return fixed4(s.Color, s.Alpha);
+#else
+	return fixed4(s.Color, 1.0);
+#endif
+};
+
+#endif

MaterialGraphProject/Assets/SRP/ScriptableRenderPipeline/LightweightPipeline/Shaders/CGIncludes/LightweightUnlit.cginc.meta

+fileFormatVersion: 2
+guid: 48b597269e31da549b83620e270727a5
+timeCreated: 1488965025
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Test-Legacy.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Test-Legacy
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_ShaderKeywords: _ALPHABLEND_ON _GLOSSYREFLECTIONS_ON _METALLICSPECGLOSSMAP _METALLIC_SETUP
+    _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA _SPECULARHIGHLIGHTS_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: e017404169662f041a969b0a924cc2ed, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 0.5
+    - _Glossiness: 0.5
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 2
+    - _OcclusionStrength: 0.5
+    - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 0.087
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _UVSec: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.9632353, g: 0.9632353, b: 0.9632353, a: 1}

MaterialGraphProject/Assets/Test-Legacy.mat.meta

+fileFormatVersion: 2
+guid: 093053a5cbe55cc48a60db27e2b28232
+timeCreated: 1505335385
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Test-PBR.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Test-PBR
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 1
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Metallic: 1
+    - _Mode: 0
+    - _OcclusionStrength: 0.5
+    - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

MaterialGraphProject/Assets/Test-PBR.mat.meta

+fileFormatVersion: 2
+guid: 9d1779795c4cf814e8732dc4542ac9ae
+timeCreated: 1505335385
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Test-Unlit.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Test-Unlit
+  m_Shader: {fileID: 4800000, guid: 650dd9526735d5b46b79224bc6e94025, type: 3}
+  m_ShaderKeywords: _ALPHABLEND_ON _GLOSSYREFLECTIONS_ON _METALLICSPECGLOSSMAP _METALLIC_SETUP
+    _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA _SPECULARHIGHLIGHTS_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: e017404169662f041a969b0a924cc2ed, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 2800000, guid: 5d84e1086e00e3347aaa0bbba206bb80, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 0.5
+    - _Glossiness: 0.5
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 2
+    - _OcclusionStrength: 0.5
+    - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 0.087
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _UVSec: 0
+    - _WorkflowMode: 1
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.9632353, g: 0.9632353, b: 0.9632353, a: 1}

MaterialGraphProject/Assets/Test-Unlit.mat.meta

+fileFormatVersion: 2
+guid: a94000a19a84e5c4f8816b53c83caa75
+timeCreated: 1505335385
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+SubShader
+{
+	Tags{"RenderType" = "Opaque" "RenderPipeline" = "LightweightPipeline"}
+
+	LOD ${LOD}
+	
+	Pass
+	{
+		Tags{"LightMode" = "LightweightForward"}
+		${Tags}
+		${Blending}
+		${Culling}
+		${ZTest}
+		${ZWrite}
+		
+		CGPROGRAM
+		#pragma target 3.0
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightPBR.cginc"
+		
+		#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+        #pragma multi_compile_fog
+		#pragma multi_compile_instancing
+
+        #pragma vertex LightweightVertex
+        #pragma fragment LightweightFragmentPBR
+		#pragma glsl
+		#pragma debug
+
+${ShaderPropertyUsages}
+${ShaderFunctions}
+
+/*		struct LightweightVertexInput
+		{
+${VertexInputs}
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+		};
+	
+		struct LightweightVertexOutput
+		{
+${VertexOutputs}
+		
+			UNITY_VERTEX_OUTPUT_STEREO
+		};
+	
+		LightweightVertexOutput LightweightVertexCustom(Input v)
+		{
+			LightweightVertexOutput o = (LightweightVertexOutput)0;
+			
+${VertexShaderBody}
+
+			UNITY_SETUP_INSTANCE_ID(v);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+			return o;
+		}*/
+		
+		void ModifyVertex(inout LightweightVertexInput v)
+		{
+${VertexShaderBody}		
+		}
+		
+		void DefineSurface(LightweightVertexOutput i, inout SurfacePBR s)
+		{
+${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
+	}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightSubshaderFastBlinn.template.meta

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

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

+SubShader
+{
+	Tags{"RenderType" = "Opaque" "RenderPipeline" = "LightweightPipeline"}
+
+	LOD ${LOD}
+	
+	Pass
+	{
+		Tags{"LightMode" = "LightweightForward"}
+		${Tags}
+		${Blending}
+		${Culling}
+		${ZTest}
+		${ZWrite}
+		
+		CGPROGRAM
+		#pragma target 3.0
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightFastBlinn.cginc"
+		
+		#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+        #pragma multi_compile_fog
+		#pragma multi_compile_instancing
+
+        #pragma vertex LightweightVertex
+        #pragma fragment LightweightFragmentFastBlinn
+		#pragma glsl
+		#pragma debug
+
+${ShaderPropertyUsages}
+${ShaderFunctions}
+
+/*		struct LightweightVertexInput
+		{
+${VertexInputs}
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+		};
+	
+		struct LightweightVertexOutput
+		{
+${VertexOutputs}
+		
+			UNITY_VERTEX_OUTPUT_STEREO
+		};
+	
+		LightweightVertexOutput LightweightVertexCustom(Input v)
+		{
+			LightweightVertexOutput o = (LightweightVertexOutput)0;
+			
+${VertexShaderBody}
+
+			UNITY_SETUP_INSTANCE_ID(v);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+			return o;
+		}*/
+		
+		void ModifyVertex(inout LightweightVertexInput v)
+		{
+${VertexShaderBody}		
+		}
+		
+		void DefineSurface(LightweightVertexOutput i, inout SurfaceFastBlinn s)
+		{
+${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 EDITOR_VISUALIZATION
+		
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightPass.cginc"
+		#pragma vertex vert_meta
+		#pragma fragment frag_meta_ld
+
+		void DefineSurfaceMeta(v2f_meta i, inout SurfaceFastBlinn s)
+		{
+			float2 uv = ${UV} //i.uv.xy
+${PixelShaderBody}				
+		}
+
+		ENDCG
+	}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightSubshaderPBR.template.meta

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

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

+SubShader
+{
+	Tags{"RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipeline"}
+
+	LOD ${LOD}
+	
+	Pass
+	{
+		Tags{"LightMode" = "LightweightForward"}
+		${Tags}
+		${Blending}
+		${Culling}
+		${ZTest}
+		${ZWrite}
+		
+		CGPROGRAM
+		#pragma target 3.0
+		#include "UnityCG.cginc"
+		#include "CGIncludes/LightweightUnlit.cginc"
+		
+		#pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+        #pragma multi_compile_fog
+		#pragma multi_compile_instancing
+
+        #pragma vertex LightweightVertexUnlit
+        #pragma fragment LightweightFragmentUnlit
+		#pragma glsl
+		#pragma debug
+
+${ShaderPropertyUsages}
+${ShaderFunctions}
+
+/*		struct appdata_unlit
+		{
+${VertexInputs}
+			UNITY_VERTEX_INPUT_INSTANCE_ID
+		};
+	
+		struct LightweightVertexOutputUnlit
+		{
+${VertexOutputs}
+		
+			UNITY_VERTEX_OUTPUT_STEREO
+		};
+	
+		LightweightVertexOutputUnlit LightweightVertexUnlitCustom(appdata_unlit v)
+		{
+			LightweightVertexOutputUnlit o = (LightweightVertexOutputUnlit)0;
+			
+${VertexShaderBody}
+
+			UNITY_SETUP_INSTANCE_ID(v);
+			UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+			return o;
+		}*/
+		
+		void ModifyVertex(inout appdata_unlit v)
+		{
+${VertexShaderBody}		
+		}
+		
+		void DefineSurface(LightweightVertexOutputUnlit i, inout SurfaceUnlit s)
+		{
+${PixelShaderBody}		
+		}
+	
+		ENDCG
+	}
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/lightweightSubshaderUnlit.template.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline.meta

+fileFormatVersion: 2
+guid: 916528b44860a914c9ce5f4db133a19b
+folderAsset: yes
+timeCreated: 1505322757
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/AbstractLightweightPBRMasterNode.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    public abstract class AbstractLightweightPBRMasterNode : AbstractMasterNode
+    {
+        public const string AlbedoSlotName = "Albedo";
+        public const string NormalSlotName = "Normal";
+        public const string EmissionSlotName = "Emission";
+        public const string SmoothnessSlotName = "Smoothness";
+        public const string OcclusionSlotName = "Occlusion";
+        public const string AlphaSlotName = "Alpha";
+        public const string VertexOffsetName = "VertexPosition";
+
+        public const int AlbedoSlotId = 0;
+        public const int NormalSlotId = 1;
+        public const int EmissionSlotId = 3;
+        public const int SmoothnessSlotId = 4;
+        public const int OcclusionSlotId = 5;
+        public const int AlphaSlotId = 6;
+        public const int VertexOffsetId = 7;
+
+        [SerializeField]
+        private SurfaceMaterialOptions m_MaterialOptions = new SurfaceMaterialOptions();
+
+        public SurfaceMaterialOptions options
+        {
+            get { return m_MaterialOptions; }
+        }
+
+        //public abstract string GetSurfaceOutputName();
+        //public abstract string GetLightFunction();
+
+
+        void GenerateNodeFunctionsAndPropertyUsages(
+            ShaderGenerator shaderBody,
+            ShaderGenerator propertyUsages,
+            ShaderGenerator nodeFunction,
+            GenerationMode mode,
+            int[] validNodeIds)
+        {
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this, NodeUtils.IncludeSelf.Include,
+                new List<int>(validNodeIds));
+
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+            {
+                if (node is IGeneratesFunction)
+                    (node as IGeneratesFunction).GenerateNodeFunction(nodeFunction, mode);
+
+                node.GeneratePropertyUsages(propertyUsages, mode);
+            }
+
+            var nodes = ListPool<INode>.Get();
+            //Get the rest of the nodes for all the other slots
+            NodeUtils.DepthFirstCollectNodesFromNode(nodes, this, NodeUtils.IncludeSelf.Exclude, new List<int>(vertexInputs));
+            for (var i = 0; i < nodes.Count; i++)
+            {
+                var node = nodes[i];
+                if (node is IGeneratesBodyCode)
+                    (node as IGeneratesBodyCode).GenerateNodeCode(shaderBody, mode);
+            }
+            ListPool<INode>.Release(nodes);
+        }
+
+        void GenerateVertexShaderInternal(
+            ShaderGenerator propertyUsages,
+            ShaderGenerator shaderBody,
+            ShaderGenerator nodeFunction,
+            ShaderGenerator vertexShaderBlock,
+            GenerationMode mode)
+        {
+            GenerateNodeFunctionsAndPropertyUsages(vertexShaderBlock, propertyUsages, nodeFunction, mode, vertexInputs);
+
+            var slot = FindInputSlot<MaterialSlot>(VertexOffsetId);
+            foreach (var edge in owner.GetEdges(slot.slotReference))
+            {
+                var outputRef = edge.outputSlot;
+                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                if (fromNode == null)
+                    continue;
+
+                var remapper = fromNode as INodeGroupRemapper;
+                if (remapper != null && !remapper.IsValidSlotConnection(outputRef.slotId))
+                    continue;
+
+                vertexShaderBlock.AddShaderChunk("v.vertex.xyz += " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+            }
+        }
+
+        public override string GetSubShader(GenerationMode mode, PropertyGenerator shaderPropertiesVisitor)
+        {
+            var templateLocation = ShaderGenerator.GetTemplatePath("lightweightSubshaderPBR.template");
+
+            if (!File.Exists(templateLocation))
+                return string.Empty;
+
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+                node.GeneratePropertyBlock(shaderPropertiesVisitor, mode);
+
+            var templateText = File.ReadAllText(templateLocation);
+            var shaderBodyVisitor = new ShaderGenerator();
+            var shaderFunctionVisitor = new ShaderGenerator();
+            var shaderPropertyUsagesVisitor = new ShaderGenerator();
+            var shaderInputVisitor = new ShaderGenerator();
+            var shaderOutputVisitor = new ShaderGenerator();
+            var vertexShaderBlock = new ShaderGenerator();
+
+            GenerateSurfaceShaderInternal(
+                shaderPropertyUsagesVisitor,
+                shaderBodyVisitor,
+                shaderFunctionVisitor,
+                shaderInputVisitor,
+                shaderOutputVisitor,
+                vertexShaderBlock,
+                mode);
+
+            GenerateVertexShaderInternal(
+                shaderPropertyUsagesVisitor,
+                shaderBodyVisitor,
+                shaderFunctionVisitor,
+                vertexShaderBlock,
+                mode);
+
+            var tagsVisitor = new ShaderGenerator();
+            var blendingVisitor = new ShaderGenerator();
+            var cullingVisitor = new ShaderGenerator();
+            var zTestVisitor = new ShaderGenerator();
+            var zWriteVisitor = new ShaderGenerator();
+
+            m_MaterialOptions.GetTags(tagsVisitor);
+            m_MaterialOptions.GetBlend(blendingVisitor);
+            m_MaterialOptions.GetCull(cullingVisitor);
+            m_MaterialOptions.GetDepthTest(zTestVisitor);
+            m_MaterialOptions.GetDepthWrite(zWriteVisitor);
+
+            var resultShader = templateText.Replace("${ShaderPropertyUsages}", shaderPropertyUsagesVisitor.GetShaderString(2));
+            //resultShader = resultShader.Replace("${LightingFunctionName}", GetLightFunction());
+            //resultShader = resultShader.Replace("${SurfaceOutputStructureName}", GetSurfaceOutputName());
+            resultShader = resultShader.Replace("${ShaderFunctions}", shaderFunctionVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ShaderInputs}", shaderInputVisitor.GetShaderString(3));
+            resultShader = resultShader.Replace("${ShaderOutputs}", shaderOutputVisitor.GetShaderString(3));
+            resultShader = resultShader.Replace("${PixelShaderBody}", shaderBodyVisitor.GetShaderString(3));
+            resultShader = resultShader.Replace("${Tags}", tagsVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${Blending}", blendingVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${Culling}", cullingVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ZTest}", zTestVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${ZWrite}", zWriteVisitor.GetShaderString(2));
+            resultShader = resultShader.Replace("${LOD}", "" + m_MaterialOptions.lod);
+
+            //resultShader = resultShader.Replace("${VertexShaderDecl}", "vertex:vert");
+            resultShader = resultShader.Replace("${VertexShaderBody}", vertexShaderBlock.GetShaderString(3));
+
+            return resultShader;
+        }
+
+        public override string GetFullShader(GenerationMode mode, string name, out List<PropertyGenerator.TextureInfo> configuredTextures)
+        {
+            var templateLocation = ShaderGenerator.GetTemplatePath("shader.template");
+
+            if (!File.Exists(templateLocation))
+            {
+                configuredTextures = new List<PropertyGenerator.TextureInfo>();
+                return string.Empty;
+            }
+
+            var templateText = File.ReadAllText(templateLocation);
+
+            var shaderPropertiesVisitor = new PropertyGenerator();
+            var resultShader = templateText.Replace("${ShaderName}", name);
+            resultShader = resultShader.Replace("${SubShader}", GetSubShader(mode, shaderPropertiesVisitor));
+            resultShader = resultShader.Replace("${ShaderPropertiesHeader}", shaderPropertiesVisitor.GetShaderString(2));
+            //resultShader = templateText.Replace("${Fallback}", "Diffuse");
+            configuredTextures = shaderPropertiesVisitor.GetConfiguredTexutres();
+            return Regex.Replace(resultShader, @"\r\n|\n\r|\n|\r", Environment.NewLine);
+        }
+
+        protected abstract int[] surfaceInputs
+        {
+            get;
+        }
+
+        protected abstract int[] vertexInputs
+        {
+            get;
+        }
+
+        private void GenerateSurfaceShaderInternal(
+            ShaderGenerator propertyUsages,
+            ShaderGenerator shaderBody,
+            ShaderGenerator nodeFunction,
+            ShaderGenerator shaderInputVisitor,
+            ShaderGenerator shaderOutputVisitor,
+            ShaderGenerator vertexShaderBlock,
+            GenerationMode mode)
+        {
+            var activeNodeList = new List<INode>();
+            NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this, NodeUtils.IncludeSelf.Include,
+                new List<int>(surfaceInputs));
+
+            foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
+            {
+                if (node is IGeneratesFunction)
+                {
+                    ((IGeneratesFunction)node).GenerateNodeFunction(nodeFunction, mode);
+                }
+
+                node.GeneratePropertyUsages(propertyUsages, mode);
+            }
+
+            int vertInputIndex = 1; // DIRTY
+            int vertOutputIndex = 3; // DIRTY
+
+            // Need these for lighting
+            shaderInputVisitor.AddShaderChunk("float4 vertex : POSITION;", true);
+            shaderInputVisitor.AddShaderChunk("float4 normal : NORMAL;", true);
+            shaderInputVisitor.AddShaderChunk("float2 lightmapUV : TEXCOORD0;", true);
+            // always add color because why not. 
+            shaderInputVisitor.AddShaderChunk("float4 color : COLOR;", true);
+
+            // Need these for lighting
+            shaderOutputVisitor.AddShaderChunk("float4 posWS : TEXCOORD0;", true);
+            shaderOutputVisitor.AddShaderChunk("half4 viewDir : TEXCOORD1;", true);
+            shaderOutputVisitor.AddShaderChunk("half4 fogCoord : TEXCOORD2;", true);
+            shaderOutputVisitor.AddShaderChunk("float4 hpos : SV_POSITION;", true);
+            
+            bool requiresBitangent = activeNodeList.OfType<IMayRequireBitangent>().Any(x => x.RequiresBitangent());
+            bool requiresTangent = activeNodeList.OfType<IMayRequireTangent>().Any(x => x.RequiresTangent());
+            bool requiresViewDirTangentSpace = activeNodeList.OfType<IMayRequireViewDirectionTangentSpace>().Any(x => x.RequiresViewDirectionTangentSpace());
+            bool requiresViewDir = activeNodeList.OfType<IMayRequireViewDirection>().Any(x => x.RequiresViewDirection());
+            bool requiresWorldPos = activeNodeList.OfType<IMayRequireWorldPosition>().Any(x => x.RequiresWorldPosition());
+            bool requiresNormal = activeNodeList.OfType<IMayRequireNormal>().Any(x => x.RequiresNormal());
+            bool requiresScreenPosition = activeNodeList.OfType<IMayRequireScreenPosition>().Any(x => x.RequiresScreenPosition());
+            bool requiresVertexColor = activeNodeList.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor());
+            
+            for (int uvIndex = 0; uvIndex < ShaderGeneratorNames.UVCount; ++uvIndex)
+            {
+                var channel = (UVChannel)uvIndex;
+                if (activeNodeList.OfType<IMayRequireMeshUV>().Any(x => x.RequiresMeshUV(channel)))
+                {
+                    shaderInputVisitor.AddShaderChunk(string.Format("half4 texcoord{0} : TEXCOORD{1};", uvIndex, vertInputIndex), true);
+                    shaderOutputVisitor.AddShaderChunk(string.Format("half4 meshUV{0} : TEXCOORD{1};", uvIndex, vertOutputIndex), true);
+                    vertexShaderBlock.AddShaderChunk(string.Format("o.meshUV{0} = v.texcoord{1};", uvIndex, uvIndex/*uvIndex == 0 ? "" : uvIndex.ToString()*/), true);
+                    shaderBody.AddShaderChunk(string.Format("half4 {0} = i.meshUV{1};", channel.GetUVName(), uvIndex), true);
+                    vertInputIndex++;
+                    vertOutputIndex++;
+                    //shaderInputVisitor.AddShaderChunk(string.Format("half4 meshUV{0};", uvIndex), true);
+                    //vertexShaderBlock.AddShaderChunk(string.Format("o.meshUV{0} = v.texcoord{1};", uvIndex, uvIndex == 0 ? "" : uvIndex.ToString()), true);
+                    //shaderBody.AddShaderChunk(string.Format("half4 {0} = IN.meshUV{1};", channel.GetUVName(), uvIndex), true);
+                }
+            }
+
+            if (requiresViewDir || requiresViewDirTangentSpace)
+            {
+                shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceViewDirection + " = i.viewDir;", true);
+                //shaderInputVisitor.AddShaderChunk("float3 worldViewDir;", true);
+                //shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceViewDirection  + " = IN.worldViewDir;", true);
+            }
+
+            if (requiresWorldPos)
+            {
+                shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpacePosition + " = i.posWS;", true);
+                //shaderInputVisitor.AddShaderChunk("float3 worldPos;", true);
+                //shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpacePosition + " = IN.worldPos;", true);
+            }
+
+            if (requiresScreenPosition)
+            {
+                shaderInputVisitor.AddShaderChunk(string.Format("half4 screenPos : TEXCOORD{0};", vertInputIndex), true);
+                shaderOutputVisitor.AddShaderChunk(string.Format("half4 screenPos : TEXCOORD{0};", vertOutputIndex), true);
+                vertexShaderBlock.AddShaderChunk("o.screenPos = v.screenPos;", true);
+                shaderBody.AddShaderChunk("float4 " + ShaderGeneratorNames.ScreenPosition + " = i.screenPos;", true);
+                vertInputIndex++;
+                vertOutputIndex++;
+                //shaderInputVisitor.AddShaderChunk("float4 screenPos;", true);
+                //shaderBody.AddShaderChunk("float4 " + ShaderGeneratorNames.ScreenPosition + " = IN.screenPos;", true);
+            }
+
+            if (requiresBitangent || requiresTangent || requiresViewDirTangentSpace)
+            {
+                shaderInputVisitor.AddShaderChunk(string.Format("half4 tangent : TEXCOORD{0};", vertInputIndex), true);
+                shaderOutputVisitor.AddShaderChunk(string.Format("half4 tangentWS : TEXCOORD{0};", vertOutputIndex), true);
+                vertexShaderBlock.AddShaderChunk("o.tangentWS = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);", true);
+                shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceTangent + " = normalize(i.worldTangent.xyz);", true);
+                vertInputIndex++;
+                vertOutputIndex++;
+
+                //shaderInputVisitor.AddShaderChunk("float4 worldTangent;", true);
+                //vertexShaderBlock.AddShaderChunk("o.worldTangent = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);", true);
+                //shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceTangent + " = normalize(IN.worldTangent.xyz);", true);
+            }
+
+            if (requiresBitangent || requiresNormal || requiresViewDirTangentSpace)
+            {
+                // is the normal connected?
+                var normalSlot = FindInputSlot<MaterialSlot>(NormalSlotId);
+                var edges = owner.GetEdges(normalSlot.slotReference);
+
+                shaderInputVisitor.AddShaderChunk(string.Format("half4 normalWS : TEXCOORD{0};", vertInputIndex), true);
+                shaderOutputVisitor.AddShaderChunk(string.Format("half4 normalWS : TEXCOORD{0};", vertOutputIndex), true);
+                vertexShaderBlock.AddShaderChunk("o.normalWS = unity_ObjectToWorld(v.normal);", true);
+                shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceNormal + " = normalize(i.normalWS);", true);
+                vertInputIndex++;
+                vertOutputIndex++;
+
+                //shaderInputVisitor.AddShaderChunk("float3 worldNormal;", true);
+                if (edges.Any())
+                    shaderInputVisitor.AddShaderChunk("INTERNAL_DATA", true);
+                
+                //shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.WorldSpaceNormal + " = normalize(IN.worldNormal);", true);
+            }
+
+            if (requiresBitangent || requiresViewDirTangentSpace)
+            {
+                shaderBody.AddShaderChunk(string.Format("float3 {0} = cross({1}, {2}) * i.tangentWS.w;", ShaderGeneratorNames.WorldSpaceBitangent, ShaderGeneratorNames.WorldSpaceNormal, ShaderGeneratorNames.WorldSpaceTangent), true);
+                //shaderBody.AddShaderChunk(string.Format("float3 {0} = cross({1}, {2}) * IN.worldTangent.w;", ShaderGeneratorNames.WorldSpaceBitangent, ShaderGeneratorNames.WorldSpaceNormal, ShaderGeneratorNames.WorldSpaceTangent), true);
+            }
+
+            if (requiresViewDirTangentSpace)
+            {
+                //                shaderInputVisitor.AddShaderChunk("float3 tangentViewDir;", true);
+                //                shaderBody.AddShaderChunk("float3 " + ShaderGeneratorNames.TangentSpaceViewDirection + " = IN.tangentViewDir;", true);
+                shaderBody.AddShaderChunk(
+                    "float3 " + ShaderGeneratorNames.TangentSpaceViewDirection + ";", true);
+
+                shaderBody.AddShaderChunk(
+                    ShaderGeneratorNames.TangentSpaceViewDirection + ".x = dot(" +
+                    ShaderGeneratorNames.WorldSpaceViewDirection + "," +
+                    ShaderGeneratorNames.WorldSpaceTangent + ");", true);
+
+                shaderBody.AddShaderChunk(
+                    ShaderGeneratorNames.TangentSpaceViewDirection + ".y = dot(" +
+                    ShaderGeneratorNames.WorldSpaceViewDirection + "," +
+                    ShaderGeneratorNames.WorldSpaceBitangent + ");", true);
+
+                shaderBody.AddShaderChunk(
+                    ShaderGeneratorNames.TangentSpaceViewDirection + ".z = dot(" +
+                    ShaderGeneratorNames.WorldSpaceViewDirection + "," +
+                    ShaderGeneratorNames.WorldSpaceNormal + ");", true);
+            }
+
+
+            if (requiresVertexColor)
+            {
+                shaderOutputVisitor.AddShaderChunk(string.Format("half4 color : TEXCOORD{0};", vertOutputIndex), true);
+                shaderBody.AddShaderChunk("float4 " + ShaderGeneratorNames.VertexColor + " = i.color;", true);
+                vertInputIndex++;
+                vertOutputIndex++;
+
+                //shaderBody.AddShaderChunk("float4 " + ShaderGeneratorNames.VertexColor + " = IN.color;", true);
+            }
+
+            GenerateNodeCode(shaderBody, mode);
+        }
+
+        public void GenerateNodeCode(ShaderGenerator shaderBody, GenerationMode generationMode)
+        {
+            var nodes = ListPool<INode>.Get();
+
+            //Get the rest of the nodes for all the other slots
+            NodeUtils.DepthFirstCollectNodesFromNode(nodes, this, NodeUtils.IncludeSelf.Exclude, new List<int>(surfaceInputs));
+            for (var i = 0; i < nodes.Count; i++)
+            {
+                var node = nodes[i];
+                if (node is IGeneratesBodyCode)
+                    (node as IGeneratesBodyCode).GenerateNodeCode(shaderBody, generationMode);
+            }
+            ListPool<INode>.Release(nodes);
+
+            foreach (var slot in GetInputSlots<MaterialSlot>())
+            {
+                if (surfaceInputs.Contains(slot.id))
+                {
+                    foreach (var edge in owner.GetEdges(slot.slotReference))
+                    {
+                        var outputRef = edge.outputSlot;
+                        var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(outputRef.nodeGuid);
+                        if (fromNode == null)
+                            continue;
+
+                        var remapper = fromNode as INodeGroupRemapper;
+                        if (remapper != null && !remapper.IsValidSlotConnection(outputRef.slotId))
+                            continue;
+
+                        shaderBody.AddShaderChunk("s." + slot.shaderOutputName + " = " + fromNode.GetVariableNameForSlot(outputRef.slotId) + ";", true);
+
+                        if (slot.id == NormalSlotId)
+                            shaderBody.AddShaderChunk("o." + slot.shaderOutputName + " += 1e-6;", true);
+                    }
+                }
+            }
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/AbstractLightweightPBRMasterNode.cs.meta

+fileFormatVersion: 2
+guid: 1ac259924f8784a4aa1eb5e9e556b08d
+timeCreated: 1478188276
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/LightweightMetallicMasterNode.cs

+using System;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Serializable]
+    [Title("Master/Metallic")]
+    public class LightweightMetallicMasterNode : AbstractLightweightPBRMasterNode
+    {
+        public const string MetallicSlotName = "Lightweight PBR Metallic";
+        public const int MetallicSlotId = 2;
+
+        //public const string LightFunctionName = "Standard";
+        //public const string SurfaceOutputStructureName = "SurfaceOutputStandard";
+
+        public LightweightMetallicMasterNode()
+        {
+            name = "LightweightMetallicMasterNode";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new MaterialSlot(VertexOffsetId, VertexOffsetName, VertexOffsetName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Vertex));
+            AddSlot(new MaterialSlot(AlbedoSlotId, AlbedoSlotName, AlbedoSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(NormalSlotId, NormalSlotName, NormalSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(EmissionSlotId, EmissionSlotName, EmissionSlotName, SlotType.Input, SlotValueType.Vector3, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(MetallicSlotId, MetallicSlotName, MetallicSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(SmoothnessSlotId, SmoothnessSlotName, SmoothnessSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(OcclusionSlotId, OcclusionSlotName, OcclusionSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+            AddSlot(new MaterialSlot(AlphaSlotId, AlphaSlotName, AlphaSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.zero, ShaderStage.Fragment));
+
+            // clear out slot names that do not match the slots
+            // we support
+            RemoveSlotsNameNotMatching(
+                new[]
+            {
+                AlbedoSlotId,
+                NormalSlotId,
+                EmissionSlotId,
+                MetallicSlotId,
+                SmoothnessSlotId,
+                OcclusionSlotId,
+                AlphaSlotId,
+                VertexOffsetId
+            });
+        }
+
+        protected override int[] surfaceInputs
+        {
+            get
+            {
+                return new[]
+                {
+                    AlbedoSlotId,
+                    NormalSlotId,
+                    EmissionSlotId,
+                    MetallicSlotId,
+                    SmoothnessSlotId,
+                    OcclusionSlotId,
+                    AlphaSlotId,
+                };
+            }
+        }
+
+        protected override int[] vertexInputs
+        {
+            get
+            {
+                return new[]
+                {
+                    VertexOffsetId
+                };
+            }
+        }
+
+        /*public override string GetSurfaceOutputName()
+        {
+            return SurfaceOutputStructureName;
+        }
+
+        public override string GetLightFunction()
+        {
+            return LightFunctionName;
+        }*/
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/LightweightMetallicMasterNode.cs.meta

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

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/ShaderTest.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 8
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 9
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_TextureWidth: 1024
+    m_TextureHeight: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &301674285
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 301674289}
+  - component: {fileID: 301674288}
+  - component: {fileID: 301674287}
+  - component: {fileID: 301674286}
+  m_Layer: 0
+  m_Name: Sphere (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &301674286
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 301674285}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 093053a5cbe55cc48a60db27e2b28232, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &301674287
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 301674285}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &301674288
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 301674285}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &301674289
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 301674285}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0.323, y: 0.913, z: -0.176}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1225352826
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1225352830}
+  - component: {fileID: 1225352829}
+  - component: {fileID: 1225352828}
+  - component: {fileID: 1225352827}
+  m_Layer: 0
+  m_Name: Sphere (2)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &1225352827
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225352826}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: a94000a19a84e5c4f8816b53c83caa75, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &1225352828
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225352826}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1225352829
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225352826}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1225352830
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225352826}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -3.087}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1225949929
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1225949933}
+  - component: {fileID: 1225949932}
+  - component: {fileID: 1225949931}
+  - component: {fileID: 1225949930}
+  m_Layer: 0
+  m_Name: Sphere
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &1225949930
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225949929}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 9d1779795c4cf814e8732dc4542ac9ae, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &1225949931
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225949929}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1225949932
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225949929}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1225949933
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1225949929}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1641918147
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1641918149}
+  - component: {fileID: 1641918148}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1641918148
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1641918147}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1641918149
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1641918147}
+  m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
+  m_LocalPosition: {x: 0, y: 3, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
+--- !u!1 &1913430569
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1913430573}
+  - component: {fileID: 1913430572}
+  - component: {fileID: 1913430571}
+  - component: {fileID: 1913430570}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1913430570
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1913430569}
+  m_Enabled: 1
+--- !u!124 &1913430571
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1913430569}
+  m_Enabled: 1
+--- !u!20 &1913430572
+Camera:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1913430569}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: 3
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!4 &1913430573
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1913430569}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &2131834041
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 2131834045}
+  - component: {fileID: 2131834044}
+  - component: {fileID: 2131834043}
+  - component: {fileID: 2131834042}
+  m_Layer: 0
+  m_Name: Sphere (3)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &2131834042
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2131834041}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 093053a5cbe55cc48a60db27e2b28232, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &2131834043
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2131834041}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &2131834044
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2131834041}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &2131834045
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2131834041}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0.323, y: 0.913, z: -0.176}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 5
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/LightweightPipeline/ShaderTest.unity.meta

+fileFormatVersion: 2
+guid: 7878b24712c094649abcc7b75433986c
+timeCreated: 1505339540
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: