Merge branch 'LightweightPipeline'

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.XR;
         private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
         private ShadowSliceData[] m_ShadowSlices = new ShadowSliceData[kMaxCascades];
 
+        // Pipeline pass names
-        private static readonly ShaderPassName m_UnlitPassName = new ShaderPassName("SRPDefaultUnlit");
+        private static readonly ShaderPassName m_UnlitPassName = new ShaderPassName("SRPDefaultUnlit"); // Renders all shaders without a lightmode tag
+
+        // Legacy pass names
+        public static readonly ShaderPassName s_AlwaysName = new ShaderPassName("Always");
+        public static readonly ShaderPassName s_ForwardBaseName = new ShaderPassName("ForwardBase");
+        public static readonly ShaderPassName s_PrepassBaseName = new ShaderPassName("PrepassBase");
+        public static readonly ShaderPassName s_VertexName = new ShaderPassName("Vertex");
+        public static readonly ShaderPassName s_VertexLMRGBMName = new ShaderPassName("VertexLMRGBM");
+        public static readonly ShaderPassName s_VertexLMName = new ShaderPassName("VertexLM");
+        public static readonly ShaderPassName[] s_LegacyPassNames =
+        {
+            s_AlwaysName, s_ForwardBaseName, s_PrepassBaseName, s_VertexName, s_VertexLMRGBMName, s_VertexLMName
+        };
 
         private RenderTextureFormat m_ColorFormat;
         private PostProcessRenderContext m_PostProcessRenderContext;
         private Mesh m_BlitQuad;
         private Material m_BlitMaterial;
         private Material m_CopyDepthMaterial;
+        private Material m_ErrorMaterial;
         private int m_BlitTexID = Shader.PropertyToID("_BlitTex");
 
         private CopyTextureSupport m_CopyTextureSupport;
             m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
             m_BlitMaterial = CoreUtils.CreateEngineMaterial(m_Asset.BlitShader);
             m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(m_Asset.CopyDepthShader);
+            m_ErrorMaterial = CoreUtils.CreateEngineMaterial("Hidden/InternalErrorShader");
         }
 
         public override void Dispose()
+
+            CoreUtils.Destroy(m_ErrorMaterial);
+            CoreUtils.Destroy(m_CopyDepthMaterial);
+            CoreUtils.Destroy(m_BlitMaterial);
         }
 
         CullResults m_CullResults;
 
             context.DrawRenderers(m_CullResults.visibleRenderers, ref opaqueDrawSettings, opaqueFilterSettings);
 
+            // Render objects that did not match any shader pass with error shader
+            RenderObjectsWithError(ref context, opaqueFilterSettings, SortFlags.None);
+
             if (m_CurrCamera.clearFlags == CameraClearFlags.Skybox)
                 context.DrawSkybox(m_CurrCamera);
         }
             CommandBufferPool.Release(cmd);
         }
 
+        private void RenderTransparents(ref ScriptableRenderContext context, RendererConfiguration config)
+        {
+            var transparentSettings = new DrawRendererSettings(m_CurrCamera, m_LitPassName);
+            transparentSettings.SetShaderPassName(1, m_UnlitPassName);
+            transparentSettings.sorting.flags = SortFlags.CommonTransparent;
+            transparentSettings.rendererConfiguration = config;
+
+            var transparentFilterSettings = new FilterRenderersSettings(true)
+            {
+                renderQueueRange = RenderQueueRange.transparent
+            };
+
+            context.DrawRenderers(m_CullResults.visibleRenderers, ref transparentSettings, transparentFilterSettings);
+
+            // Render objects that did not match any shader pass with error shader
+            RenderObjectsWithError(ref context, transparentFilterSettings, SortFlags.None);
+        }
+
         private void AfterTransparent(ref ScriptableRenderContext context, FrameRenderingConfiguration config)
         {
             if (!LightweightUtils.HasFlag(config, FrameRenderingConfiguration.PostProcess))
             CommandBufferPool.Release(cmd);
         }
 
-        private void RenderTransparents(ref ScriptableRenderContext context, RendererConfiguration config)
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
+        private void RenderObjectsWithError(ref ScriptableRenderContext context, FilterRenderersSettings filterSettings, SortFlags sortFlags)
-            var transparentSettings = new DrawRendererSettings(m_CurrCamera, m_LitPassName);
-            transparentSettings.SetShaderPassName(1, m_UnlitPassName);
-            transparentSettings.sorting.flags = SortFlags.CommonTransparent;
-            transparentSettings.rendererConfiguration = config;
-
-            var transparentFilterSettings = new FilterRenderersSettings(true)
+            if (m_ErrorMaterial != null)
-                renderQueueRange = RenderQueueRange.transparent
-            };
+                DrawRendererSettings errorSettings = new DrawRendererSettings(m_CurrCamera, s_LegacyPassNames[0]);
+                for (int i = 1; i < s_LegacyPassNames.Length; ++i)
+                    errorSettings.SetShaderPassName(i, s_LegacyPassNames[i]);
-            context.DrawRenderers(m_CullResults.visibleRenderers, ref transparentSettings, transparentFilterSettings);
+                errorSettings.sorting.flags = sortFlags;
+                errorSettings.rendererConfiguration = RendererConfiguration.None;
+                errorSettings.SetOverrideMaterial(m_ErrorMaterial, 0);
+                context.DrawRenderers(m_CullResults.visibleRenderers, ref errorSettings, filterSettings);
+            }
         }
 
         private void BuildShadowSettings()

ScriptableRenderPipeline/LightweightPipeline/Resources/LightweightPipelineAsset.cs

     {
         public static readonly string m_SimpleLightShaderPath = "LightweightPipeline/Standard (Simple Lighting)";
         public static readonly string m_StandardShaderPath = "LightweightPipeline/Standard (Physically Based)";
+        public static readonly string[] m_SearchPaths = {"Assets", "Packages/com.unity.render-pipelines"};
 
         // Default values set when a new LightweightPipeline asset is created
         [SerializeField] private int m_MaxPixelLights = 4;
         {
             var instance = CreateInstance<LightweightPipelineAsset>();
 
-            string[] guids = UnityEditor.AssetDatabase.FindAssets("LightweightPipelineResource t:scriptableobject");
+            string[] guids = UnityEditor.AssetDatabase.FindAssets("LightweightPipelineResource t:scriptableobject", m_SearchPaths);
             LightweightPipelineResource resourceAsset = null;
             foreach (string guid in guids)
             {
                     break;
+            }
+
+            // There's currently an issue that prevents FindAssets from find resources withing the package folder.
+            if (resourceAsset == null)
+            {
+                string path = "Packages/com.unity.render-pipelines.lightweight/Resources/LightweightPipelineResource.asset";
+                resourceAsset = UnityEditor.AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
             }
 
             if (resourceAsset != null)

ScriptableRenderPipeline/LightweightPipeline/Resources/LightweightPipelineResource.asset

   m_Script: {fileID: 11500000, guid: eb91b173ce266e040aa972ca9a561308, type: 3}
   m_Name: LightweightPipelineResource
   m_EditorClassIdentifier: 
-  DefaultMaterial: {fileID: 0}
-  DefaultParticleMaterial: {fileID: 0}
-  DefaultTerrainMaterial: {fileID: 0}
+  DefaultMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
+    type: 2}
+  DefaultTerrainMaterial: {fileID: 2100000, guid: 594ea882c5a793440b60ff72d896021e,
+    type: 2}

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc

 
 #define MAX_VISIBLE_LIGHTS 16
 
-// Must match Lightweigth ShaderGraph master node
-struct SurfaceData
-{
-    half3 albedo;
-    half3 specular;
-    half  metallic;
-    half  smoothness;
-    half3 normal;
-    half3 emission;
-    half  occlusion;
-    half  alpha;
-};
-
 struct LightInput
 {
     float4 pos;

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassLit.cginc

 #ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
 #define LIGHTWEIGHT_PASS_LIT_INCLUDED
 
+#include "LightweightSurfaceInput.cginc"
-#ifdef _SPECULAR_SETUP
-#define SAMPLE_METALLICSPECULAR(uv) tex2D(_SpecGlossMap, uv)
-#else
-#define SAMPLE_METALLICSPECULAR(uv) tex2D(_MetallicGlossMap, uv)
-#endif
-
-CBUFFER_START(MaterialProperties)
-half4 _MainTex_ST;
-half4 _Color;
-half _Cutoff;
-half _Glossiness;
-half _GlossMapScale;
-half _SmoothnessTextureChannel;
-half _Metallic;
-half4 _SpecColor;
-half _BumpScale;
-half _OcclusionStrength;
-half4 _EmissionColor;
-half _Shininess;
-CBUFFER_END
-
-sampler2D _MainTex;
-sampler2D _MetallicGlossMap;
-sampler2D _SpecGlossMap;
-sampler2D _BumpMap;
-sampler2D _OcclusionMap;
-sampler2D _EmissionMap;
-
 struct LightweightVertexInput
 {
     float4 vertex : POSITION;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-//                      Material Property Helpers                            //
-///////////////////////////////////////////////////////////////////////////////
-inline half Alpha(half albedoAlpha)
-{
-#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
-    half alpha = _Color.a;
-#else
-    half alpha = albedoAlpha * _Color.a;
-#endif
-
-#if defined(_ALPHATEST_ON)
-    clip(alpha - _Cutoff);
-#endif
-
-    return alpha;
-}
-
-half3 Normal(float2 uv)
-{
-#if _NORMALMAP
-    return UnpackNormalScale(tex2D(_BumpMap, uv), _BumpScale);
-#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 = tex2D(_SpecGlossMap, uv);
-    specularGloss.rgb = LIGHTWEIGHT_GAMMA_TO_LINEAR(specularGloss.rgb);
-#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 = 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 tex2D(_OcclusionMap, uv).g;
-#else
-    half occ = tex2D(_OcclusionMap, uv).g;
-    return _LerpOneTo(occ, _OcclusionStrength);
-#endif
-#else
-    return 1.0;
-#endif
-}
-
-half3 Emission(float2 uv)
-{
-#ifndef _EMISSION
-    return 0;
-#else
-    return LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, uv).rgb) * _EmissionColor.rgb;
-#endif
-}
-
-inline void InitializeStandardLitSurfaceData(LightweightVertexOutput IN, out SurfaceData outSurfaceData)
-{
-    float2 uv = IN.uv01.xy;
-    half4 albedoAlpha = tex2D(_MainTex, uv);
-
-    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha);
-    outSurfaceData.albedo = LIGHTWEIGHT_GAMMA_TO_LINEAR(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.normal = Normal(uv);
-    outSurfaceData.occlusion = Occlusion(uv);
-    outSurfaceData.emission = Emission(uv);
-    outSurfaceData.alpha = Alpha(albedoAlpha.a);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 //                  Vertex and Fragment functions                            //
 ///////////////////////////////////////////////////////////////////////////////
 
 half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
 {
     SurfaceData surfaceData;
-    InitializeStandardLitSurfaceData(IN, surfaceData);
+    InitializeStandardLitSurfaceData(IN.uv01.xy, surfaceData);
 
 #if _NORMALMAP
     half3 normalWS = TangentToWorldNormal(surfaceData.normal, IN.tangent, IN.binormal, IN.normal);

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandard.shader

             }
             ENDCG
         }
+
+            // This pass it not used during regular rendering, only for lightmap baking.
+            Pass
+            {
+                Tags{"LightMode" = "Meta"}
+
+                Cull Off
+
+                CGPROGRAM
+                #pragma vertex LightweightVertexMeta
+                #pragma fragment LightweightFragmentMeta
+
+                #pragma shader_feature _EMISSION
+                #pragma shader_feature _METALLICSPECGLOSSMAP
+                #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+                #pragma shader_feature EDITOR_VISUALIZATION
+
+                #pragma shader_feature _EMISSION
+                #pragma shader_feature _SPECGLOSSMAP
+
+                #include "LightweightPassMeta.cginc"
+                ENDCG
+            }
-    FallBack "Standard"
+    FallBack "Hidden/InternalErrorShader"
     CustomEditor "LightweightStandardGUI"
 }
 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

             CGPROGRAM
             #define UNITY_SETUP_BRDF_INPUT SpecularSetup
             #pragma vertex LightweightVertexMeta
-            #pragma fragment LightweightFragmentMeta
+            #pragma fragment LightweightFragmentMetaSimple
-            #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-            #pragma shader_feature ___ _DETAIL_MULX2
-            #pragma shader_feature EDITOR_VISUALIZATION
-
-            #include "LightweightPassLit.cginc"
-            #include "UnityMetaPass.cginc"
-
-            struct MetaVertexInput
-            {
-                float4 vertex   : POSITION;
-                half3 normal    : NORMAL;
-                float2 uv0      : TEXCOORD0;
-                float2 uv1      : TEXCOORD1;
-                float2 uv2      : TEXCOORD2;
-#ifdef _TANGENT_TO_WORLD
-                half4 tangent   : TANGENT;
-#endif
-                UNITY_VERTEX_INPUT_INSTANCE_ID
-            };
-
-            struct MetaVertexOuput
-            {
-                float4 pos      : SV_POSITION;
-                float2 uv       : TEXCOORD0;
-            };
-            MetaVertexOuput LightweightVertexMeta(MetaVertexInput v)
-            {
-                MetaVertexOuput o;
-                o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
-                o.uv = TRANSFORM_TEX(v.uv0, _MainTex);
-                return o;
-            }
-
-            fixed4 LightweightFragmentMeta(MetaVertexOuput i) : SV_Target
-            {
-                UnityMetaInput o;
-                UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
-
-                o.Albedo = _Color.rgb * tex2D(_MainTex, i.uv).rgb;
-                o.SpecularColor = SpecularGloss(i.uv.xy, 1.0);
-
-#ifdef _EMISSION
-                o.Emission += LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, i.uv).rgb) * _EmissionColor;
-#else
-                o.Emission += _EmissionColor;
-#endif
-
-                return UnityMetaFragment(o);
-            }
+            #include "LightweightPassMeta.cginc"
-    Fallback "Standard (Specular setup)"
+    Fallback "Hidden/InternalErrorShader"
     CustomEditor "LightweightStandardSimpleLightingGUI"
 }

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardTerrain.shader

             ENDCG
         }
     }
+
+    Fallback "Hidden/InternalErrorShader"
 }

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightUnlit.shader

     }
     SubShader
     {
-        Tags { "RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipe" "Lightmode" = "LightweightForward" }
+        Tags { "RenderType" = "Opaque" "IgnoreProjectors" = "True" "RenderPipeline" = "LightweightPipe" }
         LOD 100
 
         Blend [_SrcBlend][_DstBlend]

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassMeta.cginc

+#ifndef LIGHTWEIGHT_PASS_META_INCLUDED
+#define LIGHTWEIGHT_PASS_META_INCLUDED
+
+#include "LightweightSurfaceInput.cginc"
+#include "LightweightLighting.cginc"
+#include "UnityMetaPass.cginc"
+
+struct MetaVertexInput
+{
+    float4 vertex   : POSITION;
+    half3 normal    : NORMAL;
+    float2 uv0      : TEXCOORD0;
+    float2 uv1      : TEXCOORD1;
+    float2 uv2      : TEXCOORD2;
+#ifdef _TANGENT_TO_WORLD
+    half4 tangent   : TANGENT;
+#endif
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct MetaVertexOuput
+{
+    float4 pos      : SV_POSITION;
+    float2 uv       : TEXCOORD0;
+};
+
+MetaVertexOuput LightweightVertexMeta(MetaVertexInput v)
+{
+    MetaVertexOuput o;
+    o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
+    o.uv = TRANSFORM_TEX(v.uv0, _MainTex);
+    return o;
+}
+
+fixed4 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);
+
+    UnityMetaInput o;
+    UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
+
+    #if defined(EDITOR_VISUALIZATION)
+        o.Albedo = brdfData.diffuse;
+    #else
+        o.Albedo = brdfData.diffuse + brdfData.specular * brdfData.roughness * 0.5;
+    #endif
+    o.SpecularColor = surfaceData.specular;
+    o.Emission = surfaceData.emission;
+
+    return UnityMetaFragment(o);
+}
+
+fixed4 LightweightFragmentMetaSimple(MetaVertexOuput i) : SV_Target
+{
+    UnityMetaInput o;
+    UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
+
+    float2 uv = i.uv;
+    o.Albedo = _Color.rgb * tex2D(_MainTex, uv).rgb;
+    o.SpecularColor = SpecularGloss(uv, 1.0);
+    o.Emission = Emission(uv);
+
+    return UnityMetaFragment(o);
+}
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassMeta.cginc.meta

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

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightSurfaceInput.cginc

+#ifndef LIGHTWEIGHT_SURFACE_INPUT_INCLUDED
+#define LIGHTWEIGHT_SURFACE_INPUT_INCLUDED
+
+#include "LightweightCore.cginc"
+
+#ifdef _SPECULAR_SETUP
+#define SAMPLE_METALLICSPECULAR(uv) tex2D(_SpecGlossMap, uv)
+#else
+#define SAMPLE_METALLICSPECULAR(uv) tex2D(_MetallicGlossMap, uv)
+#endif
+
+CBUFFER_START(MaterialProperties)
+half4 _MainTex_ST;
+half4 _Color;
+half _Cutoff;
+half _Glossiness;
+half _GlossMapScale;
+half _SmoothnessTextureChannel;
+half _Metallic;
+half4 _SpecColor;
+half _BumpScale;
+half _OcclusionStrength;
+half4 _EmissionColor;
+half _Shininess;
+CBUFFER_END
+
+sampler2D _MainTex;
+sampler2D _MetallicGlossMap;
+sampler2D _SpecGlossMap;
+sampler2D _BumpMap;
+sampler2D _OcclusionMap;
+sampler2D _EmissionMap;
+
+// Must match Lightweigth ShaderGraph master node
+struct SurfaceData
+{
+    half3 albedo;
+    half3 specular;
+    half  metallic;
+    half  smoothness;
+    half3 normal;
+    half3 emission;
+    half  occlusion;
+    half  alpha;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Material Property Helpers                            //
+///////////////////////////////////////////////////////////////////////////////
+inline half Alpha(half albedoAlpha)
+{
+#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+    half alpha = _Color.a;
+#else
+    half alpha = albedoAlpha * _Color.a;
+#endif
+
+#if defined(_ALPHATEST_ON)
+    clip(alpha - _Cutoff);
+#endif
+
+    return alpha;
+}
+
+half3 Normal(float2 uv)
+{
+#if _NORMALMAP
+    return UnpackNormalScale(tex2D(_BumpMap, uv), _BumpScale);
+#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 = tex2D(_SpecGlossMap, uv);
+    specularGloss.rgb = LIGHTWEIGHT_GAMMA_TO_LINEAR(specularGloss.rgb);
+#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 = 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 tex2D(_OcclusionMap, uv).g;
+#else
+    half occ = tex2D(_OcclusionMap, uv).g;
+    return _LerpOneTo(occ, _OcclusionStrength);
+#endif
+#else
+    return 1.0;
+#endif
+}
+
+half3 Emission(float2 uv)
+{
+#ifndef _EMISSION
+    return 0;
+#else
+    return LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, uv).rgb) * _EmissionColor.rgb;
+#endif
+}
+
+inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
+{
+    half4 albedoAlpha = tex2D(_MainTex, uv);
+
+    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha);
+    outSurfaceData.albedo = LIGHTWEIGHT_GAMMA_TO_LINEAR(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.normal = Normal(uv);
+    outSurfaceData.occlusion = Occlusion(uv);
+    outSurfaceData.emission = Emission(uv);
+    outSurfaceData.alpha = Alpha(albedoAlpha.a);
+}
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightSurfaceInput.cginc.meta

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