Converted fragment functions to use InputData struct so we can update more easily ShaderGraph template.

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Input.hlsl

 
 #define MAX_VISIBLE_LIGHTS 16
 
+struct InputData
+{
+    float3  positionWS;
+    half3   normalWS;
+    half3   viewDirectionWS;
+    float4  shadowCoord;
+    half    fogCoord;
+    half3   vertexLighting;
+    half3   bakedGI;
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 //                      Constant Buffers                                     //
 ///////////////////////////////////////////////////////////////////////////////

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

     half3 specular;
     half  metallic;
     half  smoothness;
-    half3 normal;
+    half3 normalTS;
     half3 emission;
     half  occlusion;
     half  alpha;
 #endif
 
     outSurfaceData.smoothness = specGloss.a;
-    outSurfaceData.normal = Normal(uv);
+    outSurfaceData.normalTS = Normal(uv);
     outSurfaceData.occlusion = Occlusion(uv);
     outSurfaceData.emission = Emission(uv);
     outSurfaceData.alpha = Alpha(albedoAlpha.a);

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 //                      Fragment Functions                                   //
 //       Used by ShaderGraph and others builtin renderers                    //
 ///////////////////////////////////////////////////////////////////////////////
-half4 LightweightFragmentPBR(float3 positionWS, half3 normalWS, half3 viewDirectionWS, float4 shadowCoord,
-    half3 bakedGI, half3 vertexLighting, half3 albedo, half metallic, half3 specular,
+half4 LightweightFragmentPBR(InputData inputData, half3 albedo, half metallic, half3 specular,
-    Light mainLight = GetMainLight(positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(positionWS, shadowCoord);
+    Light mainLight = GetMainLight(inputData.positionWS);
+    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.positionWS, inputData.shadowCoord);
-    MixRealtimeAndBakedGI(mainLight, normalWS, bakedGI, half4(0, 0, 0, 0));
-    half3 color = GlobalIllumination(brdfData, bakedGI, occlusion, normalWS, viewDirectionWS);
-    color += LightingPhysicallyBased(brdfData, mainLight, normalWS, viewDirectionWS);
+    MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
+    half3 color = GlobalIllumination(brdfData, inputData.bakedGI, occlusion, inputData.normalWS, inputData.viewDirectionWS);
+    color += LightingPhysicallyBased(brdfData, mainLight, inputData.normalWS, inputData.viewDirectionWS);
-        Light light = GetLight(i, positionWS);
-        color += LightingPhysicallyBased(brdfData, light, normalWS, viewDirectionWS);
+        Light light = GetLight(i, inputData.positionWS);
+        color += LightingPhysicallyBased(brdfData, light, inputData.normalWS, inputData.viewDirectionWS);
-    color += vertexLighting * brdfData.diffuse;
+    color += inputData.vertexLighting * brdfData.diffuse;
-half4 LightweightFragmentLambert(float3 positionWS, half3 normalWS, half3 viewDirectionWS, float4 shadowCoord,
-    half fogFactor, half3 bakedGI, half3 diffuse, half3 emission, half alpha)
-{
-    Light mainLight = GetMainLight(positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(positionWS, shadowCoord);
-    MixRealtimeAndBakedGI(mainLight, normalWS, bakedGI, half4(0, 0, 0, 0));
-
-    half3 lambert = LightingLambert(mainLight.color, mainLight.direction, normalWS);
-    half3 diffuseColor = lambert * mainLight.attenuation + bakedGI;
-
-#ifdef _ADDITIONAL_LIGHTS
-    int pixelLightCount = GetPixelLightCount();
-    for (int i = 0; i < pixelLightCount; ++i)
-    {
-        Light light = GetLight(i, positionWS);
-        half3 attenuatedLightColor = light.color * light.attenuation;
-        diffuseColor += LightingLambert(attenuatedLightColor, light.direction, normalWS);
-    }
-#endif
-
-    half3 finalColor = diffuseColor * diffuse + emission;
-
-    ApplyFog(finalColor, fogFactor);
-    return half4(finalColor, alpha);
-}
-
-half4 LightweightFragmentBlinnPhong(float3 positionWS, half3 normalWS, half3 viewDirectionWS, float4 shadowCoord,
-    half fogFactor, half3 bakedGI, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
+half4 LightweightFragmentBlinnPhong(InputData inputData, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
-    Light mainLight = GetMainLight(positionWS);
-    mainLight.attenuation *= RealtimeShadowAttenuation(positionWS, shadowCoord);
-    MixRealtimeAndBakedGI(mainLight, normalWS, bakedGI, half4(0, 0, 0, 0));
+    Light mainLight = GetMainLight(inputData.positionWS);
+    mainLight.attenuation *= RealtimeShadowAttenuation(inputData.positionWS, inputData.shadowCoord);
+    MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
-    half3 diffuseColor = bakedGI + LightingLambert(attenuatedLightColor, mainLight.direction, normalWS);
-    half3 specularColor = LightingSpecular(attenuatedLightColor, mainLight.direction, normalWS, viewDirectionWS, specularGloss, shininess);
+    half3 diffuseColor = inputData.bakedGI + LightingLambert(attenuatedLightColor, mainLight.direction, inputData.normalWS);
+    half3 specularColor = LightingSpecular(attenuatedLightColor, mainLight.direction, inputData.normalWS, inputData.viewDirectionWS, specularGloss, shininess);
-        Light light = GetLight(i, positionWS);
+        Light light = GetLight(i, inputData.positionWS);
-        diffuseColor += LightingLambert(attenuatedLightColor, light.direction, normalWS);
-        specularColor += LightingSpecular(attenuatedLightColor, light.direction, normalWS, viewDirectionWS, specularGloss, shininess);
+        diffuseColor += LightingLambert(attenuatedLightColor, light.direction, inputData.normalWS);
+        specularColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, specularGloss, shininess);
+    finalColor += inputData.vertexLighting * diffuse;
+    
+#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
+#endif
-    ApplyFog(finalColor, fogFactor);
+    ApplyFog(finalColor, inputData.fogCoord);
     return half4(finalColor, alpha);
 }
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     float4 clipPos                  : SV_POSITION;
 };
 
+void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
+{
+    inputData.positionWS = IN.posWS.xyz;
+
+#ifdef _NORMALMAP
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
+#else
+    inputData.normalWS = normalize(IN.normal);
+#endif
+
+#ifdef SHADER_API_MOBILE
+    // viewDirection should be normalized here, but we avoid doing it as it's close enough and we save some ALU.
+    inputData.viewDirectionWS = IN.viewDir;
+#else
+    inputData.viewDirectionWS = normalize(IN.viewDir);
+#endif
+
+#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 = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 //                  Vertex and Fragment functions                            //
 ///////////////////////////////////////////////////////////////////////////////
     SurfaceData surfaceData;
     InitializeStandardLitSurfaceData(IN.uv, surfaceData);
 
-#ifdef _NORMALMAP
-    half3 normalWS = TangentToWorldNormal(surfaceData.normal, IN.tangent, IN.binormal, IN.normal);
-#else
-    half3 normalWS = normalize(IN.normal);
-#endif
+    InputData inputData;
+    InitializeInputData(IN, surfaceData.normalTS, inputData);
-    half3 bakedGI = SampleGI(IN.lightmapUVOrVertexSH, normalWS);
-    half fogFactor = IN.fogFactorAndVertexLight.x;
-    half3 vertexLighting = IN.fogFactorAndVertexLight.yzw;
-    float3 positionWS = IN.posWS.xyz;
+    half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-    // viewDirection should be normalized here, but we avoid doing it as it's close enough and we save some ALU.
-    half3 viewDirectionWS = IN.viewDir;
-
-    float4 shadowCoord = float4(0, 0, 0, 0);
-#ifdef _SHADOWS_ENABLED
-    shadowCoord = IN.shadowCoord;
-#endif
-
-    BRDFData brdfData;
-    InitializeBRDFData(surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.alpha, brdfData);
-
-    half4 color = LightweightFragmentPBR(positionWS, normalWS, viewDirectionWS, shadowCoord, bakedGI, vertexLighting,
-        surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-
-    ApplyFog(color.rgb, fogFactor);
+    ApplyFog(color.rgb, inputData.fogCoord);
     return color;
 }
 
     float2 uv = IN.uv;
-
     half4 diffuseAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
     half3 diffuse = diffuseAlpha.rgb * _Color.rgb;
 
     AlphaDiscard(alpha, _Cutoff);
 
 #ifdef _NORMALMAP
-    half3 normalTangent = Normal(uv);
-    half3 normalWS = TangentToWorldNormal(normalTangent, IN.tangent, IN.binormal, IN.normal);
+    half3 normalTS = Normal(uv);
-    half3 normalWS = normalize(IN.normal);
-#endif
-
-    float4 shadowCoord = float4(0, 0, 0, 0);
-#ifdef _SHADOWS_ENABLED
-    shadowCoord = IN.shadowCoord;
+    half3 normalTS = half3(0, 0, 1);
-
-    half3 viewDirectionWS = SafeNormalize(IN.viewDir.xyz);
-    float3 positionWS = IN.posWS.xyz;
-
-    half3 diffuseGI = SampleGI(IN.lightmapUVOrVertexSH, normalWS);
-
-#ifdef _VERTEX_LIGHTS
-    diffuseGI += IN.fogFactorAndVertexLight.yzw;
-#endif
-
+    half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
-    half fogFactor = IN.fogFactorAndVertexLight.x;
-#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
-    half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
-    return LightweightFragmentBlinnPhong(positionWS, normalWS, viewDirectionWS, shadowCoord, fogFactor, diffuseGI, diffuse, specularGloss, shininess, emission, alpha);
-#else
-    return LightweightFragmentLambert(positionWS, normalWS, viewDirectionWS, shadowCoord, fogFactor, diffuseGI, diffuse, emission, alpha);
-#endif
+    InputData inputData;
+    InitializeInputData(IN, normalTS, inputData);
+
+    return LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
 };
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Particles.hlsl

 #endif
 
 #if defined(_NORMALMAP)
-    float3 normal = normalize(UnpackNormalScale(readTexture(_BumpMap, sampler_BumpMap, IN), _BumpScale));
+    half3 normalTS = normalize(UnpackNormalScale(readTexture(_BumpMap, sampler_BumpMap, IN), _BumpScale));
-    float3 normal = float3(0, 0, 1);
+    half3 normalTS = float3(0, 0, 1);
 #endif
 
 #if defined(_EMISSION)
 
     surfaceData.albedo = albedo.rbg;
     surfaceData.specular = half3(0, 0, 0);
-    surfaceData.normal = normal;
+    surfaceData.normalTS = normalTS;
     surfaceData.emission = emission * _EmissionColor.rgb;
     surfaceData.metallic = metallicGloss.r;
     surfaceData.smoothness = metallicGloss.g;
 #if defined(_ALPHATEST_ON)
     clip(surfaceData.alpha - _Cutoff + 0.0001);
 #endif
+}
+
+void InitializeInputData(VertexOutputLit IN, half3 normalTS, out InputData input)
+{
+    input.positionWS = IN.posWS.xyz;
+#if _NORMALMAP
+    input.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
+#else
+    input.normalWS = normalize(IN.normal);
+#endif
+
+    input.viewDirectionWS = SafeNormalize(GetCameraPositionWS() - input.positionWS);
+    input.shadowCoord = float4(0, 0, 0, 0);
+    input.fogCoord = IN.posWS.w;
+    input.vertexLighting = half3(0, 0, 0);
+    input.bakedGI = half3(0, 0, 0);
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

                 SurfaceData surfaceData;
                 InitializeSurfaceData(IN, surfaceData);
 
-                float3 positionWS = IN.posWS.xyz;
-                half3 viewDirWS = SafeNormalize(GetCameraPositionWS() - positionWS);
-                half fogFactor = IN.posWS.w;
-
-#if _NORMALMAP
-                half3 normalWS = TangentToWorldNormal(surfaceData.normal, IN.tangent, IN.binormal, IN.normal);
-#else
-                half3 normalWS = normalize(IN.normal);
-#endif
+                InputData inputData;
+                InitializeInputData(IN, surfaceData.normalTS, inputData);
-                half3 zero = half3(0.0, 0.0, 0.0);
-                half4 color = LightweightFragmentPBR(positionWS, normalWS, viewDirWS, half4(0, 0, 0, 0), /*indirectDiffuse*/ zero, /*vertex lighting*/ zero, surfaceData.albedo,
-                    surfaceData.metallic, /* specularColor */ zero, surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-                ApplyFog(color.rgb, fogFactor);
+                half4 color = LightweightFragmentPBR(inputData, surfaceData.albedo,
+                    surfaceData.metallic, half3(0, 0, 0), surfaceData.smoothness, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
+                ApplyFog(color.rgb, inputData.fogCoord);
                 return color;
             }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

                 float4 clipPos                  : SV_POSITION;
             };
 
+            void InitializeInputData(VertexOutput IN, half3 normalTS, out InputData input)
+            {
+                input = (InputData)0;
+                input.positionWS = IN.positionWS;
+
+#ifdef _TERRAIN_NORMAL_MAP
+                input.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
+#else
+                input.normalWS = normalize(IN.normal);
+#endif
+
+                input.viewDirectionWS = SafeNormalize(GetCameraPositionWS() - IN.positionWS);
+
+#ifdef _SHADOWS_ENABLED
+                input.shadowCoord = IN.shadowCoord;
+#endif
+
+                input.fogCoord = IN.fogFactorAndVertexLight.x;
+
+#ifdef LIGHTMAP_ON
+                input.bakedGI = SampleLightmap(IN.uvControlAndLM.zw, input.normalWS);
+#endif
+            }
+
             void SplatmapMix(VertexOutput IN, half4 defaultAlpha, out half4 splat_control, out half weight, out half4 mixedDiffuse, inout half3 mixedNormal)
             {
                 splat_control = tex2D(_Control, IN.uvControlAndLM.xy);
                 half weight;
                 half4 mixedDiffuse;
                 half4 defaultSmoothness = half4(_Smoothness0, _Smoothness1, _Smoothness2, _Smoothness3);
-                half3 normalTangent;
-                SplatmapMix(IN, defaultSmoothness, splat_control, weight, mixedDiffuse, normalTangent);
+                half3 normalTS;
+                SplatmapMix(IN, defaultSmoothness, splat_control, weight, mixedDiffuse, normalTS);
 
                 half3 albedo = mixedDiffuse.rgb;
                 half smoothness = mixedDiffuse.a;
 
-#ifdef _TERRAIN_NORMAL_MAP
-                half3 normalWS = TangentToWorldNormal(normalTangent, IN.tangent, IN.binormal, IN.normal);
-#else
-                half3 normalWS = normalize(IN.normal);
-#endif
+                InputData inputData;
+                InitializeInputData(IN, normalTS, inputData);
+                half4 color = LightweightFragmentPBR(inputData, albedo, metallic, specular, smoothness, /* occlusion */ 1.0, /* emission */ half3(0, 0, 0), alpha);
-                half3 indirectDiffuse = half3(0, 0, 0);
-#ifdef LIGHTMAP_ON
-                indirectDiffuse = SampleLightmap(IN.uvControlAndLM.zw, normalWS);
-#endif
-
-                float4 shadowCoord = float4(0, 0, 0, 0);
-#ifdef _SHADOWS_ENABLED
-                shadowCoord = IN.shadowCoord;
-#endif
-
-                half3 viewDirectionWS = SafeNormalize(GetCameraPositionWS() - IN.positionWS);
-                half fogFactor = IN.fogFactorAndVertexLight.x;
-                half4 color = LightweightFragmentPBR(IN.positionWS, normalWS, viewDirectionWS, shadowCoord, indirectDiffuse,
-                    IN.fogFactorAndVertexLight.yzw, albedo, metallic, specular, smoothness, /* occlusion */ 1.0, /* emission */ half3(0, 0, 0), alpha);
-
-                ApplyFog(color.rgb, fogFactor);
+                ApplyFog(color.rgb, inputData.fogCoord);
                 return color;
             }
             ENDHLSL

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

 
 #if _SAMPLE_GI
     #if _NORMALMAP
-                half3 normalWS = TangentToWorldNormal(surfaceData.normal, IN.tangent, IN.binormal, IN.normal);
+                half3 normalWS = TangentToWorldNormal(surfaceData.normalTS, IN.tangent, IN.binormal, IN.normal);
     #else
                 half3 normalWS = normalize(IN.normal);
     #endif