Merge pull request #1483 from Unity-Technologies/lw/bugfixes

Lw/bugfixes

com.unity.render-pipelines.core/CoreRP/Editor/CoreEditorUtils.cs

 
             mode = EditorGUILayout.Popup(label, mode, options);
             if (EditorGUI.EndChangeCheck())
-            {
-                Undo.RecordObject(property.objectReferenceValue, property.name);
-            }
         }
 
         public static void DrawCascadeSplitGUI<T>(ref SerializedProperty shadowCascadeSplit)

com.unity.render-pipelines.lightweight/LWRP/Editor/LightweightLightEditor.cs

     [CustomEditorForRenderPipeline(typeof(Light), typeof(LightweightPipelineAsset))]
     class LightweightLightEditor : LightEditor
     {
-        AnimBool m_AnimShowSpotOptions = new AnimBool();
-        AnimBool m_AnimShowPointOptions = new AnimBool();
-        AnimBool m_AnimShowDirOptions = new AnimBool();
-        AnimBool m_AnimShowAreaOptions = new AnimBool();
-        AnimBool m_AnimShowRuntimeOptions = new AnimBool();
-        AnimBool m_AnimShowShadowOptions = new AnimBool();
-        AnimBool m_AnimBakedShadowAngleOptions = new AnimBool();
-        AnimBool m_AnimBakedShadowRadiusOptions = new AnimBool();
-        AnimBool m_AnimShowLightBounceIntensity = new AnimBool();
+        AnimBool m_AnimSpotOptions = new AnimBool();
+        AnimBool m_AnimPointOptions = new AnimBool();
+        AnimBool m_AnimDirOptions = new AnimBool();
+        AnimBool m_AnimAreaOptions = new AnimBool();
+        AnimBool m_AnimRuntimeOptions = new AnimBool();
+        AnimBool m_AnimShadowOptions = new AnimBool();
+        AnimBool m_AnimShadowAngleOptions = new AnimBool();
+        AnimBool m_AnimShadowRadiusOptions = new AnimBool();
+        AnimBool m_AnimLightBounceIntensity = new AnimBool();
 
         class Styles
         {
 
             // When we are switching between two light types that don't show the range (directional and area lights)
             // we want the fade group to stay hidden.
-            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimShowDirOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimDirOptions.faded))
-                    settings.DrawRange(m_AnimShowAreaOptions.target);
+                    settings.DrawRange(m_AnimAreaOptions.target);
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimShowSpotOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimSpotOptions.faded))
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimShowAreaOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimAreaOptions.faded))
                 if (group.visible)
                     settings.DrawArea();
 
 
-            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimShowAreaOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimAreaOptions.faded))
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimShowLightBounceIntensity.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimLightBounceIntensity.faded))
                 if (group.visible)
                     settings.DrawBounceIntensity();
 
 
         void UpdateShowOptions(bool initialize)
         {
-            SetOptions(m_AnimShowSpotOptions, initialize, spotOptionsValue);
-            SetOptions(m_AnimShowPointOptions, initialize, pointOptionsValue);
-            SetOptions(m_AnimShowDirOptions, initialize, dirOptionsValue);
-            SetOptions(m_AnimShowAreaOptions, initialize, areaOptionsValue);
-            SetOptions(m_AnimShowShadowOptions, initialize, shadowOptionsValue);
-            SetOptions(m_AnimShowRuntimeOptions, initialize, runtimeOptionsValue);
-            SetOptions(m_AnimBakedShadowAngleOptions, initialize, bakedShadowAngle);
-            SetOptions(m_AnimBakedShadowRadiusOptions, initialize, bakedShadowRadius);
-            SetOptions(m_AnimShowLightBounceIntensity, initialize, showLightBounceIntensity);
+            SetOptions(m_AnimSpotOptions, initialize, spotOptionsValue);
+            SetOptions(m_AnimPointOptions, initialize, pointOptionsValue);
+            SetOptions(m_AnimDirOptions, initialize, dirOptionsValue);
+            SetOptions(m_AnimAreaOptions, initialize, areaOptionsValue);
+            SetOptions(m_AnimShadowOptions, initialize, shadowOptionsValue);
+            SetOptions(m_AnimRuntimeOptions, initialize, runtimeOptionsValue);
+            SetOptions(m_AnimShadowAngleOptions, initialize, bakedShadowAngle);
+            SetOptions(m_AnimShadowRadiusOptions, initialize, bakedShadowRadius);
+            SetOptions(m_AnimLightBounceIntensity, initialize, showLightBounceIntensity);
         }
 
         void DrawSpotAngle()
         void ShadowsGUI()
         {
             // Shadows drop-down. Area lights can only be baked and always have shadows.
-            float show = 1.0f - m_AnimShowAreaOptions.faded;
+            float show = 1.0f - m_AnimAreaOptions.faded;
-            show *= m_AnimShowShadowOptions.faded;
+            show *= m_AnimShadowOptions.faded;
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimBakedShadowRadiusOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimShadowRadiusOptions.faded))
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimBakedShadowAngleOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimShadowAngleOptions.faded))
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimShowRuntimeOptions.faded))
+            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimRuntimeOptions.faded))
                 if (group.visible)
                     settings.DrawRuntimeShadow();
             EditorGUI.indentLevel -= 1;

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderPreprocessor.cs

 
 namespace UnityEditor.Experimental.Rendering.LightweightPipeline
 {
+    public static class LightweightKeyword
+    {
+        public static readonly ShaderKeyword AdditionalLights = new ShaderKeyword(LightweightKeywordStrings.AdditionalLights);
+        public static readonly ShaderKeyword VertexLights = new ShaderKeyword(LightweightKeywordStrings.VertexLights);
+        public static readonly ShaderKeyword MixedLightingSubtractive = new ShaderKeyword(LightweightKeywordStrings.MixedLightingSubtractive);
+        public static readonly ShaderKeyword MainLightCookie = new ShaderKeyword(LightweightKeywordStrings.MainLightCookie);
+        public static readonly ShaderKeyword DirectionalShadows = new ShaderKeyword(LightweightKeywordStrings.DirectionalShadows);
+        public static readonly ShaderKeyword LocalShadows = new ShaderKeyword(LightweightKeywordStrings.LocalShadows);
+        public static readonly ShaderKeyword SoftShadows = new ShaderKeyword(LightweightKeywordStrings.SoftShadows);
+
+        public static readonly ShaderKeyword Lightmap = new ShaderKeyword("LIGHTMAP_ON");
+        public static readonly ShaderKeyword DirectionalLightmap = new ShaderKeyword("DIRLIGHTMAP_COMBINED");
+    }
+
     public class ShaderPreprocessor : IPreprocessShaders
     {
 #if LOG_VARIANTS
 
         bool StripUnusedVariant(PipelineCapabilities capabilities, ShaderCompilerData compilerData)
         {
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.AdditionalLights) &&
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.AdditionalLights) &&
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.VertexLights) &&
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.VertexLights) &&
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.DirectionalShadows) &&
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalShadows) &&
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.LocalShadows) &&
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.LocalShadows) &&
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.SoftShadows) &&
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.SoftShadows) &&
                 !CoreUtils.HasFlag(capabilities, PipelineCapabilities.SoftShadows))
                 return true;
 
         bool StripInvalidVariants(ShaderCompilerData compilerData)
         {
-            bool isShadowVariant = compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.DirectionalShadows) ||
-                compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.LocalShadows);
+            bool isShadowVariant = compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalShadows) ||
+                compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.LocalShadows);
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.SoftShadows) && !isShadowVariant)
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.SoftShadows) && !isShadowVariant)
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.VertexLights) &&
-                !compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.AdditionalLights))
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.VertexLights) &&
+                !compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.AdditionalLights))
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.DirectionalLightmap) &&
-                !compilerData.shaderKeywordSet.IsEnabled(LightweightKeywords.Lightmap))
+            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalLightmap) &&
+                !compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.Lightmap))
                 return true;
 
             return false;

com.unity.render-pipelines.lightweight/LWRP/LightweightForwardRenderer.cs

                 EnqueuePass(cmd, RenderPassHandles.LocalShadows, baseDescriptor);
 
             bool requiresDepthAttachment = requiresCameraDepth && !requiresDepthPrepass;
-            bool requiresColorAttachment = RequiresColorAttachment(ref renderingData.cameraData, baseDescriptor) || requiresDepthAttachment;
+            bool requiresColorAttachment = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor, requiresDepthAttachment);
             int[] colorHandles = (requiresColorAttachment) ? new[] {RenderTargetHandles.Color} : null;
             int depthHandle = (requiresColorAttachment) ? RenderTargetHandles.DepthAttachment : -1;
             EnqueuePass(cmd, RenderPassHandles.ForwardLit, baseDescriptor, colorHandles, depthHandle, renderingData.cameraData.msaaSamples);
                 // Note: Scene view camera always perform depth prepass
                 CommandBuffer cmd = CommandBufferPool.Get("Copy Depth to Camera");
                 CoreUtils.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
-                cmd.EnableShaderKeyword(LightweightKeywords.DepthNoMsaa);
-                cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa2);
-                cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa4);
+                cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
+                cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
+                cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
                 cmd.Blit(GetSurface(RenderTargetHandles.DepthTexture), BuiltinRenderTextureType.CameraTarget, GetMaterial(MaterialHandles.DepthCopy));
                 context.ExecuteCommandBuffer(cmd);
                 CommandBufferPool.Release(cmd);
 
         public RenderTargetIdentifier GetSurface(int handle)
         {
+            if (handle == -1)
+                return BuiltinRenderTextureType.CameraTarget;
+
-            if (handle < 0 || !m_ResourceMap.TryGetValue(handle, out renderTargetID))
+            if (!m_ResourceMap.TryGetValue(handle, out renderTargetID))
             {
                 Debug.LogError(string.Format("Handle {0} has not any surface registered to it.", handle));
                 return new RenderTargetIdentifier();
                 m_ActiveRenderPassQueue.Add(pass);
         }
 
-        bool RequiresColorAttachment(ref CameraData cameraData, RenderTextureDescriptor baseDescriptor)
+        bool RequiresIntermediateColorTexture(ref CameraData cameraData, RenderTextureDescriptor baseDescriptor, bool requiresCameraDepth)
+            if (cameraData.isOffscreenRender)
+                return false;
+
-            return cameraData.isSceneViewCamera || isScaledRender || cameraData.isHdrEnabled ||
-                cameraData.postProcessEnabled || cameraData.requiresOpaqueTexture || isTargetTexture2DArray;
+            return requiresCameraDepth || cameraData.isSceneViewCamera || isScaledRender || cameraData.isHdrEnabled ||
+                cameraData.postProcessEnabled || cameraData.requiresOpaqueTexture || isTargetTexture2DArray || !cameraData.isDefaultViewport;
         }
 
         bool CanCopyDepth(ref CameraData cameraData)

com.unity.render-pipelines.lightweight/LWRP/LightweightPipeline.cs

                     context.ExecuteCommandBuffer(cmd);
                     cmd.Clear();
 
+#if UNITY_EDITOR
+#endif
                     {
                         m_IsCameraRendering = true;
 #if UNITY_EDITOR
                         m_Renderer.Setup(ref context, ref m_CullResults, ref renderingData);
                         m_Renderer.Execute(ref context, ref m_CullResults, ref renderingData);
                     }
+#if UNITY_EDITOR
                     catch (Exception)
                     {
                         CommandBufferPool.Release(cmd);
+#endif
                     {
                         m_IsCameraRendering = false;
                     }

com.unity.render-pipelines.lightweight/LWRP/LightweightPipelineCore.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
-using UnityEngine.XR;
 
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
 {
         }
     }
 
-    public static class LightweightKeywords
+    public static class LightweightKeywordStrings
-        public static readonly string AdditionalLightsText = "_ADDITIONAL_LIGHTS";
-        public static readonly string VertexLightsText = "_VERTEX_LIGHTS";
-        public static readonly string MixedLightingSubtractiveText = "_MIXED_LIGHTING_SUBTRACTIVE";
-        public static readonly string MainLightCookieText = "_MAIN_LIGHT_COOKIE";
-        public static readonly string DirectionalShadowsText = "_SHADOWS_ENABLED";
-        public static readonly string LocalShadowsText = "_LOCAL_SHADOWS_ENABLED";
-        public static readonly string SoftShadowsText = "_SHADOWS_SOFT";
-        public static readonly string CascadeShadowsText = "_SHADOWS_CASCADE";
+        public static readonly string AdditionalLights = "_ADDITIONAL_LIGHTS";
+        public static readonly string VertexLights = "_VERTEX_LIGHTS";
+        public static readonly string MixedLightingSubtractive = "_MIXED_LIGHTING_SUBTRACTIVE";
+        public static readonly string MainLightCookie = "_MAIN_LIGHT_COOKIE";
+        public static readonly string DirectionalShadows = "_SHADOWS_ENABLED";
+        public static readonly string LocalShadows = "_LOCAL_SHADOWS_ENABLED";
+        public static readonly string SoftShadows = "_SHADOWS_SOFT";
+        public static readonly string CascadeShadows = "_SHADOWS_CASCADE";
-
-        public static readonly ShaderKeyword AdditionalLights = new ShaderKeyword(AdditionalLightsText);
-        public static readonly ShaderKeyword VertexLights = new ShaderKeyword(VertexLightsText);
-        public static readonly ShaderKeyword MixedLightingSubtractive = new ShaderKeyword(MixedLightingSubtractiveText);
-        public static readonly ShaderKeyword MainLightCookie = new ShaderKeyword(MainLightCookieText);
-        public static readonly ShaderKeyword DirectionalShadows = new ShaderKeyword(DirectionalShadowsText);
-        public static readonly ShaderKeyword LocalShadows = new ShaderKeyword(LocalShadowsText);
-        public static readonly ShaderKeyword SoftShadows = new ShaderKeyword(SoftShadowsText);
-
-        public static readonly ShaderKeyword Lightmap = new ShaderKeyword("LIGHTMAP_ON");
-        public static readonly ShaderKeyword DirectionalLightmap = new ShaderKeyword("DIRLIGHTMAP_COMBINED");
     }
 
     public partial class LightweightPipeline

com.unity.render-pipelines.lightweight/LWRP/Passes/ForwardLitPass.cs

 using System.Diagnostics;
 using UnityEngine.Experimental.GlobalIllumination;
 using UnityEngine.Rendering;
-using UnityEngine.Rendering.PostProcessing;
-using UnityEngine.XR;
 
 namespace UnityEngine.Experimental.Rendering.LightweightPipeline
 {
         {
             int vertexLightsCount = lightData.totalAdditionalLightsCount - lightData.pixelAdditionalLightsCount;
 
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.AdditionalLightsText, lightData.totalAdditionalLightsCount > 0);
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.MixedLightingSubtractiveText, m_MixedLightingSetup == MixedLightingSetup.Subtractive);
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.VertexLightsText, vertexLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.AdditionalLights, lightData.totalAdditionalLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.MixedLightingSubtractive, m_MixedLightingSetup == MixedLightingSetup.Subtractive);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.VertexLights, vertexLightsCount > 0);
-            // CoreUtils.SetKeyword(cmd, LightweightKeywords.MainLightCookieText, mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
+            // CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.MainLightCookieText, mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
 
             LightShadows directionalShadowQuality = shadowData.renderedDirectionalShadowQuality;
             LightShadows localShadowQuality = shadowData.renderedLocalShadowQuality;
                 shadowData.supportsSoftShadows;
 
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.DirectionalShadowsText, directionalShadowQuality != LightShadows.None);
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.LocalShadowsText, localShadowQuality != LightShadows.None);
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.SoftShadowsText, hasSoftShadows);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.DirectionalShadows, directionalShadowQuality != LightShadows.None);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.LocalShadows, localShadowQuality != LightShadows.None);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.SoftShadows, hasSoftShadows);
 
             // TODO: Remove this. legacy particles support will be removed from Unity in 2018.3. This should be a shader_feature instead with prop exposed in the Standard particles shader.
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", cameraData.requiresSoftParticles);
                 ClearFlag clearFlag = GetCameraClearFlag(camera);
                 SetRenderTarget(cmd, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, clearFlag, CoreUtils.ConvertSRGBToActiveColorSpace(camera.backgroundColor));
 
-                // If rendering to an intermediate RT we resolve viewport on blit due to offset not being supported
-                // while rendering to a RT.
-                if (colorAttachmentHandle == -1 && cameraData.isDefaultViewport)
-                    cmd.SetViewport(camera.pixelRect);
+                // TODO: We need a proper way to handle multiple camera/ camera stack. Issue is: multiple cameras can share a same RT
+                // (e.g, split screen games). However devs have to be dilligent with it and know when to clear/preserve color.
+                // For now we make it consistent by resolving viewport with a RT until we can have a proper camera management system
+                //if (colorAttachmentHandle == -1 && !cameraData.isDefaultViewport)
+                //    cmd.SetViewport(camera.pixelRect);
 
                 context.ExecuteCommandBuffer(cmd);
                 cmd.Clear();
             CommandBuffer cmd = CommandBufferPool.Get("Final Blit Pass");
             cmd.SetGlobalTexture("_BlitTex", sourceRT);
 
+            // We need to handle viewport on a RT. We do it by rendering a fullscreen quad + viewport
-                SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.All, Color.black);
+                SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.None, Color.black);
                 cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
                 cmd.SetViewport(cameraData.camera.pixelRect);
                 LightweightPipeline.DrawFullScreen(cmd, material);
 
             if (cameraData.msaaSamples > 1)
             {
-                cmd.DisableShaderKeyword(LightweightKeywords.DepthNoMsaa);
+                cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
-                    cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa2);
-                    cmd.EnableShaderKeyword(LightweightKeywords.DepthMsaa4);
+                    cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
+                    cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
-                    cmd.EnableShaderKeyword(LightweightKeywords.DepthMsaa2);
-                    cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa4);
+                    cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
+                    cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
-                cmd.EnableShaderKeyword(LightweightKeywords.DepthNoMsaa);
-                cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa2);
-                cmd.DisableShaderKeyword(LightweightKeywords.DepthMsaa4);
+                cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
+                cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
+                cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
                 LightweightPipeline.CopyTexture(cmd, depthSurface, copyDepthSurface, m_DepthCopyMaterial);
             }
             context.ExecuteCommandBuffer(cmd);

com.unity.render-pipelines.lightweight/LWRP/Passes/ScreenSpaceShadowResolvePass.cs

 {
     public class ScreenSpaceShadowResolvePass : ScriptableRenderPass
     {
-        public bool softShadows { get; set; }
-
         RenderTextureFormat m_ColorFormat;
         Material m_ScreenSpaceShadowsMaterial;
 
                 : RenderTextureFormat.ARGB32;
 
             m_ScreenSpaceShadowsMaterial = renderer.GetMaterial(MaterialHandles.ScrenSpaceShadow);
-            softShadows = false;
         }
 
         public override void Setup(CommandBuffer cmd, RenderTextureDescriptor baseDescriptor, int[] colorAttachmentHandles, int depthAttachmentHandle = -1, int samples = 1)
                 return;
 
             CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
-            SetShadowCollectPassKeywords(cmd, renderingData.shadowData.directionalLightCascadeCount);
+            SetShadowCollectPassKeywords(cmd, ref renderingData.shadowData);
 
             // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
             // doesn't like null sources when trying to determine a stereo-ized blit.  So for proper
             CommandBufferPool.Release(cmd);
         }
 
-        void SetShadowCollectPassKeywords(CommandBuffer cmd, int cascadeCount)
+        void SetShadowCollectPassKeywords(CommandBuffer cmd, ref ShadowData shadowData)
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.SoftShadowsText, softShadows);
-            CoreUtils.SetKeyword(cmd, LightweightKeywords.CascadeShadowsText, cascadeCount > 1);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.SoftShadows, shadowData.renderedDirectionalShadowQuality == LightShadows.Soft);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.CascadeShadows, shadowData.directionalLightCascadeCount > 1);
         }
     }
 }

com.unity.render-pipelines.lightweight/LWRP/Passes/ScriptableRenderPass.cs

 
         public TextureDimension textureDimension { get; private set; }
 
-        protected List<ShaderPassName> m_ShaderPassNames = new List<ShaderPassName>();
+        public int samples { get; private set; }
-        int samples;
+        protected List<ShaderPassName> m_ShaderPassNames = new List<ShaderPassName>();
 
         public ScriptableRenderPass(LightweightForwardRenderer renderer)
         {