Merge pull request #1075 from Unity-Technologies/backport/LowEndPerf-1055

Backport/low end perf 1055

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

 	HLSLPROGRAM
     // Required to compile gles 2.0 with standard srp library
     #pragma prefer_hlslcc gles
-	#pragma target 3.0
+	#pragma target 2.0
 
 	// -------------------------------------
 	// Lightweight Pipeline keywords
 	struct GraphVertexOutput
     {
         float4 clipPos                : SV_POSITION;
-        float4 lightmapUVOrVertexSH   : TEXCOORD0;
+        DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 0);
 		half4 fogFactorAndVertexLight : TEXCOORD1; // x: fogFactor, yzw: vertex light
     	float4 shadowCoord            : TEXCOORD2;
         ${Interpolators}
  		// We either sample GI from lightmap or SH. lightmap UV and vertex SH coefficients
 	    // are packed in lightmapUVOrVertexSH to save interpolator.
 	    // The following funcions initialize
-	    OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH);
-	    OUTPUT_SH(lwWNormal, o.lightmapUVOrVertexSH);
+	    OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUV);
+	    OUTPUT_SH(lwWNormal, o.vertexSH);
 
 	    half3 vertexLight = VertexLighting(lwWorldPos, lwWNormal);
 	    half fogFactor = ComputeFogFactor(clipPos.z);
 #ifdef _NORMALMAP
 	    inputData.normalWS = TangentToWorldNormal(Normal, WorldSpaceTangent, WorldSpaceBiTangent, WorldSpaceNormal);
 #else
+    #if !SHADER_HINT_NICE_QUALITY
+        inputData.normalWS = WorldSpaceNormal;
+    #else
+    #endif
-#ifdef SHADER_API_MOBILE
+#if !SHADER_HINT_NICE_QUALITY
 	    // viewDirection should be normalized here, but we avoid doing it as it's close enough and we save some ALU.
 	    inputData.viewDirectionWS = WorldSpaceViewDirection;
 #else
 
 	    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
 	    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
-	    inputData.bakedGI = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS);
+	    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
 
 		half4 color = LightweightFragmentPBR(
 			inputData, 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

 
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef _NORMALMAP
-    #define OUTPUT_NORMAL(IN, OUT) OutputTangentToWorld(IN.tangent, IN.normal, OUT.tangent, OUT.binormal, OUT.normal)
+    #define OUTPUT_NORMAL(IN, OUT) OutputTangentToWorld(IN.tangent, IN.normal, OUT.tangent.xyz, OUT.binormal.xyz, OUT.normal.xyz)
 #else
     #define OUTPUT_NORMAL(IN, OUT) OUT.normal = TransformObjectToWorldNormal(IN.normal)
 #endif
 half3 TangentToWorldNormal(half3 normalTangent, half3 tangent, half3 binormal, half3 normal)
 {
     half3x3 tangentToWorld = half3x3(tangent, binormal, normal);
+#if !SHADER_HINT_NICE_QUALITY
+    return mul(normalTangent, tangentToWorld);
+#else
+#endif
 }
 
 // TODO: A similar function should be already available in SRP lib on master. Use that instead

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

     half4 specularGloss = half4(0, 0, 0, 1);
 #ifdef _SPECGLOSSMAP
     specularGloss = SAMPLE_TEXTURE2D(_SpecGlossMap, sampler_SpecGlossMap, uv);
-    specularGloss.rgb = specularGloss.rgb;
 #elif defined(_SPECULAR_COLOR)
     specularGloss = _SpecColor;
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 // If lightmap is not defined than we evaluate GI (ambient + probes) from SH
 // We might do it fully or partially in vertex to save shader ALU
 #if !defined(LIGHTMAP_ON)
-    #ifdef SHADER_API_GLES
+    #if defined(SHADER_API_GLES) || (SHADER_TARGET < 30) || !defined(_NORMALMAP)
-    #else
+    #elif !SHADER_HINT_NICE_QUALITY
+        // Otherwise evaluate SH fully per-pixel
+
+    #define DECLARE_LIGHTMAP_OR_SH(lmName, shName, index) float2 lmName : TEXCOORD##index
+    #define DECLARE_LIGHTMAP_OR_SH(lmName, shName, index) half3 shName : TEXCOORD##index
     #define OUTPUT_LIGHTMAP_UV(lightmapUV, lightmapScaleOffset, OUT)
     #define OUTPUT_SH(normalWS, OUT) OUT.xyz = SampleSHVertex(normalWS)
 #endif
 // mixed or fully in pixel. See SampleSHVertex
 half3 SampleSHPixel(half3 L2Term, half3 normalWS)
 {
-#ifdef EVALUATE_SH_MIXED
+#if defined(EVALUATE_SH_VERTEX)
+    return L2Term;
+#elif defined(EVALUATE_SH_MIXED)
     half3 L0L1Term = SHEvalLinearL0L1(normalWS, unity_SHAr, unity_SHAg, unity_SHAb);
     return max(half3(0, 0, 0), L2Term + L0L1Term);
 #endif
 // We either sample GI from baked lightmap or from probes.
 // If lightmap: sampleData.xy = lightmapUV
 // If probe: sampleData.xyz = L2 SH terms
-half3 SampleGI(float4 sampleData, half3 normalWS)
+#ifdef LIGHTMAP_ON
+#define SAMPLE_GI(lmName, shName, normalWSName) SampleGI(lmName, normalWSName)
+half3 SampleGI(float2 sampleData, half3 normalWS)
+{
+    return SampleLightmap(sampleData, normalWS);
+}
+#else
+#define SAMPLE_GI(lmName, shName, normalWSName) SampleGI(shName, normalWSName)
+half3 SampleGI(half3 sampleData, half3 normalWS)
-#ifdef LIGHTMAP_ON
-    return SampleLightmap(sampleData.xy, normalWS);
-#endif
-
-    return SampleSHPixel(sampleData.xyz, normalWS);
+    return SampleSHPixel(sampleData, normalWS);
+#endif
 
 half3 GlossyEnvironmentReflection(half3 reflectVector, half perceptualRoughness, half occlusion)
 {

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

 struct LightweightVertexOutput
 {
     float2 uv                       : TEXCOORD0;
-    float4 lightmapUVOrVertexSH     : TEXCOORD1; // holds either lightmapUV or vertex SH. depending on LIGHTMAP_ON
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
-    half3  normal                   : TEXCOORD3;
-    half3 tangent                   : TEXCOORD4;
-    half3 binormal                  : TEXCOORD5;
+    half4 normal                    : TEXCOORD3;    // xyz: normal, w: viewDir.x
+    half4 tangent                   : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+    half4 binormal                  : TEXCOORD5;    // xyz: binormal, w: viewDir.w
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD6;
-    half3 viewDir                   : TEXCOORD6;
-    float4 shadowCoord               : TEXCOORD8;
+    float4 shadowCoord              : TEXCOORD8;
 
     float4 clipPos                  : SV_POSITION;
     UNITY_VERTEX_INPUT_INSTANCE_ID
     inputData.positionWS = IN.posWS.xyz;
 
 #ifdef _NORMALMAP
-    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
+    half3 viewDir = half3(IN.tangent.w, IN.binormal.w, IN.normal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
-    inputData.normalWS = normalize(IN.normal);
+    half3 viewDir = IN.viewDir;
+    #if !SHADER_HINT_NICE_QUALITY
+        // World normal is already normalized in vertex. Small acceptable error to save ALU.
+        inputData.normalWS = IN.normal;
+    #else
+        inputData.normalWS = normalize(IN.normal);
+    #endif
-    inputData.viewDirectionWS = SafeNormalize(IN.viewDir);
+    inputData.viewDirectionWS = SafeNormalize(viewDir);
-    // View direction is already normalize in vertex. Small acceptable error to save ALU.
-    inputData.viewDirectionWS = IN.viewDir;
+    // View direction is already normalized in vertex. Small acceptable error to save ALU.
+    inputData.viewDirectionWS = viewDir;
 #endif
 
     inputData.shadowCoord = IN.shadowCoord;
-    inputData.bakedGI = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS);
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
     o.posWS = TransformObjectToWorld(v.vertex.xyz);
     o.clipPos = TransformWorldToHClip(o.posWS);
 
-    o.viewDir = GetCameraPositionWS() - o.posWS;
-
+    half3 viewDir = GetCameraPositionWS() - o.posWS;
-    o.viewDir = SafeNormalize(o.viewDir);
+    viewDir = SafeNormalize(viewDir);
+#endif
+
+#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
     // are packed in lightmapUVOrVertexSH to save interpolator.
     // The following funcions initialize
-    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUVOrVertexSH);
-    OUTPUT_SH(o.normal, o.lightmapUVOrVertexSH);
+    OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
+    OUTPUT_SH(o.normal.xyz, o.vertexSH);
-    half3 vertexLight = VertexLighting(o.posWS, o.normal);
+    half3 vertexLight = VertexLighting(o.posWS, o.normal.xyz);
     half fogFactor = ComputeFogFactor(o.clipPos.z);
     o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
     o.shadowCoord = ComputeShadowCoord(o.clipPos);

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
-            #pragma target 3.0
+            #pragma target 2.0
 
             // -------------------------------------
             // Material Keywords