Merge branch 'LWRP' into lw/bugfixes

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugWindow.cs

             if (m_Settings == null)
                 m_Settings = CreateInstance<DebugWindowSettings>();
 
-            if (m_WidgetStates == null)
+            // States are ScriptableObjects (necessary for Undo/Redo) but are not saved on disk so when the editor is closed then reopened, any existing debug window will have its states set to null
+            // Since we don't care about persistance in this case, we just re-init everything.
+            if (m_WidgetStates == null || !AreWidgetStatesValid())
                 m_WidgetStates = new WidgetStateDictionary();
 
             if (s_WidgetStateMap == null || s_WidgetDrawerMap == null || s_TypeMapDirty)
 
                 m_WidgetStates.Clear();
             }
+        }
+
+        bool AreWidgetStatesValid()
+        {
+            foreach (var state in m_WidgetStates)
+            {
+                if(state.Value == null)
+                {
+                    return false;
+                }
+            }
+            return true;
         }
 
         void MarkDirty()

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

 	#pragma vertex ShadowPassVertex
 	#pragma fragment ShadowPassFragment
 
+	#include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
 	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
 
 	ENDHLSL
 	// GPU Instancing
 	#pragma multi_compile_instancing
 
+	#include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
 	#include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
 	ENDHLSL
 }
 
 	#pragma shader_feature _SPECGLOSSMAP
 
+	#include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
-}
+}

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

 	#pragma vertex ShadowPassVertex
 	#pragma fragment ShadowPassFragment
 
+	#include "LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl"
 	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
 
 	ENDHLSL
 	// GPU Instancing
 	#pragma multi_compile_instancing
 
+	#include "LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl"
-}
+}

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

     #include "LWRP/ShaderLibrary/Core.hlsl"
     #include "LWRP/ShaderLibrary/Lighting.hlsl"
     #include "CoreRP/ShaderLibrary/Color.hlsl"
-    #include "LWRP/ShaderLibrary/InputSurface.hlsl"
+    #include "LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl"
     #include "ShaderGraphLibrary/Functions.hlsl"
 
     ${Defines}
         float AlphaClipThreshold = 0;
 		${SurfaceOutputRemap}
 		
- #if _AlphaClip
+#if _AlphaClip
         clip(Alpha - AlphaClipThreshold);
 #endif
     	return half4(Color, Alpha);

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         private int m_ScreenSpaceShadowMapRTID;
         private Matrix4x4[] m_ShadowMatrices = new Matrix4x4[kMaxCascades + 1];
         private RenderTargetIdentifier m_CurrCameraColorRT;
-        private RenderTargetIdentifier m_ShadowMapRT;
+        private RenderTexture m_ShadowMapRT;
         private RenderTargetIdentifier m_ScreenSpaceShadowMapRT;
         private RenderTargetIdentifier m_ColorRT;
         private RenderTargetIdentifier m_CopyColorRT;
             CameraRenderTargetID.depth = Shader.PropertyToID("_CameraDepthTexture");
             CameraRenderTargetID.depthCopy = Shader.PropertyToID("_CameraCopyDepthTexture");
 
-            m_ShadowMapRT = new RenderTargetIdentifier(m_ShadowMapRTID);
             m_ScreenSpaceShadowMapRT = new RenderTargetIdentifier(m_ScreenSpaceShadowMapRTID);
 
             m_ColorRT = new RenderTargetIdentifier(CameraRenderTargetID.color);
                 if (sceneViewCamera)
                     CopyTexture(cmd, CameraRenderTargetID.depth, BuiltinRenderTextureType.CameraTarget, m_CopyDepthMaterial, true);
 #endif
-                cmd.ReleaseTemporaryRT(m_ShadowMapRTID);
                 cmd.ReleaseTemporaryRT(m_ScreenSpaceShadowMapRTID);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depthCopy);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depth);
                 CommandBufferPool.Release(cmd);
 
                 context.Submit();
+                if (m_ShadowMapRT)
+                {
+                    RenderTexture.ReleaseTemporary(m_ShadowMapRT);
+                    m_ShadowMapRT = null;
+                }
+            m_ShadowMapRT = null;
             if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
             {
                 VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
             float invShadowResolution = 1.0f / m_Asset.ShadowAtlasResolution;
             float invHalfShadowResolution = 0.5f * invShadowResolution;
             cmd.Clear();
+            cmd.SetGlobalTexture(m_ShadowMapRTID, m_ShadowMapRT);
             cmd.SetGlobalMatrixArray(ShadowConstantBuffer._WorldToShadow, m_ShadowMatrices);
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowData, new Vector4(light.shadowStrength, 0.0f, 0.0f, 0.0f));
             cmd.SetGlobalVectorArray(ShadowConstantBuffer._DirShadowSplitSpheres, m_DirectionalShadowSplitDistances);
             bool success = false;
 
             var cmd = CommandBufferPool.Get("Prepare Shadowmap");
-            cmd.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, kShadowBufferBits, FilterMode.Bilinear, m_ShadowSettings.shadowmapTextureFormat);
+            RenderTextureDescriptor shadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.shadowAtlasWidth,
+                m_ShadowSettings.shadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, kShadowBufferBits);
+            shadowmapDescriptor.shadowSamplingMode = ShadowSamplingMode.CompareDepths;
+            m_ShadowMapRT = RenderTexture.GetTemporary(shadowmapDescriptor);
+            m_ShadowMapRT.filterMode = FilterMode.Bilinear;
+            m_ShadowMapRT.wrapMode = TextureWrapMode.Clamp;
+
             // LightweightPipeline.SetRenderTarget is meant to be used with camera targets, not shadowmaps
             CoreUtils.SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.Depth, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor));
 
         {
             cmd.SetViewport(new Rect(m_ShadowSlices[cascadeIndex].atlasX, m_ShadowSlices[cascadeIndex].atlasY,
                     m_ShadowSlices[cascadeIndex].shadowResolution, m_ShadowSlices[cascadeIndex].shadowResolution));
+            cmd.EnableScissorRect(new Rect(m_ShadowSlices[cascadeIndex].atlasX + 4, m_ShadowSlices[cascadeIndex].atlasY + 4,
+                m_ShadowSlices[cascadeIndex].shadowResolution - 8, m_ShadowSlices[cascadeIndex].shadowResolution - 8));
+
+            cmd.Clear();
+            cmd.DisableScissorRect();
+            context.ExecuteCommandBuffer(cmd);
             cmd.Clear();
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl

 #define LIGHTWEIGHT_PASS_DEPTH_ONLY_INCLUDED
 
 #include "LWRP/ShaderLibrary/Core.hlsl"
-#include "LWRP/ShaderLibrary/InputSurface.hlsl"
 
 struct VertexInput
 {

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

-#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
-#define LIGHTWEIGHT_PASS_LIT_INCLUDED
-
-#include "LWRP/ShaderLibrary/InputSurface.hlsl"
-#include "LWRP/ShaderLibrary/Lighting.hlsl"
-
-struct LightweightVertexInput
-{
-    float4 vertex : POSITION;
-    float3 normal : NORMAL;
-    float4 tangent : TANGENT;
-    float2 texcoord : TEXCOORD0;
-    float2 lightmapUV : TEXCOORD1;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-struct LightweightVertexOutput
-{
-    float2 uv                       : TEXCOORD0;
-    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
-    float4 posWSShininess           : TEXCOORD2;    // xyz: posWS, w: Shininess * 128
-
-#ifdef _NORMALMAP
-    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
-    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
-    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
-#else
-    half3  normal                   : TEXCOORD3;
-    half3 viewDir                   : TEXCOORD4;
-#endif
-
-    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
-
-#ifdef _SHADOWS_ENABLED
-    float4 shadowCoord              : TEXCOORD7;
-#endif
-
-    float4 clipPos                  : SV_POSITION;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-    UNITY_VERTEX_OUTPUT_STEREO
-};
-
-void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
-{
-    inputData.positionWS = IN.posWSShininess.xyz;
-
-#ifdef _NORMALMAP
-    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
-    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
-#else
-    half3 viewDir = IN.viewDir;
-    inputData.normalWS = FragmentNormalWS(IN.normal);
-#endif
-
-    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
-#ifdef _SHADOWS_ENABLED
-    inputData.shadowCoord = IN.shadowCoord;
-#else
-    inputData.shadowCoord = float4(0, 0, 0, 0);
-#endif
-    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
-    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
-    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                  Vertex and Fragment functions                            //
-///////////////////////////////////////////////////////////////////////////////
-
-// Used in Standard (Physically Based) shader
-LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
-{
-    LightweightVertexOutput o = (LightweightVertexOutput)0;
-
-    UNITY_SETUP_INSTANCE_ID(v);
-    UNITY_TRANSFER_INSTANCE_ID(v, o);
-    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-
-    o.uv = TransformMainTextureCoord(v.texcoord);
-
-    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
-    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
-
-    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
-
-#ifdef _NORMALMAP
-    o.normal.w = viewDir.x;
-    o.tangent.w = viewDir.y;
-    o.binormal.w = viewDir.z;
-#else
-    o.viewDir = viewDir;
-#endif
-
-    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
-    OUTPUT_NORMAL(v, o);
-
-    // We either sample GI from lightmap or SH.
-    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
-    // see DECLARE_LIGHTMAP_OR_SH macro.
-    // The following funcions initialize the correct variable with correct data
-    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
-    OUTPUT_SH(o.normal.xyz, o.vertexSH);
-
-    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
-    half fogFactor = ComputeFogFactor(o.clipPos.z);
-    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
-
-#ifdef _SHADOWS_ENABLED
-#if SHADOWS_SCREEN
-    o.shadowCoord = ComputeShadowCoord(o.clipPos);
-#else
-    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
-#endif
-#endif
-
-    return o;
-}
-
-// Used in Standard (Physically Based) shader
-half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
-{
-    UNITY_SETUP_INSTANCE_ID(IN);
-
-    SurfaceData surfaceData;
-    InitializeStandardLitSurfaceData(IN.uv, surfaceData);
-
-    InputData inputData;
-    InitializeInputData(IN, surfaceData.normalTS, inputData);
-
-    half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-
-    ApplyFog(color.rgb, inputData.fogCoord);
-    return color;
-}
-
-// Used in Standard (Simple Lighting) shader
-// TODO: we only need to specialise this because of _Shininess prop
-// Once we refactor SimpleLighting shader we will be able to share vertex
-// between PBS and Simple
-LightweightVertexOutput LitPassVertexSimple(LightweightVertexInput v)
-{
-    LightweightVertexOutput o = (LightweightVertexOutput)0;
-
-    UNITY_SETUP_INSTANCE_ID(v);
-    UNITY_TRANSFER_INSTANCE_ID(v, o);
-    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-
-    o.uv = TransformMainTextureCoord(v.texcoord);
-
-    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
-    o.posWSShininess.w = _Shininess * 128.0;
-    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
-
-    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
-
-#ifdef _NORMALMAP
-    o.normal.w = viewDir.x;
-    o.tangent.w = viewDir.y;
-    o.binormal.w = viewDir.z;
-#else
-    o.viewDir = viewDir;
-#endif
-
-    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
-    OUTPUT_NORMAL(v, o);
-
-    // We either sample GI from lightmap or SH.
-    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
-    // see DECLARE_LIGHTMAP_OR_SH macro.
-    // The following funcions initialize the correct variable with correct data
-    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
-    OUTPUT_SH(o.normal.xyz, o.vertexSH);
-
-    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
-    half fogFactor = ComputeFogFactor(o.clipPos.z);
-    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
-
-#ifdef _SHADOWS_ENABLED
-#if SHADOWS_SCREEN
-    o.shadowCoord = ComputeShadowCoord(o.clipPos);
-#else
-    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
-#endif
-#endif
-
-    return o;
-}
-
-// Used for StandardSimpleLighting shader
-half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
-{
-    UNITY_SETUP_INSTANCE_ID(IN);
-
-    float2 uv = IN.uv;
-    half4 diffuseAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
-    half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
-
-    half alpha = diffuseAlpha.a * _Color.a;
-    AlphaDiscard(alpha, _Cutoff);
-#ifdef _ALPHAPREMULTIPLY_ON
-    diffuse *= alpha;
-#endif
-
-#ifdef _NORMALMAP
-    half3 normalTS = Normal(uv);
-#else
-    half3 normalTS = half3(0, 0, 1);
-#endif
-
-    half3 emission = Emission(uv);
-    half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
-    half shininess = IN.posWSShininess.w;
-
-    InputData inputData;
-    InitializeInputData(IN, normalTS, inputData);
-
-    return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
-};
-
-#endif
+#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
+#define LIGHTWEIGHT_PASS_LIT_INCLUDED
+
+#include "LWRP/ShaderLibrary/Lighting.hlsl"
+
+struct LightweightVertexInput
+{
+    float4 vertex : POSITION;
+    float3 normal : NORMAL;
+    float4 tangent : TANGENT;
+    float2 texcoord : TEXCOORD0;
+    float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutput
+{
+    float2 uv                       : TEXCOORD0;
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
+#ifdef _ADDITIONAL_LIGHTS
+    float3 posWS                    : TEXCOORD2;
+#endif
+
+#ifdef _NORMALMAP
+    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
+    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD4;
+#endif
+
+    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
+
+#ifdef _SHADOWS_ENABLED
+    float4 shadowCoord              : TEXCOORD7;
+#endif
+
+    float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
+{
+    inputData = (InputData)0;
+
+#ifdef _ADDITIONAL_LIGHTS
+    inputData.positionWS = IN.posWS;
+#endif
+
+#ifdef _NORMALMAP
+    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
+#else
+    half3 viewDir = IN.viewDir;
+    inputData.normalWS = FragmentNormalWS(IN.normal);
+#endif
+
+    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
+#ifdef _SHADOWS_ENABLED
+    inputData.shadowCoord = IN.shadowCoord;
+#else
+    inputData.shadowCoord = float4(0, 0, 0, 0);
+#endif
+    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
+    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Used in Standard (Physically Based) shader
+LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
+{
+    LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+
+    float3 posWS = TransformObjectToWorld(v.vertex.xyz);
+    o.clipPos = TransformWorldToHClip(posWS);
+
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - posWS);
+
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
+#endif
+
+    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
+    OUTPUT_NORMAL(v, o);
+
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
+
+    half3 vertexLight = VertexLighting(posWS, o.normal.xyz);
+    half fogFactor = ComputeFogFactor(o.clipPos.z);
+    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+
+#ifdef _SHADOWS_ENABLED
+#if SHADOWS_SCREEN
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(posWS);
+#endif
+#endif
+
+#if _ADDITIONAL_LIGHTS
+    o.posWS = posWS;
+#endif
+
+    return o;
+}
+
+// Used in Standard (Physically Based) shader
+half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
+{
+    UNITY_SETUP_INSTANCE_ID(IN);
+
+    SurfaceData surfaceData;
+    InitializeStandardLitSurfaceData(IN.uv, surfaceData);
+
+    InputData inputData;
+    InitializeInputData(IN, surfaceData.normalTS, inputData);
+
+    half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
+
+    ApplyFog(color.rgb, inputData.fogCoord);
+    return color;
+}
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassMeta.hlsl

 #ifndef LIGHTWEIGHT_PASS_META_INCLUDED
 #define LIGHTWEIGHT_PASS_META_INCLUDED
 
-#include "LWRP/ShaderLibrary/InputSurface.hlsl"
 #include "LWRP/ShaderLibrary/Lighting.hlsl"
 
 CBUFFER_START(UnityMetaPass)
     o.pos = MetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST);
     o.uv = TransformMainTextureCoord(v.uv0);
     return o;
-}
-
-half4 LightweightFragmentMeta(MetaVertexOuput i) : SV_Target
-{
-    SurfaceData surfaceData;
-    InitializeStandardLitSurfaceData(i.uv, surfaceData);
-
-    BRDFData brdfData;
-    InitializeBRDFData(surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.alpha, brdfData);
-
-    MetaInput o;
-    o.Albedo = brdfData.diffuse + brdfData.specular * brdfData.roughness * 0.5;
-    o.SpecularColor = surfaceData.specular;
-    o.Emission = surfaceData.emission;
-
-    return MetaFragment(o);
-}
-
-half4 LightweightFragmentMetaSimple(MetaVertexOuput i) : SV_Target
-{
-    float2 uv = i.uv;
-    MetaInput o;
-    o.Albedo = _Color.rgb * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv).rgb;
-    o.SpecularColor = SpecularGloss(uv, 1.0).xyz;
-    o.Emission = Emission(uv);
-
-    return MetaFragment(o);
 }
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassShadow.hlsl

 #define LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 
 #include "LWRP/ShaderLibrary/Core.hlsl"
-#include "LWRP/ShaderLibrary/InputSurface.hlsl"
 
 // x: global clip space bias, y: normal world space bias
 float4 _ShadowBias;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Particles.hlsl

+#ifndef LIGHTWEIGHT_PARTICLES_INCLUDED
+#define LIGHTWEIGHT_PARTICLES_INCLUDED
+
-#include "InputSurface.hlsl"
-TEXTURE2D(_CameraDepthTexture);
-SAMPLER(sampler_CameraDepthTexture);
+CBUFFER_START(UnityPerMaterial)
+float4 _MainTex_ST;
+half4 _Color;
+
+#if defined (_COLORADDSUBDIFF_ON)
+    half4 _ColorAddSubDiff;
+#endif
+
+half _Cutoff;
+half _Shininess;
+half _Metallic;
+half _Glossiness;
+CBUFFER_END
+
+#include "InputSurfaceCommon.hlsl"
+
+TEXTURE2D(_CameraDepthTexture);
+SAMPLER(sampler_CameraDepthTexture);
 
 #define SOFT_PARTICLE_NEAR_FADE _SoftParticleFadeParams.x
 #define SOFT_PARTICLE_INV_FADE_DISTANCE _SoftParticleFadeParams.y
-
-#if defined (_COLORADDSUBDIFF_ON)
-half4 _ColorAddSubDiff;
-#endif
 
 // Color function
 #if defined(UNITY_PARTICLE_INSTANCING_ENABLED)
     return specularGloss;
 }
 
-half AlphaBlendAndTest(half alpha)
+half AlphaBlendAndTest(half alpha, half cutoff)
 {
 #if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON) || defined(_ALPHAOVERLAY_ON)
     half result = alpha;
-    AlphaDiscard(result, _Cutoff, 0.0001h);
+    AlphaDiscard(result, cutoff, 0.0001h);
 
     return result;
 }
 #endif
 }
 
-void InitializeSurfaceData(VertexOutputLit IN, out SurfaceData surfaceData)
-{
-    half4 albedo = Albedo(IN);
-
-#if defined(_METALLICGLOSSMAP)
-    half2 metallicGloss = readTexture(TEXTURE2D_PARAM(_MetallicGlossMap, sampler_MetallicGlossMap), IN).ra * half2(1.0, _Glossiness);
-#else
-    half2 metallicGloss = half2(_Metallic, _Glossiness);
-#endif
-
-    half3 normalTS = NormalTS(IN);
-    half3 emission = Emission(IN);
-
-    surfaceData.albedo = albedo.rbg;
-    surfaceData.specular = half3(0.0h, 0.0h, 0.0h);
-    surfaceData.normalTS = normalTS;
-    surfaceData.emission = emission;
-    surfaceData.metallic = metallicGloss.r;
-    surfaceData.smoothness = metallicGloss.g;
-    surfaceData.occlusion = 1.0;
-
-    surfaceData.alpha = AlphaBlendAndTest(albedo.a);
-    surfaceData.albedo = AlphaModulate(surfaceData.albedo, surfaceData.alpha);
-}
-
 void InitializeInputData(VertexOutputLit IN, half3 normalTS, out InputData input)
 {
     input.positionWS = IN.posWS.xyz;
 
     input.viewDirectionWS = FragmentViewDirWS(IN.viewDirShininess.xyz);
     input.shadowCoord = float4(0, 0, 0, 0);
-    input.fogCoord = IN.posWS.w;
+    input.fogCoord = (half)IN.posWS.w;
+
+#endif // LIGHTWEIGHT_PARTICLES_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 #define BEYOND_SHADOW_FAR(shadowCoord) shadowCoord.z >= UNITY_RAW_FAR_CLIP_VALUE
 #endif
 
-#define OUTSIDE_SHADOW_BOUNDS(shadowCoord) shadowCoord.x <= 0 || shadowCoord.x >= 1 || shadowCoord.y <= 0 || shadowCoord.y >= 1 || BEYOND_SHADOW_FAR(shadowCoord)
-
 half GetShadowStrength()
 {
     return _ShadowData.x;
 #endif
 
     // Shadow coords that fall out of the light frustum volume must always return attenuation 1.0
-    return (OUTSIDE_SHADOW_BOUNDS(shadowCoord)) ? 1.0 : attenuation;
+    return BEYOND_SHADOW_FAR(shadowCoord) ? 1.0 : attenuation;
 }
 
 inline half ComputeCascadeIndex(float3 positionWS)

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragment
 
+            #include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
             #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
             ENDHLSL
         }
             #pragma vertex ShadowPassVertex
             #pragma fragment ShadowPassFragment
 
+            #include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
         }
             // GPU Instancing
             #pragma multi_compile_instancing
 
+            #include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
             #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
 
             #pragma shader_feature _SPECGLOSSMAP
 
+            #include "LWRP/ShaderLibrary/InputSurfacePBR.hlsl"
+
+            half4 LightweightFragmentMeta(MetaVertexOuput i) : SV_Target
+            {
+                SurfaceData surfaceData;
+                InitializeStandardLitSurfaceData(i.uv, surfaceData);
+
+                BRDFData brdfData;
+                InitializeBRDFData(surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.alpha, brdfData);
+
+                MetaInput o;
+                o.Albedo = brdfData.diffuse + brdfData.specular * brdfData.roughness * 0.5;
+                o.SpecularColor = surfaceData.specular;
+                o.Emission = surfaceData.emission;
+
+                return MetaFragment(o);
+            }
+
             ENDHLSL
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

 
             #define NO_SHADOWS 1
 
-            #include "LWRP/ShaderLibrary/Particles.hlsl"
+            #include "LWRP/ShaderLibrary/ParticlesPBR.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
 
             VertexOutputLit ParticlesLitVertex(appdata_particles v)

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

 
             #define BUMP_SCALE_NOT_SUPPORTED 1
             #define NO_SHADOWS 1
-
+            
             #include "LWRP/ShaderLibrary/Particles.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
 
             half4 ParticlesLitFragment(VertexOutputLit IN) : SV_Target
             {
                 half4 albedo = Albedo(IN);
-                half alpha = AlphaBlendAndTest(albedo.a);
+                half alpha = AlphaBlendAndTest(albedo.a, _Cutoff);
                 half3 diffuse = AlphaModulate(albedo.rgb, alpha);
                 half3 normalTS = NormalTS(IN);
                 half3 emission = Emission(IN);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesUnlit.shader

                 #pragma fragment fragParticleUnlit
 
                 #include "LWRP/ShaderLibrary/Particles.hlsl"
-                #include "LWRP/ShaderLibrary/Core.hlsl"
 
                 VertexOutputLit vertParticleUnlit(appdata_particles v)
                 {
                 half4 fragParticleUnlit(VertexOutputLit IN) : SV_Target
                 {
                     half4 albedo = Albedo(IN);
-                    half alpha = AlphaBlendAndTest(albedo.a);
+                    half alpha = AlphaBlendAndTest(albedo.a, _Cutoff);
                     half3 emission = Emission(IN);
                     half3 diffuse = AlphaModulate(albedo.rgb, alpha);
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #pragma vertex LitPassVertexSimple
             #pragma fragment LitPassFragmentSimple
             #define BUMP_SCALE_NOT_SUPPORTED 1
-            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+
+            #include "LWRP/ShaderLibrary/InputSurfaceSimple.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassLitSimple.hlsl"
             ENDHLSL
         }
 
             #pragma vertex ShadowPassVertex
             #pragma fragment ShadowPassFragment
 
+            #include "LWRP/ShaderLibrary/InputSurfaceSimple.hlsl"
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
         }
             // GPU Instancing
             #pragma multi_compile_instancing
 
+            #include "LWRP/ShaderLibrary/InputSurfaceSimple.hlsl"
             #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
             #pragma shader_feature _EMISSION
             #pragma shader_feature _SPECGLOSSMAP
 
+            #include "LWRP/ShaderLibrary/InputSurfaceSimple.hlsl"
+
+            half4 LightweightFragmentMetaSimple(MetaVertexOuput i) : SV_Target
+            {
+                float2 uv = i.uv;
+                MetaInput o;
+                o.Albedo = _Color.rgb * SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv).rgb;
+                o.SpecularColor = SpecularGloss(uv, 1.0).xyz;
+                o.Emission = Emission(uv);
+
+                return MetaFragment(o);
+            }
+
             ENDHLSL
         }
     }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

 
             // Lighting include is needed because of GI
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
-            #include "LWRP/ShaderLibrary/InputSurface.hlsl"
+            #include "LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl"
 
             struct VertexInput
             {

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceCommon.hlsl

+#ifndef LIGHTWEIGHT_INPUT_SURFACE_COMMON_INCLUDED
+#define LIGHTWEIGHT_INPUT_SURFACE_COMMON_INCLUDED
+
+#include "Core.hlsl"
+#include "CoreRP/ShaderLibrary/Packing.hlsl"
+#include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
+
+TEXTURE2D(_MainTex);            SAMPLER(sampler_MainTex);
+TEXTURE2D(_BumpMap);            SAMPLER(sampler_BumpMap);
+TEXTURE2D(_EmissionMap);        SAMPLER(sampler_EmissionMap);
+
+// Must match Lightweigth ShaderGraph master node
+struct SurfaceData
+{
+    half3 albedo;
+    half3 specular;
+    half  metallic;
+    half  smoothness;
+    half3 normalTS;
+    half3 emission;
+    half  occlusion;
+    half  alpha;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Material Property Helpers                            //
+///////////////////////////////////////////////////////////////////////////////
+float2 TransformMainTextureCoord(float2 uv)
+{
+    return TRANSFORM_TEX(uv, _MainTex);
+}
+
+half Alpha(half albedoAlpha)
+{
+#if !defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A) && !defined(_GLOSSINESS_FROM_BASE_ALPHA)
+    half alpha = albedoAlpha * _Color.a;
+#else
+    half alpha = _Color.a;
+#endif
+
+#if defined(_ALPHATEST_ON)
+    clip(alpha - _Cutoff);
+#endif
+
+    return alpha;
+}
+
+half4 MainTexture(float2 uv)
+{
+    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
+}
+
+half3 Normal(float2 uv)
+{
+#if _NORMALMAP
+    #if BUMP_SCALE_NOT_SUPPORTED
+        return UnpackNormal(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv));
+    #else
+        return UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv), _BumpScale);
+    #endif
+#else
+    return half3(0.0h, 0.0h, 1.0h);
+#endif
+}
+
+half3 Emission(float2 uv)
+{
+#ifndef _EMISSION
+    return 0;
+#else
+    return SAMPLE_TEXTURE2D(_EmissionMap, sampler_EmissionMap, uv).rgb * _EmissionColor.rgb;
+#endif
+}
+
+#endif // LIGHTWEIGHT_INPUT_SURFACE_COMMON_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfacePBR.hlsl

+#ifndef LIGHTWEIGHT_INPUT_SURFACE_PBR_INCLUDED
+#define LIGHTWEIGHT_INPUT_SURFACE_PBR_INCLUDED
+
+#include "Core.hlsl"
+#include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
+
+CBUFFER_START(UnityPerMaterial)
+float4 _MainTex_ST;
+half4 _Color;
+half4 _SpecColor;
+half4 _EmissionColor;
+half _Cutoff;
+half _Glossiness;
+half _GlossMapScale;
+half _Metallic;
+half _BumpScale;
+half _OcclusionStrength;
+CBUFFER_END
+
+TEXTURE2D(_OcclusionMap);       SAMPLER(sampler_OcclusionMap);
+TEXTURE2D(_MetallicGlossMap);   SAMPLER(sampler_MetallicGlossMap);
+TEXTURE2D(_SpecGlossMap);       SAMPLER(sampler_SpecGlossMap);
+
+#ifdef _SPECULAR_SETUP
+    #define SAMPLE_METALLICSPECULAR(uv) SAMPLE_TEXTURE2D(_SpecGlossMap, sampler_SpecGlossMap, uv)
+#else
+    #define SAMPLE_METALLICSPECULAR(uv) SAMPLE_TEXTURE2D(_MetallicGlossMap, sampler_MetallicGlossMap, uv)
+#endif
+
+half4 MetallicSpecGloss(float2 uv, half albedoAlpha)
+{
+    half4 specGloss;
+
+#ifdef _METALLICSPECGLOSSMAP
+    specGloss = SAMPLE_METALLICSPECULAR(uv);
+    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+        specGloss.a = albedoAlpha * _GlossMapScale;
+    #else
+        specGloss.a *= _GlossMapScale;
+    #endif
+#else // _METALLICSPECGLOSSMAP
+    #if _SPECULAR_SETUP
+        specGloss.rgb = _SpecColor.rgb;
+    #else
+        specGloss.rgb = _Metallic.rrr;
+    #endif
+
+    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+        specGloss.a = albedoAlpha * _GlossMapScale;
+    #else
+        specGloss.a = _Glossiness;
+    #endif
+#endif
+
+    return specGloss;
+}
+
+half Occlusion(float2 uv)
+{
+#ifdef _OCCLUSIONMAP
+#if (SHADER_TARGET < 30)
+    // SM20: instruction count limitation
+    // SM20: simpler occlusion
+    return SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;
+#else
+    half occ = SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;
+    return LerpWhiteTo(occ, _OcclusionStrength);
+#endif
+#else
+    return 1.0;
+#endif
+}
+
+#include "InputSurfaceCommon.hlsl"
+
+inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
+{
+    half4 albedoAlpha = MainTexture(uv);
+
+    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha.a);
+    outSurfaceData.albedo = albedoAlpha.rgb * _Color.rgb;
+
+#if _SPECULAR_SETUP
+    outSurfaceData.metallic = 1.0h;
+    outSurfaceData.specular = specGloss.rgb;
+#else
+    outSurfaceData.metallic = specGloss.r;
+    outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
+#endif
+
+    outSurfaceData.smoothness = specGloss.a;
+    outSurfaceData.normalTS = Normal(uv);
+    outSurfaceData.occlusion = Occlusion(uv);
+    outSurfaceData.emission = Emission(uv);
+    outSurfaceData.alpha = Alpha(albedoAlpha.a);
+}
+
+#endif // LIGHTWEIGHT_INPUT_SURFACE_PBR_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfacePBR.hlsl.meta

+fileFormatVersion: 2
+guid: c46f85bf266d7496d9b3659acfbdc711
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceSimple.hlsl

+#ifndef LIGHTWEIGHT_INPUT_SURFACE_SIMPLE_INCLUDED
+#define LIGHTWEIGHT_INPUT_SURFACE_SIMPLE_INCLUDED
+
+#include "Core.hlsl"
+
+CBUFFER_START(UnityPerMaterial)
+float4 _MainTex_ST;
+half4 _Color;
+half4 _SpecColor;
+half4 _EmissionColor;
+half _Cutoff;
+half _Shininess;
+CBUFFER_END
+
+TEXTURE2D(_SpecGlossMap);       SAMPLER(sampler_SpecGlossMap);
+
+half4 SpecularGloss(half2 uv, half alpha)
+{
+    half4 specularGloss = half4(0, 0, 0, 1);
+#ifdef _SPECGLOSSMAP
+    specularGloss = SAMPLE_TEXTURE2D(_SpecGlossMap, sampler_SpecGlossMap, uv);
+#elif defined(_SPECULAR_COLOR)
+    specularGloss = _SpecColor;
+#endif
+
+#ifdef _GLOSSINESS_FROM_BASE_ALPHA
+    specularGloss.a = alpha;
+#endif
+    return specularGloss;
+}
+
+#include "InputSurfaceCommon.hlsl"
+
+#endif // LIGHTWEIGHT_INPUT_SURFACE_SIMPLE_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceSimple.hlsl.meta

+fileFormatVersion: 2
+guid: ad863d097888f42c6bcf419efb2946c5
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl

+#ifndef LIGHTWEIGHT_INPUT_SURFACE_UNLIT_INCLUDED
+#define LIGHTWEIGHT_INPUT_SURFACE_UNLIT_INCLUDED
+
+#include "Core.hlsl"
+
+CBUFFER_START(UnityPerMaterial)
+float4 _MainTex_ST;
+half4 _Color;
+half _Cutoff;
+half _Glossiness;
+half _Metallic;
+CBUFFER_END
+
+#include "InputSurfaceCommon.hlsl"
+
+#endif // LIGHTWEIGHT_INPUT_SURFACE_UNLIT_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl.meta

+fileFormatVersion: 2
+guid: e7ba75cc852b14b7f934978b5697bf1b
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLitSimple.hlsl

+#ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
+#define LIGHTWEIGHT_PASS_LIT_INCLUDED
+
+#include "LWRP/ShaderLibrary/Lighting.hlsl"
+
+struct LightweightVertexInput
+{
+    float4 vertex : POSITION;
+    float3 normal : NORMAL;
+    float4 tangent : TANGENT;
+    float2 texcoord : TEXCOORD0;
+    float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutput
+{
+    float2 uv                       : TEXCOORD0;
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
+
+    float4 posWSShininess           : TEXCOORD2;    // xyz: posWS, w: Shininess * 128
+
+#ifdef _NORMALMAP
+    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
+    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.z
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD4;
+#endif
+
+    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
+
+#ifdef _SHADOWS_ENABLED
+    float4 shadowCoord              : TEXCOORD7;
+#endif
+
+    float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
+{
+    inputData.positionWS = IN.posWSShininess.xyz;
+
+#ifdef _NORMALMAP
+    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
+#else
+    half3 viewDir = IN.viewDir;
+    inputData.normalWS = FragmentNormalWS(IN.normal);
+#endif
+
+    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
+#ifdef _SHADOWS_ENABLED
+    inputData.shadowCoord = IN.shadowCoord;
+#else
+    inputData.shadowCoord = float4(0, 0, 0, 0);
+#endif
+    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
+    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Used in Standard (Simple Lighting) shader
+LightweightVertexOutput LitPassVertexSimple(LightweightVertexInput v)
+{
+    LightweightVertexOutput o = (LightweightVertexOutput)0;
+
+    UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+
+    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
+    o.posWSShininess.w = _Shininess * 128.0;
+    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
+
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
+
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
+#endif
+
+    // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
+    OUTPUT_NORMAL(v, o);
+
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
+
+    half3 vertexLight = VertexLighting(o.posWSShininess.xyz, o.normal.xyz);
+    half fogFactor = ComputeFogFactor(o.clipPos.z);
+    o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+
+#ifdef _SHADOWS_ENABLED
+#if SHADOWS_SCREEN
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
+#endif
+#endif
+
+    return o;
+}
+
+// Used for StandardSimpleLighting shader
+half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
+{
+    UNITY_SETUP_INSTANCE_ID(IN);
+
+    float2 uv = IN.uv;
+    half4 diffuseAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
+    half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
+
+    half alpha = diffuseAlpha.a * _Color.a;
+    AlphaDiscard(alpha, _Cutoff);
+#ifdef _ALPHAPREMULTIPLY_ON
+    diffuse *= alpha;
+#endif
+
+#ifdef _NORMALMAP
+    half3 normalTS = Normal(uv);
+#else
+    half3 normalTS = half3(0, 0, 1);
+#endif
+
+    half3 emission = Emission(uv);
+    half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
+    half shininess = IN.posWSShininess.w;
+
+    InputData inputData;
+    InitializeInputData(IN, normalTS, inputData);
+
+    return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
+};
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLitSimple.hlsl.meta

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

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/ParticlesPBR.hlsl

+#ifndef LIGHTWEIGHT_PARTICLES_PBR_INCLUDED
+#define LIGHTWEIGHT_PARTICLES_PBR_INCLUDED
+
+#include "Particles.hlsl"
+
+TEXTURE2D(_MetallicGlossMap);   SAMPLER(sampler_MetallicGlossMap);
+
+void InitializeSurfaceData(VertexOutputLit IN, out SurfaceData surfaceData)
+{
+    half4 albedo = Albedo(IN);
+
+#if defined(_METALLICGLOSSMAP)
+    half2 metallicGloss = readTexture(TEXTURE2D_PARAM(_MetallicGlossMap, sampler_MetallicGlossMap), IN).ra * half2(1.0, _Glossiness);
+#else
+    half2 metallicGloss = half2(_Metallic, _Glossiness);
+#endif
+
+    half3 normalTS = NormalTS(IN);
+    half3 emission = Emission(IN);
+
+    surfaceData.albedo = albedo.rgb;
+    surfaceData.specular = half3(0.0h, 0.0h, 0.0h);
+    surfaceData.normalTS = normalTS;
+    surfaceData.emission = emission;
+    surfaceData.metallic = metallicGloss.r;
+    surfaceData.smoothness = metallicGloss.g;
+    surfaceData.occlusion = 1.0;
+
+    surfaceData.alpha = AlphaBlendAndTest(albedo.a, _Cutoff);
+    surfaceData.albedo = AlphaModulate(surfaceData.albedo, surfaceData.alpha);
+}
+
+#endif // LIGHTWEIGHT_PARTICLES_PBR_INCLUDED

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/ParticlesPBR.hlsl.meta

+fileFormatVersion: 2
+guid: a3129e299d0744bb7bd42c2cea7cea2b
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

-#ifndef LIGHTWEIGHT_SURFACE_INPUT_INCLUDED
-#define LIGHTWEIGHT_SURFACE_INPUT_INCLUDED
-
-#include "Core.hlsl"
-#include "CoreRP/ShaderLibrary/Packing.hlsl"
-#include "CoreRP/ShaderLibrary/CommonMaterial.hlsl"
-
-#ifdef _SPECULAR_SETUP
-#define SAMPLE_METALLICSPECULAR(uv) SAMPLE_TEXTURE2D(_SpecGlossMap, sampler_SpecGlossMap, uv)
-#else
-#define SAMPLE_METALLICSPECULAR(uv) SAMPLE_TEXTURE2D(_MetallicGlossMap, sampler_MetallicGlossMap, uv)
-#endif
-
-CBUFFER_START(UnityPerMaterial)
-float4 _MainTex_ST;
-half4 _Color;
-half4 _SpecColor;
-half4 _EmissionColor;
-half _Cutoff;
-half _Glossiness;
-half _GlossMapScale;
-half _Metallic;
-half _BumpScale;
-half _OcclusionStrength;
-half _Shininess;
-CBUFFER_END
-
-TEXTURE2D(_MainTex);            SAMPLER(sampler_MainTex);
-TEXTURE2D(_MetallicGlossMap);   SAMPLER(sampler_MetallicGlossMap);
-TEXTURE2D(_SpecGlossMap);       SAMPLER(sampler_SpecGlossMap);
-TEXTURE2D(_BumpMap);            SAMPLER(sampler_BumpMap);
-TEXTURE2D(_OcclusionMap);       SAMPLER(sampler_OcclusionMap);
-TEXTURE2D(_EmissionMap);        SAMPLER(sampler_EmissionMap);
-
-// Must match Lightweigth ShaderGraph master node
-struct SurfaceData
-{
-    half3 albedo;
-    half3 specular;
-    half  metallic;
-    half  smoothness;
-    half3 normalTS;
-    half3 emission;
-    half  occlusion;
-    half  alpha;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//                      Material Property Helpers                            //
-///////////////////////////////////////////////////////////////////////////////
-float2 TransformMainTextureCoord(float2 uv)
-{
-    return TRANSFORM_TEX(uv, _MainTex);
-}
-
-half Alpha(half albedoAlpha)
-{
-#if !defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A) && !defined(_GLOSSINESS_FROM_BASE_ALPHA)
-    half alpha = albedoAlpha * _Color.a;
-#else
-    half alpha = _Color.a;
-#endif
-
-#if defined(_ALPHATEST_ON)
-    clip(alpha - _Cutoff);
-#endif
-
-    return alpha;
-}
-
-half4 MainTexture(float2 uv)
-{
-    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
-}
-
-half3 Normal(float2 uv)
-{
-#if _NORMALMAP
-    #if BUMP_SCALE_NOT_SUPPORTED
-        return UnpackNormal(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv));
-    #else
-        return UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv), _BumpScale);
-    #endif
-#else
-    return half3(0.0h, 0.0h, 1.0h);
-#endif
-}
-
-half4 SpecularGloss(half2 uv, half alpha)
-{
-    half4 specularGloss = half4(0, 0, 0, 1);
-#ifdef _SPECGLOSSMAP
-    specularGloss = SAMPLE_TEXTURE2D(_SpecGlossMap, sampler_SpecGlossMap, uv);
-#elif defined(_SPECULAR_COLOR)
-    specularGloss = _SpecColor;
-#endif
-
-#ifdef _GLOSSINESS_FROM_BASE_ALPHA
-    specularGloss.a = alpha;
-#endif
-    return specularGloss;
-}
-
-half4 MetallicSpecGloss(float2 uv, half albedoAlpha)
-{
-    half4 specGloss;
-
-#ifdef _METALLICSPECGLOSSMAP
-    specGloss = SAMPLE_METALLICSPECULAR(uv);
-    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-        specGloss.a = albedoAlpha * _GlossMapScale;
-    #else
-        specGloss.a *= _GlossMapScale;
-    #endif
-#else // _METALLICSPECGLOSSMAP
-    #if _SPECULAR_SETUP
-        specGloss.rgb = _SpecColor.rgb;
-    #else
-        specGloss.rgb = _Metallic.rrr;
-    #endif
-
-    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-        specGloss.a = albedoAlpha * _GlossMapScale;
-    #else
-        specGloss.a = _Glossiness;
-    #endif
-#endif
-
-    return specGloss;
-}
-
-half Occlusion(float2 uv)
-{
-#ifdef _OCCLUSIONMAP
-#if (SHADER_TARGET < 30)
-    // SM20: instruction count limitation
-    // SM20: simpler occlusion
-    return SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;
-#else
-    half occ = SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;
-    return LerpWhiteTo(occ, _OcclusionStrength);
-#endif
-#else
-    return 1.0;
-#endif
-}
-
-half3 Emission(float2 uv)
-{
-#ifndef _EMISSION
-    return 0;
-#else
-    return SAMPLE_TEXTURE2D(_EmissionMap, sampler_EmissionMap, uv).rgb * _EmissionColor.rgb;
-#endif
-}
-
-inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
-{
-    half4 albedoAlpha = MainTexture(uv);
-
-    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha.a);
-    outSurfaceData.albedo = albedoAlpha.rgb * _Color.rgb;
-
-#if _SPECULAR_SETUP
-    outSurfaceData.metallic = 1.0h;
-    outSurfaceData.specular = specGloss.rgb;
-#else
-    outSurfaceData.metallic = specGloss.r;
-    outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
-#endif
-
-    outSurfaceData.smoothness = specGloss.a;
-    outSurfaceData.normalTS = Normal(uv);
-    outSurfaceData.occlusion = Occlusion(uv);
-    outSurfaceData.emission = Emission(uv);
-    outSurfaceData.alpha = Alpha(albedoAlpha.a);
-}
-
-#endif