Merge pull request #1053 from Unity-Technologies/LW-Bugfix

Lightweight Bugfixes / Small Improvements

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         private MixedLightingSetup m_MixedLightingSetup;
 
         private const int kDepthStencilBufferBits = 32;
+        private const int kShadowBufferBits = 16;
         private Vector4[] m_DirectionalShadowSplitDistances = new Vector4[kMaxCascades];
         private Vector4 m_DirectionalShadowSplitRadii;
 
 
             var cmd = CommandBufferPool.Get("Prepare Shadowmap");
             cmd.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, kDepthStencilBufferBits, FilterMode.Bilinear, m_ShadowSettings.renderTextureFormat);
+                m_ShadowSettings.shadowAtlasHeight, kShadowBufferBits, FilterMode.Bilinear, m_ShadowSettings.renderTextureFormat);
             // LightweightPipeline.SetRenderTarget is meant to be used with camera targets, not shadowmaps
             CoreUtils.SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.Depth, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor));
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

 #include "CoreRP/ShaderLibrary/Packing.hlsl"
 #include "Input.hlsl"
 
+#if !defined(SHADER_HINT_NICE_QUALITY)
+#ifdef SHADER_API_MOBILE
+#define SHADER_HINT_NICE_QUALITY 0
+#else
+#define SHADER_HINT_NICE_QUALITY 1
+#endif
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef _NORMALMAP
     #define OUTPUT_NORMAL(IN, OUT) OutputTangentToWorld(IN.tangent, IN.normal, OUT.tangent, OUT.binormal, OUT.normal)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 
 half4 GetMainLightDirectionAndAttenuation(LightInput lightInput, float3 positionWS)
 {
-    half4 directionAndAttenuation = lerp(half4(lightInput.position.xyz, 1.0), GetLightDirectionAndAttenuation(lightInput, positionWS), lightInput.position.w);
+    half4 directionAndAttenuation = GetLightDirectionAndAttenuation(lightInput, positionWS);
 
     // Cookies are only computed for main light
     directionAndAttenuation.w *= CookieAttenuation(positionWS);
 
 
     // 1) Gives good estimate of illumination as if light would've been shadowed during the bake.
-    //    Preserves bounce and other baked lights
-    //    No shadows on the geometry facing away from the light
+    // We only subtract the main direction light. This is accounted in the contribution term below.
-    half NdotL = saturate(dot(mainLight.direction, normalWS));
-    half3 lambert = mainLight.color * NdotL;
+    half contributionTerm = saturate(dot(mainLight.direction, normalWS)) * (1.0 - _MainLightPosition.w);
+    half3 lambert = mainLight.color * contributionTerm;
     half3 estimatedLightContributionMaskedByInverseOfShadow = lambert * (1.0 - mainLight.attenuation);
     half3 subtractedLightmap = bakedGI - estimatedLightContributionMaskedByInverseOfShadow;
 
 
 void MixRealtimeAndBakedGI(inout Light light, half3 normalWS, inout half3 bakedGI, half4 shadowMask)
 {
-#if defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_ON) && defined(_SHADOWS_ENABLED)
-    bakedGI = lerp(SubtractDirectMainLightFromLightmap(light, normalWS, bakedGI), bakedGI, _MainLightPosition.w);
+#if defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_ON)
+    bakedGI = SubtractDirectMainLightFromLightmap(light, normalWS, bakedGI);
 #endif
 
 #if defined(LIGHTMAP_ON)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     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;
+#if SHADER_HINT_NICE_QUALITY
+    inputData.viewDirectionWS = SafeNormalize(IN.viewDir);
-    inputData.viewDirectionWS = normalize(IN.viewDir);
+    // View direction is already normalize in vertex. Small acceptable error to save ALU.
+    inputData.viewDirectionWS = IN.viewDir;
 #endif
 
     inputData.shadowCoord = IN.shadowCoord;
 
     o.posWS = TransformObjectToWorld(v.vertex.xyz);
     o.clipPos = TransformWorldToHClip(o.posWS);
-    o.viewDir = SafeNormalize(GetCameraPositionWS() - o.posWS);
+
+    o.viewDir = GetCameraPositionWS() - o.posWS;
+
+#if !SHADER_HINT_NICE_QUALITY
+    // Normalize in vertex and avoid renormalizing it in frag to save ALU.
+    o.viewDir = SafeNormalize(o.viewDir);
+#endif
 
     // initializes o.normal and if _NORMALMAP also o.tangent and o.binormal
     OUTPUT_NORMAL(v, o);