Added meta pass for StandardShader.

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 "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"
             ENDCG
         }
     }

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: