Merge branch '2018.1' into projects/system-shock/2018.1

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugState.cs

         [SerializeField]
         protected string m_QueryPath;
 
+        // We need this to keep track of the state modified in the current frame.
+        // This helps reduces the cost of re-applying states to original widgets and is also needed
+        // when two states point to the same value (e.g. when using split enums like HDRP does for
+        // the `fullscreenDebugMode`.
+        internal static DebugState m_CurrentDirtyState;
+
         public string queryPath
         {
             get { return m_QueryPath; }

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugUIDrawer.Builtins.cs

+using System;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
 
             EditorGUI.BeginChangeCheck();
 
             var rect = PrepareControlRect();
-            bool value = EditorGUI.Toggle(rect, CoreEditorUtils.GetContent(w.displayName), s.value);
+            bool value = EditorGUI.Toggle(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
 
             var rect = PrepareControlRect();
             int value = w.min != null && w.max != null
-                ? EditorGUI.IntSlider(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.min(), w.max())
-                : EditorGUI.IntField(rect, CoreEditorUtils.GetContent(w.displayName), s.value);
+                ? EditorGUI.IntSlider(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue(), w.min(), w.max())
+                : EditorGUI.IntField(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
             // No UIntField so we need to max to 0 ourselves or the value will wrap around
             var rect = PrepareControlRect();
             int tmp = w.min != null && w.max != null
-                ? EditorGUI.IntSlider(rect, CoreEditorUtils.GetContent(w.displayName), Mathf.Max(0, (int)s.value), Mathf.Max(0, (int)w.min()), Mathf.Max(0, (int)w.max()))
-                : EditorGUI.IntField(rect, CoreEditorUtils.GetContent(w.displayName), Mathf.Max(0, (int)s.value));
+                ? EditorGUI.IntSlider(rect, CoreEditorUtils.GetContent(w.displayName), Mathf.Max(0, (int)w.GetValue()), Mathf.Max(0, (int)w.min()), Mathf.Max(0, (int)w.max()))
+                : EditorGUI.IntField(rect, CoreEditorUtils.GetContent(w.displayName), Mathf.Max(0, (int)w.GetValue()));
 
             uint value = (uint)Mathf.Max(0, tmp);
 
 
             var rect = PrepareControlRect();
             float value = w.min != null && w.max != null
-                ? EditorGUI.Slider(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.min(), w.max())
-                : EditorGUI.FloatField(rect, CoreEditorUtils.GetContent(w.displayName), s.value);
+                ? EditorGUI.Slider(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue(), w.min(), w.max())
+                : EditorGUI.FloatField(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
 
             EditorGUI.BeginChangeCheck();
 
-            int value = s.value;
+            int value = w.GetValue();
             if (w.enumNames == null || w.enumValues == null)
             {
                 EditorGUILayout.LabelField("Can't draw an empty enumeration.");
                 var rect = PrepareControlRect();
-                value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.enumNames, w.enumValues);
+
+                int index = Array.IndexOf(w.enumValues, w.GetValue());
+
+                // Fallback just in case, we may be handling sub/sectionned enums here
+                if (index < 0)
+                    value = w.enumValues[0];
+
+                value = EditorGUI.IntPopup(rect, CoreEditorUtils.GetContent(w.displayName), value, w.enumNames, w.enumValues);
             }
 
             if (EditorGUI.EndChangeCheck())
 
             EditorGUI.BeginChangeCheck();
 
-            bool value = EditorGUILayout.Foldout(s.value, CoreEditorUtils.GetContent(w.displayName), true);
+            bool value = EditorGUILayout.Foldout(w.GetValue(), CoreEditorUtils.GetContent(w.displayName), true);
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
             EditorGUI.BeginChangeCheck();
 
             var rect = PrepareControlRect();
-            var value = EditorGUI.ColorField(rect, CoreEditorUtils.GetContent(w.displayName), s.value, w.showPicker, w.showAlpha, w.hdr);
+            var value = EditorGUI.ColorField(rect, CoreEditorUtils.GetContent(w.displayName), w.GetValue(), w.showPicker, w.showAlpha, w.hdr);
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
 
             EditorGUI.BeginChangeCheck();
 
-            var value = EditorGUILayout.Vector2Field(w.displayName, s.value);
+            var value = EditorGUILayout.Vector2Field(w.displayName, w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
 
             EditorGUI.BeginChangeCheck();
 
-            var value = EditorGUILayout.Vector3Field(w.displayName, s.value);
+            var value = EditorGUILayout.Vector3Field(w.displayName, w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);
 
             EditorGUI.BeginChangeCheck();
 
-            var value = EditorGUILayout.Vector4Field(w.displayName, s.value);
+            var value = EditorGUILayout.Vector4Field(w.displayName, w.GetValue());
 
             if (EditorGUI.EndChangeCheck())
                 Apply(w, s, value);

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugUIDrawer.cs

             state.SetValue(value, widget);
             widget.SetValue(value);
             EditorUtility.SetDirty(state);
+            DebugState.m_CurrentDirtyState = state;
             UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
         }
 

ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugWindow.cs

         void OnDestroy()
         {
             DebugManager.instance.onSetDirty -= MarkDirty;
+            Undo.ClearUndo(m_Settings);
 
             if (m_WidgetStates != null)
             {
             }
         }
 
-        public void ApplyStates()
+        public void ApplyStates(bool forceApplyAll = false)
+            if (!forceApplyAll && DebugState.m_CurrentDirtyState != null)
+            {
+                ApplyState(DebugState.m_CurrentDirtyState.queryPath, DebugState.m_CurrentDirtyState);
+                DebugState.m_CurrentDirtyState = null;
+                return;
+            }
+
-            {
-                var widget = DebugManager.instance.GetItem(state.Key) as DebugUI.IValueField;
+                ApplyState(state.Key, state.Value);
+
+            DebugState.m_CurrentDirtyState = null;
+        }
+
+        void ApplyState(string queryPath, DebugState state)
+        {
+            var widget = DebugManager.instance.GetItem(queryPath) as DebugUI.IValueField;
-                if (widget == null)
-                    continue;
+            if (widget == null)
+                return;
-                widget.SetValue(state.Value.GetValue());
-            }
+            widget.SetValue(state.GetValue());
         }
 
         void OnUndoRedoPerformed()
             // Something has been undone / redone, re-apply states to the debug tree
             if (stateHash != m_Settings.currentStateHash)
             {
-                ApplyStates();
+                ApplyStates(true);
                 m_Settings.currentStateHash = stateHash;
             }
 
                         if (m_Settings.selectedPanel == i && Event.current.type == EventType.Repaint)
                             s_Styles.selected.Draw(elementRect, false, false, false, false);
 
-                        if (GUI.Toggle(elementRect, m_Settings.selectedPanel == i, panel.displayName, s_Styles.sectionElement))
+                        EditorGUI.BeginChangeCheck();
+                        GUI.Toggle(elementRect, m_Settings.selectedPanel == i, panel.displayName, s_Styles.sectionElement);
+                        if (EditorGUI.EndChangeCheck())
-                            Undo.RecordObject(m_Settings, "Debug Panel Selection");
+                            Undo.RegisterCompleteObjectUndo(m_Settings, "Debug Panel Selection");
                             m_Settings.selectedPanel = i;
                         }
                     }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Packing.hlsl

     return normalize(normal);
 }
 
+real3 UnpackNormalRGBNoScale(real4 packedNormal)
+{
+    return packedNormal.rgb * 2.0 - 1.0;
+}
+
 real3 UnpackNormalAG(real4 packedNormal, real scale = 1.0)
 {
     real3 normal;

ScriptableRenderPipeline/Core/package.json

 {
     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
-    "version": "1.1.1-preview",
+    "version": "1.1.2-preview",
-        "com.unity.postprocessing": "2.0.2-preview"
+        "com.unity.postprocessing": "2.0.3-preview"
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs

                 UpdateLightIntensity();
             }
 
+            settings.DrawBounceIntensity();
+
             settings.DrawLightmapping();
 
             EditorGUI.BeginChangeCheck(); // For GI we need to detect any change on additional data and call SetLightDirty

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs

 
         static void Drawer_AdditionalSettings(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
         {
-            EditorGUILayout.PropertyField(p.dimmer);
+            EditorGUILayout.PropertyField(p.weight);
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(p.multiplier);
+            if (EditorGUI.EndChangeCheck())
+                p.multiplier.floatValue = Mathf.Max(0.0f, p.multiplier.floatValue);
 
             if (p.so.targetObjects.Length == 1)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

 
         static void Drawer_SectionInfluenceSettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
         {
-            EditorGUILayout.PropertyField(d.dimmer, _.GetContent("Dimmer"));
+            EditorGUILayout.PropertyField(d.weight, _.GetContent("Weight"));
+           
+
+            EditorGUI.BeginChangeCheck();
+            EditorGUILayout.PropertyField(d.multiplier, _.GetContent("Multiplier"));
+            if (EditorGUI.EndChangeCheck())
+                d.multiplier.floatValue = Mathf.Max(0.0f, d.multiplier.floatValue);
         }
 
         static void Drawer_FieldCaptureType(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/SerializedHDReflectionProbe.cs

         internal SerializedProperty blendNormalDistanceNegative;
         internal SerializedProperty boxSideFadePositive;
         internal SerializedProperty boxSideFadeNegative;
-        internal SerializedProperty dimmer;
+        internal SerializedProperty weight;
+        internal SerializedProperty multiplier;
 
         internal SerializedProperty proxyVolumeComponent;
 
             boxReprojectionVolumeSize = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeSize);
             boxReprojectionVolumeCenter = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeCenter);
             sphereReprojectionVolumeRadius = addso.Find((HDAdditionalReflectionData d) => d.sphereReprojectionVolumeRadius);
-            dimmer = addso.Find((HDAdditionalReflectionData d) => d.dimmer);
+            weight = addso.Find((HDAdditionalReflectionData d) => d.weight);
+            multiplier = addso.Find((HDAdditionalReflectionData d) => d.multiplier);
             blendDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendDistancePositive);
             blendDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendDistanceNegative);
             blendNormalDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistancePositive);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/SerializedPlanarReflectionProbe.cs

         public SerializedProperty capturePositionMode;
         public SerializedProperty captureMirrorPlaneLocalPosition;
         public SerializedProperty captureMirrorPlaneLocalNormal;
-        public SerializedProperty dimmer;
+        public SerializedProperty weight;
+        public SerializedProperty multiplier;
         public SerializedProperty mode;
         public SerializedProperty refreshMode;
         public SerializedProperty customTexture;
             capturePositionMode = serializedObject.Find((PlanarReflectionProbe p) => p.capturePositionMode);
             captureMirrorPlaneLocalPosition = serializedObject.Find((PlanarReflectionProbe p) => p.captureMirrorPlaneLocalPosition);
             captureMirrorPlaneLocalNormal = serializedObject.Find((PlanarReflectionProbe p) => p.captureMirrorPlaneLocalNormal);
-            dimmer = serializedObject.Find((PlanarReflectionProbe p) => p.dimmer);
+            weight = serializedObject.Find((PlanarReflectionProbe p) => p.weight);
+            multiplier = serializedObject.Find((PlanarReflectionProbe p) => p.multiplier);
             mode = serializedObject.Find((PlanarReflectionProbe p) => p.mode);
             refreshMode = serializedObject.Find((PlanarReflectionProbe p) => p.refreshMode);
             customTexture = serializedObject.Find((PlanarReflectionProbe p) => p.customTexture);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/LitUI.cs

                     float amplitude = (heightMax[layerIndex].floatValue - heightMin[layerIndex].floatValue);
 
                     heightAmplitude[layerIndex].floatValue = amplitude * 0.01f; // Conversion centimeters to meters.
-                    heightCenter[layerIndex].floatValue = -(heightMin[layerIndex].floatValue + offset) / amplitude;
+                    heightCenter[layerIndex].floatValue = -(heightMin[layerIndex].floatValue + offset) / Mathf.Max(1e-6f, amplitude);
-                    heightCenter[layerIndex].floatValue = -heightOffset[layerIndex].floatValue / amplitude + heightTessCenter[layerIndex].floatValue;
+                    heightCenter[layerIndex].floatValue = -heightOffset[layerIndex].floatValue / Mathf.Max(1e-6f, amplitude) + heightTessCenter[layerIndex].floatValue;
                 }
             }
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

         protected const string kEnableMotionVectorForVertexAnimation = "_EnableMotionVectorForVertexAnimation";
 
         protected const string kZTestDepthEqualForOpaque = "_ZTestDepthEqualForOpaque";
+        protected const string kZTestGBuffer = "_ZTestGBuffer";
         protected const string kZTestModeDistortion = "_ZTestModeDistortion";
 
         // See comment in LitProperties.hlsl
             CoreUtils.SetKeyword(material, "_BLENDMODE_ALPHA", false);
             CoreUtils.SetKeyword(material, "_BLENDMODE_ADD", false);
             CoreUtils.SetKeyword(material, "_BLENDMODE_PRE_MULTIPLY", false);
+
+            // Alpha tested materials always have a prepass where we perform the clip.
+            // Then during Gbuffer pass we don't perform the clip test, so we need to use depth equal in this case.
+            if (alphaTestEnable)
+            {
+                material.SetInt(kZTestGBuffer, (int)UnityEngine.Rendering.CompareFunction.Equal);
+            }
+            else
+            {
+                material.SetInt(kZTestGBuffer, (int)UnityEngine.Rendering.CompareFunction.LessEqual);
+            }
 
             // If the material use the kZTestDepthEqualForOpaque it mean it require depth equal test for opaque but transparent are not affected
             if (material.HasProperty(kZTestDepthEqualForOpaque))

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/FrameSettingsUI.cs

                 CED.FadeGroup(
                     (s, d, o, i) => s.isSectionExpandedUseForwardOnly,
                     FadeOption.None,
-                    CED.Action(Drawer_FieldUseDepthPrepassWithDefferedRendering),
-                    CED.FadeGroup(
-                        (s, d, o, i) => s.isSectionExpandedUseDepthPrepass,
-                        FadeOption.Indent,
-                        CED.Action(Drawer_FieldRenderAlphaTestOnlyInDeferredPrepass))),
+                    CED.Action(Drawer_FieldUseDepthPrepassWithDefferedRendering)
+                    ),
                 CED.Action(Drawer_SectionOtherRenderingSettings)
             )
         );
         public AnimBool isSectionExpandedXRSettings { get { return m_AnimBools[3]; } }
         public AnimBool isSectionExpandedXRSupported { get { return m_AnimBools[4]; } }
         public AnimBool isSectionExpandedUseForwardOnly { get { return m_AnimBools[5]; } }
-        public AnimBool isSectionExpandedUseDepthPrepass { get { return m_AnimBools[6]; } }
 
         public LightLoopSettingsUI lightLoopSettings = new LightLoopSettingsUI();
 
         {
             isSectionExpandedXRSupported.target = PlayerSettings.virtualRealitySupported;
             isSectionExpandedUseForwardOnly.target = !data.enableForwardRenderingOnly.boolValue;
-            isSectionExpandedUseDepthPrepass.target = data.enableDepthPrepassWithDeferredRendering.boolValue;
             lightLoopSettings.Update();
         }
 
         static void Drawer_FieldUseDepthPrepassWithDefferedRendering(FrameSettingsUI s, SerializedFrameSettings p, Editor owner)
         {
             EditorGUILayout.PropertyField(p.enableDepthPrepassWithDeferredRendering, _.GetContent("Enable Depth Prepass With Deferred Rendering"));
-        }
-
-        static void Drawer_FieldRenderAlphaTestOnlyInDeferredPrepass(FrameSettingsUI s, SerializedFrameSettings p, Editor owner)
-        {
-            EditorGUILayout.PropertyField(p.enableAlphaTestOnlyInDeferredPrepass, _.GetContent("Enable Alpha Test Only In Deferred Prepass"));
         }
 
         static void Drawer_SectionOtherRenderingSettings(FrameSettingsUI s, SerializedFrameSettings p, Editor owner)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/LightLoopSettingsUI.cs

 
         static void Drawer_SectionLightLoopSettings(LightLoopSettingsUI s, SerializedLightLoopSettings p, Editor owner)
         {
-            EditorGUILayout.PropertyField(p.enableTileAndCluster, _.GetContent("Enable Tile And Cluster"));
+            // Uncomment if you re-enable LIGHTLOOP_SINGLE_PASS multi_compile in lit*.shader
+            //EditorGUILayout.PropertyField(p.enableTileAndCluster, _.GetContent("Enable Tile And Cluster"));
+            //EditorGUI.indentLevel++;
+
-                EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(p.enableFptlForForwardOpaque, _.GetContent("Enable FPTL For Forward Opaque"));
                 EditorGUILayout.PropertyField(p.enableBigTilePrepass, _.GetContent("Enable Big Tile Prepass"));
                 EditorGUILayout.PropertyField(p.enableComputeLightEvaluation, _.GetContent("Enable Compute Light Evaluation"));
                 }
                 EditorGUILayout.EndFadeGroup();
                 GUILayout.EndVertical();
-                EditorGUI.indentLevel--;
+
+            //EditorGUI.indentLevel--;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedFrameSettings.cs

 
         public SerializedProperty enableForwardRenderingOnly;
         public SerializedProperty enableDepthPrepassWithDeferredRendering;
-        public SerializedProperty enableAlphaTestOnlyInDeferredPrepass;
 
         public SerializedProperty enableTransparentPrepass;
         public SerializedProperty enableMotionVectors;
             specularGlobalDimmer = root.Find((FrameSettings d) => d.specularGlobalDimmer);
             enableForwardRenderingOnly = root.Find((FrameSettings d) => d.enableForwardRenderingOnly);
             enableDepthPrepassWithDeferredRendering = root.Find((FrameSettings d) => d.enableDepthPrepassWithDeferredRendering);
-            enableAlphaTestOnlyInDeferredPrepass = root.Find((FrameSettings d) => d.enableAlphaTestOnlyInDeferredPrepass);
             enableTransparentPrepass = root.Find((FrameSettings d) => d.enableTransparentPrepass);
             enableMotionVectors = root.Find((FrameSettings d) => d.enableMotionVectors);
             enableObjectMotionVectors = root.Find((FrameSettings d) => d.enableObjectMotionVectors);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

         }
 
         RenderStateBlock m_DepthStateOpaque;
-        RenderStateBlock m_DepthStateOpaqueWithPrepass;
 
         // Detect when windows size is changing
         int m_CurrentWidth;
                 supportedLightmapsModes = LightmapsMode.NonDirectional | LightmapsMode.CombinedDirectional,
                 rendererSupportsLightProbeProxyVolumes = true,
                 rendererSupportsMotionVectors = true,
-                rendererSupportsReceiveShadows = true,
+                rendererSupportsReceiveShadows = false,
                 rendererSupportsReflectionProbes = true
             };
 
             m_DepthStateOpaque = new RenderStateBlock
             {
                 depthState = new DepthState(true, CompareFunction.LessEqual),
-                mask = RenderStateMask.Depth
-            };
-
-            // When doing a prepass, we don't need to write the depth anymore.
-            // Moreover, we need to use DepthEqual because for alpha tested materials we don't do the clip in the shader anymore (otherwise HiZ does not work on PS4)
-            m_DepthStateOpaqueWithPrepass = new RenderStateBlock
-            {
-                depthState = new DepthState(false, CompareFunction.Equal),
                 mask = RenderStateMask.Depth
             };
         }
             }
         }
 
+        bool IsConsolePlatform()
+        {
+            return  SystemInfo.graphicsDeviceType == GraphicsDeviceType.PlayStation4 ||
+                    SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOne ||
+                    SystemInfo.graphicsDeviceType == GraphicsDeviceType.XboxOneD3D12;
+        }
+
-            // For now we consider only PS4 to be able to read from a bound depth buffer.
-            // TODO: test/implement for other platforms.
-            return SystemInfo.graphicsDeviceType != GraphicsDeviceType.PlayStation4 &&
-                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOne &&
-                    SystemInfo.graphicsDeviceType != GraphicsDeviceType.XboxOneD3D12;
+            // For now we consider all console to be able to read from a bound depth buffer.
+            return !IsConsolePlatform();
         }
 
         bool NeedStencilBufferCopy()
 
         // RenderDepthPrepass render both opaque and opaque alpha tested based on engine configuration.
         // Forward only renderer: We always render everything
-        // Deferred renderer: We render a depth prepass only if engine request it. We can decide if we render everything or only opaque alpha tested object.
+        // Deferred renderer: We always render depth prepass for alpha tested (optimization), other object are render based on engine configuration.
         // Forward opaque with deferred renderer (DepthForwardOnly pass): We always render everything
         void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool forcePrepass)
         {
             // Guidelines: In deferred by default there is no opaque in forward. However it is possible to force an opaque material to render in forward
             // by using the pass "ForwardOnly". In this case the .shader should not have "Forward" but only a "ForwardOnly" pass.
             // It must also have a "DepthForwardOnly" and no "DepthOnly" pass as forward material (either deferred or forward only rendering) have always a depth pass.
-
-            // In case of forward only rendering we have a depth prepass. In case of deferred renderer, it is optional
-            bool addFullDepthPrepass = m_FrameSettings.enableForwardRenderingOnly || m_FrameSettings.enableDepthPrepassWithDeferredRendering;
-            bool addAlphaTestedOnly = !m_FrameSettings.enableForwardRenderingOnly && m_FrameSettings.enableDepthPrepassWithDeferredRendering && m_FrameSettings.enableAlphaTestOnlyInDeferredPrepass;
+            // If a forward material have no depth prepass, then lighting can be incorrect (deferred sahdowing, SSAO), this may be acceptable depends on usage
+            bool addFullDepthPrepass = forcePrepass || m_FrameSettings.enableForwardRenderingOnly || m_FrameSettings.enableDepthPrepassWithDeferredRendering;
-            using (new ProfilingSample(cmd, addAlphaTestedOnly ? "Depth Prepass alpha test" : "Depth Prepass", CustomSamplerId.DepthPrepass.GetSampler()))
+            using (new ProfilingSample(cmd, !addFullDepthPrepass ? "Depth Prepass alpha test" : "Depth Prepass", CustomSamplerId.DepthPrepass.GetSampler()))
-                if (forcePrepass || (addFullDepthPrepass && !addAlphaTestedOnly)) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
+                if (addFullDepthPrepass) // Always true in case of forward rendering, use in case of deferred rendering if requesting a full depth prepass
                 {
                     // We render first the opaque object as opaque alpha tested are more costly to render and could be reject by early-z (but not Hi-z as it is disable with clip instruction)
                     // This is handled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
                     // We always do a DepthForwardOnly pass with all the opaque (including alpha test)
                     RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthForwardOnlyPassNames, 0, HDRenderQueue.k_RenderQueue_AllOpaque);
 
-                    // Render Alpha test only if requested
-                    if (addAlphaTestedOnly)
-                    {
-                        var renderQueueRange = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthOnlyPassNames, 0, renderQueueRange);
-                    }
+                    // Alpha tested materials always have a prepass.
+                    var renderQueueRange = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthOnlyPassNames, 0, renderQueueRange);
                 }
             }
 
             {
                 // setup GBuffer for rendering
                 HDUtils.SetRenderTarget(cmd, hdCamera, m_GbufferManager.GetBuffersRTI(enableShadowMask), m_CameraDepthStencilBuffer);
-
-                // Render opaque objects into GBuffer
-                if (m_FrameSettings.enableDepthPrepassWithDeferredRendering)
-                {
-                    // When using depth prepass for opaque alpha test only we need to use regular depth test for normal opaque objects.
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_OpaqueNoAlphaTest, m_FrameSettings.enableAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
-                    // but for opaque alpha tested object we use a depth equal and no depth write. And we rely on the shader pass GbufferWithDepthPrepass
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_OpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
-                }
-                else
-                {
-                    // No depth prepass, use regular depth test - Note that we will render opaque then opaque alpha tested (based on the RenderQueue system)
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_AllOpaque, m_DepthStateOpaque);
-                }
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_AllOpaque);
 
                 m_GbufferManager.BindBufferAsTextures(cmd);
             }
             {
                 RenderTargetIdentifier source = m_CameraColorBuffer;
 
-#if UNITY_EDITOR
-                bool tempHACK = true;
-#else
-                // In theory in the player the only place where we have post process is the main camera with the RTHandle reference size, so we won't need to copy.
-                bool tempHACK = false;
-#endif
+                // For console we are not allowed to resize the windows, so don't use our hack.
+                bool tempHACK = !IsConsolePlatform();
+
                 if (tempHACK)
                 {
                     // TEMPORARY:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset

     specularGlobalDimmer: 1
     enableForwardRenderingOnly: 0
     enableDepthPrepassWithDeferredRendering: 0
-    enableAlphaTestOnlyInDeferredPrepass: 0
     enableTransparentPrepass: 1
     enableMotionVectors: 1
     enableObjectMotionVectors: 1

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs

 
         public Vector3 boxSideFadePositive;
         public Vector3 boxSideFadeNegative;
-        public float dimmer;
-        public float unused01;
+        public float weight;
+        public float multiplier;
 
         public Vector3 sampleDirectionDiscardWS;
         // Sampling properties

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightDefinition.cs.hlsl

     float3 blendNormalDistanceNegative;
     float3 boxSideFadePositive;
     float3 boxSideFadeNegative;
-    float dimmer;
-    float unused01;
+    float weight;
+    float multiplier;
     float3 sampleDirectionDiscardWS;
     int envIndex;
 };
 {
 	return value.boxSideFadeNegative;
 }
-float GetDimmer(EnvLightData value)
+float GetWeight(EnvLightData value)
-	return value.dimmer;
+	return value.weight;
-float GetUnused01(EnvLightData value)
+float GetMultiplier(EnvLightData value)
-	return value.unused01;
+	return value.multiplier;
 }
 float3 GetSampleDirectionDiscardWS(EnvLightData value)
 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

 
 
             envLightData.influenceShapeType = probe.influenceShapeType;
-            envLightData.dimmer = probe.dimmer;
+            envLightData.weight = probe.weight;
+            envLightData.multiplier = probe.multiplier;
             envLightData.influenceExtents = probe.influenceExtents;
             envLightData.blendNormalDistancePositive = probe.blendNormalDistancePositive;
             envLightData.blendNormalDistanceNegative = probe.blendNormalDistanceNegative;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoopSettings.cs

                     displayName = "Lighting Settings",
                     children =
                     {
+                        // Uncomment if you re-enable LIGHTLOOP_SINGLE_PASS multi_compile in lit*.shader
+                        //new DebugUI.BoolField { displayName = "Enable Tile/Cluster", getter = () => lightLoopSettings.enableTileAndCluster, setter = value => lightLoopSettings.enableTileAndCluster = value },
-                        new DebugUI.BoolField { displayName = "Enable Tile/Cluster", getter = () => lightLoopSettings.enableTileAndCluster, setter = value => lightLoopSettings.enableTileAndCluster = value },
                         new DebugUI.BoolField { displayName = "Enable Big Tile", getter = () => lightLoopSettings.enableBigTilePrepass, setter = value => lightLoopSettings.enableBigTilePrepass = value },
                         new DebugUI.BoolField { displayName = "Enable Compute Lighting", getter = () => lightLoopSettings.enableComputeLightEvaluation, setter = value => lightLoopSettings.enableComputeLightEvaluation = value },
                         new DebugUI.BoolField { displayName = "Enable Light Classification", getter = () => lightLoopSettings.enableComputeLightVariants, setter = value => lightLoopSettings.enableComputeLightVariants = value },

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtilities.hlsl

     output.influenceRight = float3(1.0, 0.0, 0.0);
     output.influencePositionWS = float3(0.0, 0.0, 0.0);
 
-    output.dimmer = 1.0;
+    output.weight = 1.0;
+    output.multiplier = 1.0;
 
     // proxy
     output.proxyForward = float3(0.0, 0.0, 1.0);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/HDAdditionalReflectionData.cs

-using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEngine.Serialization;
+using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEngine.Experimental.Rendering
 {
 #pragma warning restore 414
 
         public ShapeType influenceShape;
-        [Range(0.0f,1.0f)]
-        public float dimmer = 1.0f;
+        [FormerlySerializedAsAttribute("dimmer")]
+        public float multiplier = 1.0f;
+        [Range(0.0f, 1.0f)]
+        public float weight = 1.0f;
         public float influenceSphereRadius = 3.0f;
         public float sphereReprojectionVolumeRadius = 1.0f;
         public bool useSeparateProjectionVolume = false;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/PlanarReflectionProbe.cs

-using UnityEngine.Rendering;
+using UnityEngine.Serialization;
+using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         [SerializeField]
         Vector3 m_CaptureLocalPosition;
         [SerializeField]
-        [Range(0, 1)]
-        float m_Dimmer = 1;
+        [FormerlySerializedAsAttribute("m_Dimmer")]
+        float m_Multiplier = 1.0f;
+        [SerializeField]
+        [Range(0.0f, 1.0f)]
+        float m_Weight = 1.0f;
         [SerializeField]
         ReflectionProbeMode m_Mode = ReflectionProbeMode.Baked;
         [SerializeField]
         }
         public Bounds bounds { get { return m_InfluenceVolume.GetBoundsAt(transform); } }
         public Vector3 captureLocalPosition { get { return m_CaptureLocalPosition; } set { m_CaptureLocalPosition = value; } }
-        public float dimmer { get { return m_Dimmer; } }
+        public float weight { get { return m_Weight; } }
+        public float multiplier { get { return m_Multiplier; } }
         public ReflectionProbeMode mode { get { return m_Mode; } }
         public Matrix4x4 influenceToWorld
         {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ProbeWrapper.cs

         public abstract ReflectionProbeMode mode { get; }
         public abstract Texture texture { get; }
         // Position of the center of the probe in capture space
-        public abstract float dimmer { get; }
+        public abstract float weight { get; }
+        public abstract float multiplier { get; }
         public abstract Matrix4x4 influenceToWorld { get; }
         public abstract EnvShapeType influenceShapeType { get; }
         public abstract Vector3 influenceExtents { get; }
         public override Texture texture { get { return probe.texture; } }
         public override ReflectionProbeMode mode { get { return probe.probe.mode; } }
         public override EnvShapeType influenceShapeType { get { return ConvertShape(additional.influenceShape); } }
-        public override float dimmer { get { return additional.dimmer; } }
+        public override float weight { get { return additional.weight; } }
+        public override float multiplier { get { return additional.multiplier; } }
         public override Vector3 influenceExtents
         {
             get
         public override Matrix4x4 influenceToWorld { get { return planarReflectionProbe.influenceToWorld; } }
         public override Texture texture { get { return planarReflectionProbe.texture; } }
         public override EnvShapeType influenceShapeType { get { return ConvertShape(planarReflectionProbe.influenceVolume.shapeType); } }
-        public override float dimmer { get { return planarReflectionProbe.dimmer; } }
+        public override float weight { get { return planarReflectionProbe.weight; } }
+        public override float multiplier { get { return planarReflectionProbe.multiplier; } }
         public override Vector3 influenceExtents
         {
             get

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLit.shader

         [HideInInspector] _ZWrite ("__zw", Float) = 1.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
+        [HideInInspector] _ZTestGBuffer("_ZTestGBuffer", Int) = 4
 
         [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
         [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
+            ZTest[_ZTestGBuffer]
 
             Stencil
             {
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
 
-            #define SHADERPASS SHADERPASS_GBUFFER
-            #include "../../ShaderVariables.hlsl"
-            #ifdef DEBUG_DISPLAY
-            #include "../../Debug/DebugDisplay.hlsl"
-            #endif
-            #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitSharePass.hlsl"
-            #include "LayeredLitData.hlsl"
-            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
-
-            ENDHLSL
-        }
-
-        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
-        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
-        Pass
-        {
-            Name "GBufferWithPrepass"  // Name is not used
-            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
-
-            Cull [_CullMode]
-
-            Stencil
-            {
-                WriteMask [_StencilWriteMask]
-                Ref [_StencilRef]
-                Comp Always
-                Pass Replace
-            }
-
-            HLSLPROGRAM
-
-            #pragma multi_compile _ DEBUG_DISPLAY
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
-            #pragma multi_compile _ SHADOWS_SHADOWMASK
+        #ifdef _ALPHATEST_ON
+            // When we have alpha test, we will force a depth prepass so we always bypass the clip instruction in the GBuffer
+            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST 
+        #endif
-            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             #ifdef DEBUG_DISPLAY
             #include "../../Debug/DebugDisplay.hlsl"
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

         [HideInInspector] _ZWrite ("__zw", Float) = 1.0
         [HideInInspector] _CullMode("__cullmode", Float) = 2.0
         [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
+        [HideInInspector] _ZTestGBuffer("_ZTestGBuffer", Int) = 4
 
         [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
         [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
+            ZTest[_ZTestGBuffer]
 
             Stencil
             {
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
 
-            #define SHADERPASS SHADERPASS_GBUFFER
-            #include "../../ShaderVariables.hlsl"
-            #ifdef DEBUG_DISPLAY
-            #include "../../Debug/DebugDisplay.hlsl"
-            #endif
-            #include "../../Material/Material.hlsl"
-            #include "../Lit/ShaderPass/LitSharePass.hlsl"
-            #include "LayeredLitData.hlsl"
-            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
-
-            ENDHLSL
-        }
-
-        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
-        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
-        Pass
-        {
-            Name "GBufferWithPrepass"  // Name is not used
-            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
-
-            Cull [_CullMode]
-
-            Stencil
-            {
-                WriteMask [_StencilWriteMask]
-                Ref [_StencilRef]
-                Comp Always
-                Pass Replace
-            }
-
-            HLSLPROGRAM
-
-            #pragma hull Hull
-            #pragma domain Domain
-
-            #pragma multi_compile _ DEBUG_DISPLAY
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
-            #pragma multi_compile _ SHADOWS_SHADOWMASK
+        #ifdef _ALPHATEST_ON
+            // When we have alpha test, we will force a depth prepass so we always bypass the clip instruction in the GBuffer
+            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST 
+        #endif
-            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
             #include "../../ShaderVariables.hlsl"
             #ifdef DEBUG_DISPLAY
             #include "../../Debug/DebugDisplay.hlsl"
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 // bake lighting function
 //-----------------------------------------------------------------------------
 
-// GetBakedDiffuseLigthing function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case)
+// GetBakedDiffuseLighting function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case)
-float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
+float3 GetBakedDiffuseLighting(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
 {
     if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
     {
 
 #endif // LIT_DISPLAY_REFERENCE_IBL
 
+    weight *= lightData.weight;
-    envLighting *= weight * lightData.dimmer;
+    envLighting *= weight * lightData.multiplier;
 
     if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
         lighting.specularReflected = envLighting;
     float3 modifiedDiffuseColor = ApplySubsurfaceScatteringTexturingMode(texturingMode, bsdfData.diffuseColor);
 
     // Apply the albedo to the direct diffuse lighting (only once). The indirect (baked)
-    // diffuse lighting has already had the albedo applied in GetBakedDiffuseLigthing().
+    // diffuse lighting has already had the albedo applied in GetBakedDiffuseLighting().
     diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + bakeDiffuseLighting;
 
     // If refraction is enable we use the transmittanceMask to lerp between current diffuse lighting and refraction value

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.shader

         [HideInInspector] _CullModeForward("__cullmodeForward", Float) = 2.0 // This mode is dedicated to Forward to correctly handle backface then front face rendering thin transparent
         [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
         [HideInInspector] _ZTestModeDistortion("_ZTestModeDistortion", Int) = 8
+        [HideInInspector] _ZTestGBuffer("_ZTestGBuffer", Int) = 4
 
         [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
         [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
+            ZTest [_ZTestGBuffer]
 
             Stencil
             {
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
 
-            #define SHADERPASS SHADERPASS_GBUFFER
-            #include "../../ShaderVariables.hlsl"
-            #ifdef DEBUG_DISPLAY
-            #include "../../Debug/DebugDisplay.hlsl"
-            #endif
-            #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitSharePass.hlsl"
-            #include "LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
-
-            ENDHLSL
-        }
-
-        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
-        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
-        Pass
-        {
-            Name "GBufferWithPrepass"  // Name is not used
-            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
-
-            Cull [_CullMode]
-
-            Stencil
-            {
-                WriteMask [_StencilWriteMask]
-                Ref  [_StencilRef]
-                Comp Always
-                Pass Replace
-            }
-
-            HLSLPROGRAM
-
-            #pragma multi_compile _ DEBUG_DISPLAY
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
-            #pragma multi_compile _ SHADOWS_SHADOWMASK
+        #ifdef _ALPHATEST_ON
+            // When we have alpha test, we will force a depth prepass so we always bypass the clip instruction in the GBuffer
+            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST 
+        #endif
-            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST // This define allow to not perform the alpha test (alpha test is done during depth prepass)
             #include "../../ShaderVariables.hlsl"
             #ifdef DEBUG_DISPLAY
             #include "../../Debug/DebugDisplay.hlsl"
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/LitTessellation.shader

         [HideInInspector] _CullModeForward("__cullmodeForward", Float) = 2.0 // This mode is dedicated to Forward to correctly handle backface then front face rendering thin transparent
         [HideInInspector] _ZTestDepthEqualForOpaque("_ZTestDepthEqualForOpaque", Int) = 4 // Less equal
         [HideInInspector] _ZTestModeDistortion("_ZTestModeDistortion", Int) = 8
+        [HideInInspector] _ZTestGBuffer("_ZTestGBuffer", Int) = 4
 
         [ToggleUI] _EnableFogOnTransparent("Enable Fog", Float) = 1.0
         [ToggleUI] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0
             Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
 
             Cull [_CullMode]
+            ZTest[_ZTestGBuffer]
 
             Stencil
             {
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
 
-            #define SHADERPASS SHADERPASS_GBUFFER
-            #include "../../ShaderVariables.hlsl"
-            #ifdef DEBUG_DISPLAY
-            #include "../../Debug/DebugDisplay.hlsl"
-            #endif
-            #include "../../Material/Material.hlsl"
-            #include "ShaderPass/LitSharePass.hlsl"
-            #include "LitData.hlsl"
-            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
-
-            ENDHLSL
-        }
-
-        // This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed)
-        // This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass.
-        Pass
-        {
-            Name "GBufferWithPrepass"  // Name is not used
-            Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index
-
-            Cull [_CullMode]
-
-            Stencil
-            {
-                WriteMask [_StencilWriteMask]
-                Ref  [_StencilRef]
-                Comp Always
-                Pass Replace
-            }
-
-            HLSLPROGRAM
-
-            #pragma hull Hull
-            #pragma domain Domain
-
-            #pragma multi_compile _ DEBUG_DISPLAY
-            #pragma multi_compile _ LIGHTMAP_ON
-            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
-            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
-            #pragma multi_compile _ SHADOWS_SHADOWMASK
+        #ifdef _ALPHATEST_ON
+            // When we have alpha test, we will force a depth prepass so we always bypass the clip instruction in the GBuffer
+            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST 
+        #endif
-            #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST // This define allow to not perform the alpha test (alpha test is done during depth prepass)
             #include "../../ShaderVariables.hlsl"
             #ifdef DEBUG_DISPLAY
             #include "../../Debug/DebugDisplay.hlsl"
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD
             #pragma multi_compile _ DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
             // #include "../../Lighting/Forward.hlsl"
-            #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            //#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
+            #define LIGHTLOOP_TILE_PASS
             #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             #define SHADERPASS SHADERPASS_FORWARD

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipeline/FrameSettings.cs

         // View
         public bool enableForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
         public bool enableDepthPrepassWithDeferredRendering = false;
-        public bool enableAlphaTestOnlyInDeferredPrepass = false;
 
         public bool enableTransparentPrepass = true;
         public bool enableMotionVectors = true; // Enable/disable whole motion vectors pass (Camera + Object).
 
             frameSettings.enableForwardRenderingOnly = this.enableForwardRenderingOnly;
             frameSettings.enableDepthPrepassWithDeferredRendering = this.enableDepthPrepassWithDeferredRendering;
-            frameSettings.enableAlphaTestOnlyInDeferredPrepass = this.enableAlphaTestOnlyInDeferredPrepass;
 
             frameSettings.enableTransparentPrepass = this.enableTransparentPrepass;
             frameSettings.enableMotionVectors = this.enableMotionVectors;
             // as rendering everything in wireframe + deferred do not play well together
             aggregate.enableForwardRenderingOnly = srcFrameSettings.enableForwardRenderingOnly || GL.wireframe || renderPipelineSettings.supportForwardOnly;
             aggregate.enableDepthPrepassWithDeferredRendering = srcFrameSettings.enableDepthPrepassWithDeferredRendering;
-            aggregate.enableAlphaTestOnlyInDeferredPrepass = srcFrameSettings.enableAlphaTestOnlyInDeferredPrepass;
 
             aggregate.enableTransparentPrepass = srcFrameSettings.enableTransparentPrepass;
             aggregate.enableMotionVectors = camera.cameraType != CameraType.Reflection && srcFrameSettings.enableMotionVectors && renderPipelineSettings.supportMotionVectors;
                     {
                         new DebugUI.BoolField { displayName = "Forward Only", getter = () => frameSettings.enableForwardRenderingOnly, setter = value => frameSettings.enableForwardRenderingOnly = value },
                         new DebugUI.BoolField { displayName = "Deferred Depth Prepass", getter = () => frameSettings.enableDepthPrepassWithDeferredRendering, setter = value => frameSettings.enableDepthPrepassWithDeferredRendering = value },
-                        new DebugUI.BoolField { displayName = "Deferred Depth Prepass ATest Only", getter = () => frameSettings.enableAlphaTestOnlyInDeferredPrepass, setter = value => frameSettings.enableAlphaTestOnlyInDeferredPrepass = value },
                         new DebugUI.BoolField { displayName = "Enable Async Compute", getter = () => frameSettings.enableAsyncCompute, setter = value => frameSettings.enableAsyncCompute = value },
                         new DebugUI.BoolField { displayName = "Enable Opaque Objects", getter = () => frameSettings.enableOpaqueObjects, setter = value => frameSettings.enableOpaqueObjects = value },
                         new DebugUI.BoolField { displayName = "Enable Transparent Objects", getter = () => frameSettings.enableTransparentObjects, setter = value => frameSettings.enableTransparentObjects = value },

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassForward.hlsl

         float3 diffuseLighting;
         float3 specularLighting;
         BakeLightingData bakeLightingData;
-        bakeLightingData.bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
+        bakeLightingData.bakeDiffuseLighting = GetBakedDiffuseLighting(surfaceData, builtinData, bsdfData, preLightData);
 #ifdef SHADOWS_SHADOWMASK
         bakeLightingData.bakeShadowMask = float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3);
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassGBuffer.hlsl

 
     PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
 
-    float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
+    float3 bakeDiffuseLighting = GetBakedDiffuseLighting(surfaceData, builtinData, bsdfData, preLightData);
 
     ENCODE_INTO_GBUFFER(surfaceData, bakeDiffuseLighting, posInput.positionSS, outGBuffer);
     ENCODE_SHADOWMASK_INTO_GBUFFER(float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3), outShadowMaskBuffer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyManager.cs

         SkyResolution256 = 256,
         SkyResolution512 = 512,
         SkyResolution1024 = 1024,
-        // TODO: Anything above 1024 cause a crash in Unity...
-        //SkyResolution2048 = 2048,
-        //SkyResolution4096 = 4096
+        SkyResolution2048 = 2048,
+        SkyResolution4096 = 4096
     }
 
     public enum EnvironementUpdateMode

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyRenderingContext.cs

             }
         }
 
+        // We do our own hash here because Unity does not provide correct hash for builtin types
+        // Moreover, we don't want to test every single parameters of the light so we filter them here in this specific function.
+        int GetSunLightHashCode(Light light)
+        {
+            HDAdditionalLightData ald = light.GetComponent<HDAdditionalLightData>();
+            unchecked
+            {
+                int hash = 13;
+                hash = hash * 23 + (light.GetHashCode() * 23 + light.transform.position.GetHashCode()) * 23 + light.transform.rotation.GetHashCode();
+                hash = hash * 23 + light.color.GetHashCode();
+                hash = hash * 23 + light.colorTemperature.GetHashCode();
+                hash = hash * 23 + light.intensity.GetHashCode();
+                hash = hash * 23 + light.range.GetHashCode();
+                if (light.cookie != null)
+                {
+                    hash = hash * 23 + (int)light.cookie.updateCount;
+                    hash = hash * 23 + (int)light.cookie.GetInstanceID();
+                }
+                if (ald != null)
+                {
+                    hash = hash * 23 + ald.lightDimmer.GetHashCode();
+                }
+
+                return hash;
+            }
+        }
+
         public bool UpdateEnvironment(SkyUpdateContext skyContext, HDCamera camera, Light sunLight, bool updateRequired, CommandBuffer cmd)
         {
             bool result = false;
 
                 int sunHash = 0;
                 if (sunLight != null)
-                    sunHash = (sunLight.GetHashCode() * 23 + sunLight.transform.position.GetHashCode()) * 23 + sunLight.transform.rotation.GetHashCode();
+                    sunHash = GetSunLightHashCode(sunLight);
                 int skyHash = sunHash * 23 + skyContext.skySettings.GetHashCode();
 
                 bool forceUpdate = (updateRequired || skyContext.updatedFramesRequired > 0 || m_NeedUpdate);

ScriptableRenderPipeline/HDRenderPipeline/package.json

 {
     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
-    "version": "1.1.1-preview",
+    "version": "1.1.2-preview",
-        "com.unity.postprocessing": "2.0.2-preview",
-        "com.unity.render-pipelines.core": "1.1.1-preview"
+        "com.unity.postprocessing": "2.0.3-preview",
+        "com.unity.render-pipelines.core": "1.1.2-preview"
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

         private Material GetMaterial(DefaultMaterialType materialType)
         {
 #if UNITY_EDITOR
+            if (editorResources == null)
+                return null;
 
             switch (materialType)
             {

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardSimpleLightingGUI.cs

         StandardSimpleLightingUpgrader.UpdateMaterialKeywords(material);
     }
 
+    private bool RequiresAlpha()
+    {
+        SurfaceType surfaceType = (SurfaceType) surfaceTypeProp.floatValue;
+        return alphaClip.floatValue > 0.0f || surfaceType == SurfaceType.Transparent;
+    }
+
     private void DoSurfaceArea()
     {
         int surfaceTypeValue = (int)surfaceTypeProp.floatValue;
         bool alphaClipEnabled = EditorGUILayout.Toggle(Styles.alphaClipLabel, alphaClip.floatValue == 1);
         if (EditorGUI.EndChangeCheck())
             alphaClip.floatValue = alphaClipEnabled ? 1 : 0;
-        
+
         EditorGUILayout.Space();
 
         if ((SurfaceType)surfaceTypeValue == SurfaceType.Opaque)
             m_MaterialEditor.TexturePropertySingleLine(Styles.specularGlossMapLabels[(int)glossinessSourceProp.floatValue], specularGlossMapProp, hasSpecularMap ? null : specularColorProp);
 
             EditorGUI.indentLevel += 2;
-            GUI.enabled = hasSpecularMap;
-            int glossinessSource = hasSpecularMap ? (int)glossinessSourceProp.floatValue : (int)GlossinessSource.BaseAlpha;
-            EditorGUI.BeginChangeCheck();
-            glossinessSource = EditorGUILayout.Popup(Styles.glossinessSourceLabel, glossinessSource, Styles.glossinessSourceNames);
-            if (EditorGUI.EndChangeCheck())
-                glossinessSourceProp.floatValue = glossinessSource;
-            GUI.enabled = true;
+            if (RequiresAlpha())
+            {
+                GUI.enabled = false;
+                glossinessSourceProp.floatValue = (float)EditorGUILayout.Popup(Styles.glossinessSourceLabel, (int) GlossinessSource.SpecularAlpha, Styles.glossinessSourceNames);
+                GUI.enabled = true;
+            }
+            else
+            {
+                int glossinessSource = (int)glossinessSourceProp.floatValue;
+                EditorGUI.BeginChangeCheck();
+                glossinessSource = EditorGUILayout.Popup(Styles.glossinessSourceLabel, glossinessSource, Styles.glossinessSourceNames);
+                if (EditorGUI.EndChangeCheck())
+                    glossinessSourceProp.floatValue = glossinessSource;
+                GUI.enabled = true;
+            }
-                    kMinShininessValue, 1.0f);
+                kMinShininessValue, 1.0f);
             if (EditorGUI.EndChangeCheck())
                 shininessProp.floatValue = shininess;
             EditorGUI.indentLevel -= 2;

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

 Pass
 {
-    Tags{"LightMode" = "ShadowCaster"}
+	Tags{"LightMode" = "ShadowCaster"}
-    ZWrite On
-    ZTest LEqual
-    Cull ${Culling}
+	ZWrite On
+	ZTest LEqual
+	Cull ${Culling}
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
+
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
+
+	#pragma vertex ShadowPassVertex
+	#pragma fragment ShadowPassFragment
-    #pragma vertex ShadowPassVertex
-    #pragma fragment LitPassFragmentNull
+	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    ENDHLSL
+	ENDHLSL
-    Tags{"LightMode" = "DepthOnly"}
+	Tags{"LightMode" = "DepthOnly"}
+
+	ZWrite On
+	ColorMask 0
-    ZWrite On
-    ColorMask 0
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	#pragma vertex DepthOnlyVertex
+	#pragma fragment DepthOnlyFragment
-    #pragma vertex LitPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
+	ENDHLSL
-    Tags{"LightMode" = "Meta"}
+	Tags{"LightMode" = "Meta"}
-    Cull Off
+	Cull Off
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
-    #pragma vertex LightweightVertexMeta
-    #pragma fragment LightweightFragmentMeta
+	#pragma vertex LightweightVertexMeta
+	#pragma fragment LightweightFragmentMeta
-    #pragma shader_feature _SPECULAR_SETUP
-    #pragma shader_feature _EMISSION
-    #pragma shader_feature _METALLICSPECGLOSSMAP
-    #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    #pragma shader_feature EDITOR_VISUALIZATION
+	#pragma shader_feature _SPECULAR_SETUP
+	#pragma shader_feature _EMISSION
+	#pragma shader_feature _METALLICSPECGLOSSMAP
+	#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+	#pragma shader_feature EDITOR_VISUALIZATION
-    #pragma shader_feature _SPECGLOSSMAP
+	#pragma shader_feature _SPECGLOSSMAP
-    #include "LWRP/ShaderLibrary/LightweightPassMeta.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassMeta.hlsl"
+	ENDHLSL
 }

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}
 		float3 lwWorldPos = TransformObjectToWorld(v.vertex.xyz);
 		float4 clipPos = TransformWorldToHClip(lwWorldPos);
 
- 		// 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);
+ 		// We either sample GI from lightmap or SH.
+	    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+        // see DECLARE_LIGHTMAP_OR_SH macro.
+	    // The following funcions initialize the correct variable with correct data
+	    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/Editor/ShaderGraph/lightweightUnlitExtraPasses.template

 Pass
 {
-    Tags{"LightMode" = "ShadowCaster"}
+	Tags{"LightMode" = "ShadowCaster"}
-    ZWrite On
-    ZTest LEqual
-    Cull ${Culling}
+	ZWrite On
+	ZTest LEqual
+	Cull ${Culling}
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
-    #pragma vertex ShadowPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
-    ENDHLSL
+	#pragma vertex ShadowPassVertex
+	#pragma fragment ShadowPassFragment
+
+	#include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
+
+	ENDHLSL
-    Tags{"LightMode" = "DepthOnly"}
+	Tags{"LightMode" = "DepthOnly"}
-    ZWrite On
-    ColorMask 0
+	ZWrite On
+	ColorMask 0
-    HLSLPROGRAM
-    // Required to compile gles 2.0 with standard srp library
-    #pragma prefer_hlslcc gles
-    #pragma target 2.0
-    
-    //--------------------------------------
-    // GPU Instancing
-    #pragma multi_compile_instancing
+	HLSLPROGRAM
+	// Required to compile gles 2.0 with standard srp library
+	#pragma prefer_hlslcc gles
+	#pragma target 2.0
+
+	#pragma vertex DepthOnlyVertex
+	#pragma fragment DepthOnlyFragment
-    #pragma vertex LitPassVertex
-    #pragma fragment LitPassFragmentNull
+	//--------------------------------------
+	// GPU Instancing
+	#pragma multi_compile_instancing
-    #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
-    ENDHLSL
+	#include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
+	ENDHLSL
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Text;
+#if UNITY_EDITOR
+using UnityEditor.Experimental.Rendering.LightweightPipeline;
+#endif
 using UnityEngine.Experimental.GlobalIllumination;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
     public class ShadowSettings
     {
         public bool     enabled;
+        public bool     screenSpace;
         public int      shadowAtlasWidth;
         public int      shadowAtlasHeight;
 
         public float    directionalLightNearPlaneOffset;
 
-        public RenderTextureFormat renderTextureFormat;
+        public RenderTextureFormat shadowmapTextureFormat;
+        public RenderTextureFormat screenspaceShadowmapTextureFormat;
 
         static ShadowSettings defaultShadowSettings = null;
 
                 {
                     defaultShadowSettings = new ShadowSettings();
                     defaultShadowSettings.enabled = true;
+                    defaultShadowSettings.screenSpace = true;
-                    defaultShadowSettings.renderTextureFormat = RenderTextureFormat.Shadowmap;
+                    defaultShadowSettings.shadowmapTextureFormat = RenderTextureFormat.Shadowmap;
+                    defaultShadowSettings.screenspaceShadowmapTextureFormat = RenderTextureFormat.R8;
                 }
                 return defaultShadowSettings;
             }
         private int m_ScreenSpaceShadowMapRTID;
         private Matrix4x4[] m_ShadowMatrices = new Matrix4x4[kMaxCascades + 1];
         private RenderTargetIdentifier m_CurrCameraColorRT;
-        private RenderTargetIdentifier m_ShadowMapRT;
+        private RenderTexture m_ShadowMapRT;
         private RenderTargetIdentifier m_ScreenSpaceShadowMapRT;
         private RenderTargetIdentifier m_ColorRT;
         private RenderTargetIdentifier m_CopyColorRT;
             CameraRenderTargetID.depth = Shader.PropertyToID("_CameraDepthTexture");
             CameraRenderTargetID.depthCopy = Shader.PropertyToID("_CameraCopyDepthTexture");
 
-            m_ShadowMapRT = new RenderTargetIdentifier(m_ShadowMapRTID);
             m_ScreenSpaceShadowMapRT = new RenderTargetIdentifier(m_ScreenSpaceShadowMapRTID);
 
             m_ColorRT = new RenderTargetIdentifier(CameraRenderTargetID.color);
             CoreUtils.Destroy(m_ErrorMaterial);
             CoreUtils.Destroy(m_CopyDepthMaterial);
             CoreUtils.Destroy(m_BlitMaterial);
+
+#if UNITY_EDITOR
+            SceneViewDrawMode.ResetDrawMode();
+#endif
         }
 
         private void SetRenderingFeatures()
                 rendererSupportsReceiveShadows = true,
                 rendererSupportsReflectionProbes = true
             };
+            SceneViewDrawMode.SetupDrawMode();
 #endif
         }
 
                 m_CurrCamera = camera;
                 m_IsOffscreenCamera = m_CurrCamera.targetTexture != null && m_CurrCamera.cameraType != CameraType.SceneView;
 
-                var cmd = CommandBufferPool.Get("");
-                cmd.BeginSample("LightweightPipeline.Render");
-                context.ExecuteCommandBuffer(cmd);
-                cmd.Clear();
+                var cmd = CommandBufferPool.Get("");
                 cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance,
                         m_CurrCamera.farClipPlane);
 
                 context.SetupCameraProperties(m_CurrCamera, stereoEnabled);
 
                 if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.DepthPrePass))
-                {
-                    // Only screen space shadowmap mode is supported.
-                    if (shadows)
-                        ShadowCollectPass(visibleLights, ref context, ref lightData, frameRenderingConfiguration);
-                }
+                if (shadows && m_ShadowSettings.screenSpace)
+                    ShadowCollectPass(visibleLights, ref context, ref lightData, frameRenderingConfiguration);
-                    setRT.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
+                    if (m_ShadowSettings.screenSpace)
+                        setRT.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
+                    else
+                        setRT.GetTemporaryRT(m_ShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, m_ShadowSettings.shadowmapTextureFormat);
                     setRT.Blit(Texture2D.whiteTexture, m_ScreenSpaceShadowMapRT);
                     context.ExecuteCommandBuffer(setRT);
                 }
                 if (sceneViewCamera)
                     CopyTexture(cmd, CameraRenderTargetID.depth, BuiltinRenderTextureType.CameraTarget, m_CopyDepthMaterial, true);
 #endif
-                cmd.ReleaseTemporaryRT(m_ShadowMapRTID);
-
-                cmd.EndSample("LightweightPipeline.Render");
-
+
+                if (m_ShadowMapRT)
+                {
+                    RenderTexture.ReleaseTemporary(m_ShadowMapRT);
+                    m_ShadowMapRT = null;
+                }
+            m_ShadowMapRT = null;
             if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
             {
                 VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
                     bool shadowsRendered = RenderShadows(ref m_CullResults, ref mainLight, shadowOriginalIndex, ref context);
                     if (shadowsRendered)
                     {
-                        lightData.shadowMapSampleType = (m_Asset.ShadowSetting != ShadowType.SOFT_SHADOWS)
-                            ? LightShadows.Hard
-                            : mainLight.light.shadows;
+                        lightData.shadowMapSampleType = (m_Asset.ShadowSetting != ShadowType.SOFT_SHADOWS) ? LightShadows.Hard : mainLight.light.shadows;
+
+                        // In order to avoid shader variants explosion we only do hard shadows when sampling shadowmap in the lit pass.
+                        // GLES2 platform is forced to hard single cascade shadows.
+                        if (!m_ShadowSettings.screenSpace)
+                            lightData.shadowMapSampleType = LightShadows.Hard;
                     }
                     else
                     {
         {
             CommandBuffer cmd = CommandBufferPool.Get("Collect Shadows");
 
-            SetupShadowReceiverConstants(cmd, visibleLights[lightData.mainLightIndex]);
-
             // TODO: Support RenderScale for the SSSM target.  Should probably move allocation elsewhere, or at
             // least propogate RenderTextureDescriptor generation
             if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.Stereo))
-                desc.colorFormat = RenderTextureFormat.R8;
+                desc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
-                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
+                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
-            // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that 
+            // 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
             // stereo functionality, we use the screen-space shadow map as the source (until we have
             // a better solution).
         private void BuildShadowSettings()
         {
             m_ShadowSettings = ShadowSettings.Default;
-            m_ShadowSettings.directionalLightCascadeCount = m_Asset.CascadeCount;
+            m_ShadowSettings.screenSpace = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
+            m_ShadowSettings.directionalLightCascadeCount = (m_ShadowSettings.screenSpace) ? m_Asset.CascadeCount : 1;
-            m_ShadowSettings.renderTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+            m_ShadowSettings.shadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.Shadowmap)
+            m_ShadowSettings.screenspaceShadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8)
+                    ? RenderTextureFormat.R8
+                    : RenderTextureFormat.ARGB32;
+
             switch (m_ShadowSettings.directionalLightCascadeCount)
             {
                 case 1:
 
             if (shadows)
             {
-                m_RequireDepthTexture = true;
+                m_RequireDepthTexture = m_ShadowSettings.screenSpace;
 
                 if (!msaaEnabled)
                     intermediateTexture = true;
             msaaSamples = (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.Msaa)) ? msaaSamples : 1;
             m_CurrCameraColorRT = BuiltinRenderTextureType.CameraTarget;
 
-            if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture))
+            if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture) || m_RequireDepthTexture)
                 SetupIntermediateRenderTextures(cmd, renderingConfig, msaaSamples);
 
             context.ExecuteCommandBuffer(cmd);
             cmd.SetGlobalVector("_LightDirection", new Vector4(lightDirection.x, lightDirection.y, lightDirection.z, 0.0f));
         }
 
-        private void SetupShadowReceiverConstants(CommandBuffer cmd, VisibleLight shadowLight)
+        private void SetupShadowReceiverConstants(CommandBuffer cmd, VisibleLight shadowLight, ref ScriptableRenderContext context)
         {
             Light light = shadowLight.light;
 
 
             float invShadowResolution = 1.0f / m_Asset.ShadowAtlasResolution;
             float invHalfShadowResolution = 0.5f * invShadowResolution;
+            cmd.Clear();
+            cmd.SetGlobalTexture(m_ShadowMapRTID, m_ShadowMapRT);
             cmd.SetGlobalMatrixArray(ShadowConstantBuffer._WorldToShadow, m_ShadowMatrices);
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowData, new Vector4(light.shadowStrength, 0.0f, 0.0f, 0.0f));
             cmd.SetGlobalVectorArray(ShadowConstantBuffer._DirShadowSplitSpheres, m_DirectionalShadowSplitDistances);
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset2, new Vector4(-invHalfShadowResolution, invHalfShadowResolution, 0.0f, 0.0f));
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowOffset3, new Vector4(invHalfShadowResolution, invHalfShadowResolution, 0.0f, 0.0f));
             cmd.SetGlobalVector(ShadowConstantBuffer._ShadowmapSize, new Vector4(invShadowResolution, invShadowResolution, m_Asset.ShadowAtlasResolution, m_Asset.ShadowAtlasResolution));
+            context.ExecuteCommandBuffer(cmd);
         }
 
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, List<VisibleLight> visibleLights)
             CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SUBTRACTIVE", m_MixedLightingSetup == MixedLightingSetup.Subtractive);
             CoreUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_RequireDepthTexture && m_Asset.RequireSoftParticles);
-           
+
             bool linearFogModeEnabled = false;
             bool exponentialFogModeEnabled = false;
             if (RenderSettings.fog)
             bool success = false;
 
             var cmd = CommandBufferPool.Get("Prepare Shadowmap");
-            cmd.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, kShadowBufferBits, FilterMode.Bilinear, m_ShadowSettings.renderTextureFormat);
+            RenderTextureDescriptor shadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.shadowAtlasWidth,
+                m_ShadowSettings.shadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, kShadowBufferBits);
+            shadowmapDescriptor.shadowSamplingMode = ShadowSamplingMode.CompareDepths;
+            m_ShadowMapRT = RenderTexture.GetTemporary(shadowmapDescriptor);
+            m_ShadowMapRT.filterMode = FilterMode.Bilinear;
+            m_ShadowMapRT.wrapMode = TextureWrapMode.Clamp;
+
             // LightweightPipeline.SetRenderTarget is meant to be used with camera targets, not shadowmaps
             CoreUtils.SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.Depth, CoreUtils.ConvertSRGBToActiveColorSpace(m_CurrCamera.backgroundColor));
 
             {
                 Debug.LogWarning("Only spot and directional shadow casters are supported in lightweight pipeline");
             }
+
+            if (success)
+                SetupShadowReceiverConstants(cmd, shadowLight, ref context);
 
             CommandBufferPool.Release(cmd);
             return success;
         {
             cmd.SetViewport(new Rect(m_ShadowSlices[cascadeIndex].atlasX, m_ShadowSlices[cascadeIndex].atlasY,
                     m_ShadowSlices[cascadeIndex].shadowResolution, m_ShadowSlices[cascadeIndex].shadowResolution));
+            cmd.EnableScissorRect(new Rect(m_ShadowSlices[cascadeIndex].atlasX + 4, m_ShadowSlices[cascadeIndex].atlasY + 4,
+                m_ShadowSlices[cascadeIndex].shadowResolution - 8, m_ShadowSlices[cascadeIndex].shadowResolution - 8));
+
+            cmd.Clear();
+            cmd.DisableScissorRect();
+            context.ExecuteCommandBuffer(cmd);
             cmd.Clear();
         }
 
                     depthRT = m_DepthRT;
             }
 
-            if (ForceClear())
+            ClearFlag clearFlag = ClearFlag.None;
+            CameraClearFlags cameraClearFlags = m_CurrCamera.clearFlags;
+            if (cameraClearFlags != CameraClearFlags.Nothing)
-                SetRenderTarget(cmd, colorRT, depthRT, ClearFlag.All);
+                clearFlag |= ClearFlag.Depth;
+                if (cameraClearFlags == CameraClearFlags.Color || cameraClearFlags == CameraClearFlags.Skybox)
+                    clearFlag |= ClearFlag.Color;
-            else
-            {
-                ClearFlag clearFlag = ClearFlag.None;
-                CameraClearFlags cameraClearFlags = m_CurrCamera.clearFlags;
-                if (cameraClearFlags != CameraClearFlags.Nothing)
-                {
-                    clearFlag |= ClearFlag.Depth;
-                    if (cameraClearFlags == CameraClearFlags.Color || cameraClearFlags == CameraClearFlags.Skybox)
-                        clearFlag |= ClearFlag.Color;
-                }
-                SetRenderTarget(cmd, colorRT, depthRT, clearFlag);
-            }
+            SetRenderTarget(cmd, colorRT, depthRT, clearFlag);
 
             // If rendering to an intermediate RT we resolve viewport on blit due to offset not being supported
             // while rendering to a RT.
         private int GetLightUnsortedIndex(int index)
         {
             return (index < m_SortedLightIndexMap.Count) ? m_SortedLightIndexMap[index] : index;
-        }
-
-        private bool ForceClear()
-        {
-            // Clear RenderTarget to avoid tile initialization on mobile GPUs
-            // https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
-            return (Application.platform == RuntimePlatform.Android || Application.platform == RuntimePlatform.IPhonePlayer);
         }
 
         private void Blit(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material material = null)

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
     #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)
 #endif
 
-void AlphaDiscard(half alpha, half cutoff)
+void AlphaDiscard(half alpha, half cutoff, half offset = 0.0h)
-    clip(alpha - cutoff);
+    clip(alpha - cutoff + offset);
-    // Compiler will optimize the scale away
-    return UnpackNormalRGB(packedNormal, 1.0);
+    return UnpackNormalRGBNoScale(packedNormal);
+        // Compiler will optimize the scale away
     return UnpackNormalmapRGorAG(packedNormal, 1.0);
 #endif
 }
     binormalWS = cross(normalWS, tangentWS) * sign;
 }
 
+half3 FragmentNormalWS(half3 normal)
+{
+#if !SHADER_HINT_NICE_QUALITY
+    // World normal is already normalized in vertex. Small acceptable error to save ALU.
+    return normal;
+#else
+    return normalize(normal);
+#endif
+}
+
+half3 FragmentViewDirWS(half3 viewDir)
+{
+#if !SHADER_HINT_NICE_QUALITY
+    // View direction is already normalized in vertex. Small acceptable error to save ALU.
+    return viewDir;
+#else
+    return SafeNormalize(viewDir);
+#endif
+}
+
+half3 VertexViewDirWS(half3 viewDir)
+{
+#if !SHADER_HINT_NICE_QUALITY
+    // Normalize in vertex and avoid renormalizing it in frag to save ALU.
+    return SafeNormalize(viewDir);
+#else
+    return viewDir;
+#endif
+}
+
-    return normalize(mul(normalTangent, tangentToWorld));
+    return FragmentNormalWS(mul(normalTangent, tangentToWorld));
 }
 
 // TODO: A similar function should be already available in SRP lib on master. Use that instead

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/InputSurface.hlsl

 ///////////////////////////////////////////////////////////////////////////////
 //                      Material Property Helpers                            //
 ///////////////////////////////////////////////////////////////////////////////
-inline half Alpha(half albedoAlpha)
+float2 TransformMainTextureCoord(float2 uv)
-#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+    return TRANSFORM_TEX(uv, _MainTex);
+}
+
+half Alpha(half albedoAlpha)
+{
+#if !defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A) && !defined(_GLOSSINESS_FROM_BASE_ALPHA)
+    half alpha = albedoAlpha * _Color.a;
+#else
-#else
-    half alpha = albedoAlpha * _Color.a;
 #endif
 
 #if defined(_ALPHATEST_ON)
     return alpha;
 }
 
+half4 MainTexture(float2 uv)
+{
+    return SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
+}
+
-    return UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv), _BumpScale);
+    #if BUMP_SCALE_NOT_SUPPORTED
+        return UnpackNormal(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv));
+    #else
+        return UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, uv), _BumpScale);
+    #endif
 #else
     return half3(0.0h, 0.0h, 1.0h);
 #endif
     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
     half4 specGloss;
 
 #ifdef _METALLICSPECGLOSSMAP
-    specGloss = specGloss = SAMPLE_METALLICSPECULAR(uv);
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    specGloss.a = albedoAlpha * _GlossMapScale;
-#else
-    specGloss.a *= _GlossMapScale;
-#endif
-
+    specGloss = SAMPLE_METALLICSPECULAR(uv);
+    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+        specGloss.a = albedoAlpha * _GlossMapScale;
+    #else
+        specGloss.a *= _GlossMapScale;
+    #endif
-#if _SPECULAR_SETUP
-    specGloss.rgb = _SpecColor.rgb;
-#else
-    specGloss.rgb = _Metallic.rrr;
-#endif
+    #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
+    #ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+        specGloss.a = albedoAlpha * _GlossMapScale;
+    #else
+        specGloss.a = _Glossiness;
+    #endif
 #endif
 
     return specGloss;
 
 inline void InitializeStandardLitSurfaceData(float2 uv, out SurfaceData outSurfaceData)
 {
-    half4 albedoAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
+    half4 albedoAlpha = MainTexture(uv);
 
     half4 specGloss = MetallicSpecGloss(uv, albedoAlpha.a);
     outSurfaceData.albedo = albedoAlpha.rgb * _Color.rgb;

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)
-{
-    return SampleLightmap(sampleData.xy, normalWS);
-#endif
-
+#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)
+{
-    return SampleSHPixel(sampleData.xyz, normalWS);
+    return SampleSHPixel(sampleData, normalWS);
+#endif
 
 half3 GlossyEnvironmentReflection(half3 reflectVector, half perceptualRoughness, half occlusion)
 {
 {
     half3 halfVec = SafeNormalize(lightDir + viewDir);
     half NdotH = saturate(dot(normal, halfVec));
-    half3 specularReflection = specularGloss.rgb * pow(NdotH, shininess) * specularGloss.a;
+    half modifier = pow(NdotH, shininess) * specularGloss.a;
+    half3 specularReflection = specularGloss.rgb * modifier;
     return lightColor * specularReflection;
 }
 
     }
 #endif
 
-    half3 finalColor = diffuseColor * diffuse + emission;
-    finalColor += inputData.vertexLighting * diffuse;
+    half3 fullDiffuse = diffuseColor + inputData.vertexLighting;
+    half3 finalColor = fullDiffuse * diffuse + emission;
     
 #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
     finalColor += specularColor;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     float2 texcoord : TEXCOORD0;
     float2 lightmapUV : TEXCOORD1;
     UNITY_VERTEX_INPUT_INSTANCE_ID
-
-    float4 lightmapUVOrVertexSH     : TEXCOORD1; // holds either lightmapUV or vertex SH. depending on LIGHTMAP_ON
-    float3 posWS                    : TEXCOORD2;
-    half3  normal                   : TEXCOORD3;
+    DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
+    float4 posWSShininess           : TEXCOORD2;    // xyz: posWS, w: Shininess * 128
-    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.z
+#else
+    half3  normal                   : TEXCOORD3;
+    half3 viewDir                   : TEXCOORD4;
-    half3 viewDir                   : TEXCOORD6;
-    half4 fogFactorAndVertexLight   : TEXCOORD7; // x: fogFactor, yzw: vertex light
+    half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
-    float4 shadowCoord               : TEXCOORD8;
+    float4 shadowCoord              : TEXCOORD7;
 
     float4 clipPos                  : SV_POSITION;
     UNITY_VERTEX_INPUT_INSTANCE_ID
 void InitializeInputData(LightweightVertexOutput IN, half3 normalTS, out InputData inputData)
 {
-    inputData.positionWS = IN.posWS.xyz;
+    inputData.positionWS = IN.posWSShininess.xyz;
-    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
-#else
-    inputData.normalWS = normalize(IN.normal);
-#endif
-
-#if SHADER_HINT_NICE_QUALITY
-    inputData.viewDirectionWS = SafeNormalize(IN.viewDir);
+    half3 viewDir = half3(IN.normal.w, IN.tangent.w, IN.binormal.w);
+    inputData.normalWS = TangentToWorldNormal(normalTS, IN.tangent.xyz, IN.binormal.xyz, IN.normal.xyz);
-    // View direction is already normalize in vertex. Small acceptable error to save ALU.
-    inputData.viewDirectionWS = IN.viewDir;
+    half3 viewDir = IN.viewDir;
+    inputData.normalWS = FragmentNormalWS(IN.normal);
+    inputData.viewDirectionWS = FragmentViewDirWS(viewDir);
-
-    inputData.bakedGI = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS);
+    inputData.bakedGI = SAMPLE_GI(IN.lightmapUV, IN.vertexSH, inputData.normalWS);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
     UNITY_TRANSFER_INSTANCE_ID(v, o);
     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
 
-    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
+    o.uv = TransformMainTextureCoord(v.texcoord);
-    o.posWS = TransformObjectToWorld(v.vertex.xyz);
-    o.clipPos = TransformWorldToHClip(o.posWS);
+    o.posWSShininess.xyz = TransformObjectToWorld(v.vertex.xyz);
+    o.posWSShininess.w = _Shininess * 128.0;
+    o.clipPos = TransformWorldToHClip(o.posWSShininess.xyz);
-    o.viewDir = GetCameraPositionWS() - o.posWS;
+    half3 viewDir = VertexViewDirWS(GetCameraPositionWS() - o.posWSShininess.xyz);
-#if !SHADER_HINT_NICE_QUALITY
-    // Normalize in vertex and avoid renormalizing it in frag to save ALU.
-    o.viewDir = SafeNormalize(o.viewDir);
+#ifdef _NORMALMAP
+    o.normal.w = viewDir.x;
+    o.tangent.w = viewDir.y;
+    o.binormal.w = viewDir.z;
+#else
+    o.viewDir = viewDir;
-    // 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.lightmapUV, unity_LightmapST, o.lightmapUVOrVertexSH);
-    OUTPUT_SH(o.normal, o.lightmapUVOrVertexSH);
+    // We either sample GI from lightmap or SH.
+    // Lightmap UV and vertex SH coefficients use the same interpolator ("float2 lightmapUV" for lightmap or "half3 vertexSH" for SH)
+    // see DECLARE_LIGHTMAP_OR_SH macro.
+    // The following funcions initialize the correct variable with correct data
+    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.posWSShininess.xyz, o.normal.xyz);
+
+#if SHADOWS_SCREEN
+#else
+    o.shadowCoord = TransformWorldToShadowCoord(o.posWSShininess.xyz);
+#endif
 
     return o;
 }
     return color;
 }
 
-// Used for Standard shader
-half4 LitPassFragmentNull(LightweightVertexOutput IN) : SV_Target
-{
-    LitPassFragment(IN);
-    return 0;
-}
-
 // Used for StandardSimpleLighting shader
 half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
 {
 
     half3 emission = Emission(uv);
     half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
-    half shininess = _Shininess * 128.0h;
+    half shininess = IN.posWSShininess.w;
 
     InputData inputData;
     InitializeInputData(IN, normalTS, inputData);
-
-
-// Used for StandardSimpleLighting shader
-half4 LitPassFragmentSimpleNull(LightweightVertexOutput IN) : SV_Target
-{
-    half4 result = LitPassFragmentSimple(IN);
-    return result.a;
-}
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassShadow.hlsl

 #ifndef LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 #define LIGHTWEIGHT_PASS_SHADOW_INCLUDED
 
-#include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+#include "LWRP/ShaderLibrary/Core.hlsl"
+#include "LWRP/ShaderLibrary/InputSurface.hlsl"
-LightweightVertexOutput ShadowPassVertex(LightweightVertexInput v)
+struct VertexInput
+{
+    float4 position     : POSITION;
+    float3 normal       : NORMAL;
+    float2 texcoord     : TEXCOORD0;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput
+{
+    float2 uv           : TEXCOORD0;
+    float4 clipPos      : SV_POSITION;
+};
+
+float4 GetShadowPositionHClip(VertexInput v)
-    LightweightVertexOutput o = LitPassVertex(v);
+    float3 positionWS = TransformObjectToWorld(v.position.xyz);
+    float3 normalWS = TransformObjectToWorldDir(v.normal);
-    float invNdotL = 1.0 - saturate(dot(_LightDirection, o.normal));
+    float invNdotL = 1.0 - saturate(dot(_LightDirection, normalWS));
-    o.posWS = o.normal * scale.xxx + o.posWS;
-    float4 clipPos = TransformWorldToHClip(o.posWS);
+    positionWS = normalWS * scale.xxx + positionWS;
+    float4 clipPos = TransformWorldToHClip(positionWS);
 
     // _ShadowBias.x sign depens on if platform has reversed z buffer
     clipPos.z += _ShadowBias.x;
     clipPos.z = max(clipPos.z, clipPos.w * UNITY_NEAR_CLIP_VALUE);
 #endif
 
-    o.clipPos = clipPos;
+    return clipPos;
+}
+
+VertexOutput ShadowPassVertex(VertexInput v)
+{
+    VertexOutput o;
+    UNITY_SETUP_INSTANCE_ID(v);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+    o.clipPos = GetShadowPositionHClip(v);
+
+half4 ShadowPassFragment(VertexOutput IN) : SV_TARGET
+{
+    Alpha(MainTexture(IN.uv).a);
+    return 0;
+}
+
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Particles.hlsl

     float4 projectedPosition        : TEXCOORD5;
 #endif
     float4 posWS                    : TEXCOORD6; // xyz: position; w = fogFactor;
+    half4 viewDirShininess          : TEXCOORD7; // xyz: viewDir; w = shininess
     float4 clipPos                  : SV_POSITION;
 };
 
     return color;
 }
 
-void InitializeSurfaceData(VertexOutputLit IN, out SurfaceData surfaceData)
+half3 NormalTS(VertexOutputLit IN)
+{
+#if defined(_NORMALMAP)
+    #if BUMP_SCALE_NOT_SUPPORTED
+        return UnpackNormal(readTexture(TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap), IN));
+    #else
+        return UnpackNormalScale(readTexture(TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap), IN), _BumpScale);
+    #endif
+#else
+    return half3(0.0h, 0.0h, 1.0h);
+#endif
+}
+
+half3 Emission(VertexOutputLit IN)
+{
+#if defined(_EMISSION)
+    return readTexture(TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap), IN).rgb * _EmissionColor.rgb;
+#else
+    return half3(0.0h, 0.0h, 0.0h);
+#endif
+}
+
+half4 Albedo(VertexOutputLit IN)
 {
     half4 albedo = readTexture(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), IN) * IN.color;
 
     fragCameraFading(IN);
 
-#if defined(_METALLICGLOSSMAP)
-    half2 metallicGloss = readTexture(_MetallicGlossMap, sampler_MetallicGlossMap, IN).ra * half2(1.0, _Glossiness);
+    return albedo;
+}
+
+half4 SpecularGloss(VertexOutputLit IN, half alpha)
+{
+    half4 specularGloss = half4(0.0h, 0.0h, 0.0h, 1.0h);
+#ifdef _SPECGLOSSMAP
+    specularGloss = readTexture(TEXTURE2D_PARAM(_SpecGlossMap, sampler_SpecGlossMap), IN);
+#elif defined(_SPECULAR_COLOR)
+    specularGloss = _SpecColor;
+#endif
+
+#ifdef _GLOSSINESS_FROM_BASE_ALPHA
+    specularGloss.a = alpha;
+#endif
+    return specularGloss;
+}
+
+half AlphaBlendAndTest(half alpha)
+{
+#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON) || defined(_ALPHAOVERLAY_ON)
+    half result = alpha;
-    half2 metallicGloss = half2(_Metallic, _Glossiness);
+    half result = 1.0h;
+    AlphaDiscard(result, _Cutoff, 0.0001h);
-#if defined(_NORMALMAP)
-    half3 normalTS = normalize(UnpackNormalScale(readTexture(_BumpMap, sampler_BumpMap, IN), _BumpScale));
+    return result;
+}
+
+half3 AlphaModulate(half3 albedo, half alpha)
+{
+#if defined(_ALPHAMODULATE_ON)
+    return lerp(half3(1.0h, 1.0h, 1.0h), albedo, alpha);
-    half3 normalTS = float3(0, 0, 1);
+    return albedo;
+}
-#if defined(_EMISSION)
-    half3 emission = readTexture(_EmissionMap, sampler_EmissionMap, IN).rgb;
+void InitializeSurfaceData(VertexOutputLit IN, out SurfaceData surfaceData)
+{
+    half4 albedo = Albedo(IN);
+
+#if defined(_METALLICGLOSSMAP)
+    half2 metallicGloss = readTexture(TEXTURE2D_PARAM(_MetallicGlossMap, sampler_MetallicGlossMap), IN).ra * half2(1.0, _Glossiness);
-    half3 emission = 0;
+    half2 metallicGloss = half2(_Metallic, _Glossiness);
+    half3 normalTS = NormalTS(IN);
+    half3 emission = Emission(IN);
+
-    surfaceData.specular = half3(0, 0, 0);
+    surfaceData.specular = half3(0.0h, 0.0h, 0.0h);
-    surfaceData.emission = emission * _EmissionColor.rgb;
+    surfaceData.emission = emission;
-#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON) || defined(_ALPHAOVERLAY_ON)
-    surfaceData.alpha = albedo.a;
-#else
-    surfaceData.alpha = 1;
-#endif
-
-#if defined(_ALPHAMODULATE_ON)
-    surfaceData.albedo = lerp(half3(1.0, 1.0, 1.0), surfaceData.albedo, surfaceData.alpha);
-#endif
-
-#if defined(_ALPHATEST_ON)
-    clip(surfaceData.alpha - _Cutoff + 0.0001);
-#endif
+    surfaceData.alpha = AlphaBlendAndTest(albedo.a);
+    surfaceData.albedo = AlphaModulate(surfaceData.albedo, surfaceData.alpha);
 }
 
 void InitializeInputData(VertexOutputLit IN, half3 normalTS, out InputData input)
 #if _NORMALMAP
     input.normalWS = TangentToWorldNormal(normalTS, IN.tangent, IN.binormal, IN.normal);
 #else
-    input.normalWS = normalize(IN.normal);
+    input.normalWS = FragmentNormalWS(IN.normal);
-    input.viewDirectionWS = SafeNormalize(GetCameraPositionWS() - input.positionWS);
+    input.viewDirectionWS = FragmentViewDirWS(IN.viewDirShininess.xyz);
-    input.vertexLighting = half3(0, 0, 0);
-    input.bakedGI = half3(0, 0, 0);
+    input.vertexLighting = half3(0.0h, 0.0h, 0.0h);
+    input.bakedGI = half3(0.0h, 0.0h, 0.0h);
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 
 #define MAX_SHADOW_CASCADES 4
 
+#ifdef SHADER_API_GLES
+#define SHADOWS_SCREEN 0
+#else
+#define SHADOWS_SCREEN 1
+#endif
+
 SCREENSPACE_TEXTURE(_ScreenSpaceShadowMap);
 SAMPLER(sampler_ScreenSpaceShadowMap);
 
 #define BEYOND_SHADOW_FAR(shadowCoord) shadowCoord.z >= UNITY_RAW_FAR_CLIP_VALUE
 #endif
 
-#define OUTSIDE_SHADOW_BOUNDS(shadowCoord) shadowCoord.x <= 0 || shadowCoord.x >= 1 || shadowCoord.y <= 0 || shadowCoord.y >= 1 || BEYOND_SHADOW_FAR(shadowCoord)
-
 half GetShadowStrength()
 {
     return _ShadowData.x;
     half attenuation = SAMPLE_TEXTURE2D(_ScreenSpaceShadowMap, sampler_ScreenSpaceShadowMap, shadowCoord.xy).x;
 #endif
 
-    // Apply shadow strength
-    return LerpWhiteTo(attenuation, GetShadowStrength());
+    return attenuation;
 }
 
 inline real SampleShadowmap(float4 shadowCoord)
         attenuation = dot(attenuation4, 0.25);
     #else
         #ifdef _SHADOWS_CASCADE //Assume screen space shadows when cascades enabled
-            real fetchesWeights[16];
-            real2 fetchesUV[16];
+            float fetchesWeights[16];
+            float2 fetchesUV[16];
-            attenuation  = fetchesWeights[0]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[0].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[1]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[1].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[2].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[3].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[4].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[5].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[6].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[7].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[8].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[9].xy,  shadowCoord.z));
-            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[10].xy, shadowCoord.z));
-            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[11].xy, shadowCoord.z));
-            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[12].xy, shadowCoord.z));
-            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[13].xy, shadowCoord.z));
-            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[14].xy, shadowCoord.z));
-            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[15].xy, shadowCoord.z));
+            attenuation  = fetchesWeights[0]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[1]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[2]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[3]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[4]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[5]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[6]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[7]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[8]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[9]  * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[9].xy,  shadowCoord.z));
+            attenuation += fetchesWeights[10] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[10].xy, shadowCoord.z));
+            attenuation += fetchesWeights[11] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[11].xy, shadowCoord.z));
+            attenuation += fetchesWeights[12] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[12].xy, shadowCoord.z));
+            attenuation += fetchesWeights[13] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[13].xy, shadowCoord.z));
+            attenuation += fetchesWeights[14] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[14].xy, shadowCoord.z));
+            attenuation += fetchesWeights[15] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[15].xy, shadowCoord.z));
-            real fetchesWeights[9];
-            real2 fetchesUV[9];
+            float fetchesWeights[9];
+            float2 fetchesUV[9];
-            attenuation  = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[0].xy, shadowCoord.z));
-            attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[1].xy, shadowCoord.z));
-            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[2].xy, shadowCoord.z));
-            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[3].xy, shadowCoord.z));
-            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[4].xy, shadowCoord.z));
-            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[5].xy, shadowCoord.z));
-            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[6].xy, shadowCoord.z));
-            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[7].xy, shadowCoord.z));
-            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, real3(fetchesUV[8].xy, shadowCoord.z));
+            attenuation  = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy, shadowCoord.z));
+            attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy, shadowCoord.z));
+            attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy, shadowCoord.z));
+            attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy, shadowCoord.z));
+            attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy, shadowCoord.z));
+            attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy, shadowCoord.z));
+            attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy, shadowCoord.z));
+            attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy, shadowCoord.z));
+            attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(_ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy, shadowCoord.z));
         #endif
     #endif
 #else
 
+#if SHADER_HINT_NICE_QUALITY
+    // Apply shadow strength
+    attenuation = LerpWhiteTo(attenuation, GetShadowStrength());
+#endif
+
-    return (OUTSIDE_SHADOW_BOUNDS(shadowCoord)) ? 1.0 : attenuation;
+    return BEYOND_SHADOW_FAR(shadowCoord) ? 1.0 : attenuation;
 }
 
 inline half ComputeCascadeIndex(float3 positionWS)
     return 4 - dot(weights, half4(4, 3, 2, 1));
 }
 
-float4 ComputeScreenSpaceShadowCoords(float3 positionWS)
+float4 TransformWorldToShadowCoord(float3 positionWS)
-    #ifdef _SHADOWS_CASCADE
+#ifdef _SHADOWS_CASCADE
     half cascadeIndex = ComputeCascadeIndex(positionWS);
     return mul(_WorldToShadow[cascadeIndex], float4(positionWS, 1.0));
 #else
 
 half RealtimeShadowAttenuation(float4 shadowCoord)
 {
+#if NO_SHADOWS
+    return 1.0h;
+#elif SHADOWS_SCREEN
+#else
+
+    return SampleShadowmap(shadowCoord);
+#endif
 }
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

         HLSLINCLUDE
 
         #pragma prefer_hlslcc gles
-        //Keep compiler quiet about Shadows.hlsl. 
+        //Keep compiler quiet about Shadows.hlsl.
         #include "CoreRP/ShaderLibrary/Common.hlsl"
         #include "CoreRP/ShaderLibrary/EntityLighting.hlsl"
         #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
-        SCREENSPACE_TEXTURE(_CameraDepthTexture);
+#if defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+        TEXTURE2D_ARRAY(_CameraDepthTexture);
+#else
+        TEXTURE2D(_CameraDepthTexture);
+#endif // defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+
         SAMPLER(sampler_CameraDepthTexture);
 
         struct VertexInput
             return o;
         }
 
-        half Fragment(Interpolators i) : SV_Target
+        half4 Fragment(Interpolators i) : SV_Target
         {
             UNITY_SETUP_INSTANCE_ID(i);
 #if !defined(UNITY_STEREO_INSTANCING_ENABLED)
 #if UNITY_REVERSED_Z
             deviceDepth = 1 - deviceDepth;
 #endif
-            deviceDepth = 2 * deviceDepth - 1; //NOTE: Currently must massage depth before computing CS position. 
+            deviceDepth = 2 * deviceDepth - 1; //NOTE: Currently must massage depth before computing CS position.
-            
+
-            float4 coords  = ComputeScreenSpaceShadowCoords(wpos);
+            float4 coords  = TransformWorldToShadowCoord(wpos);
 
             return SampleShadowmap(coords);
         }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             // Required to compile gles 2.0 with standard SRP library
             // All shaders must be compiled with HLSLcc and currently only gles is not using HLSLcc by default
             #pragma prefer_hlslcc gles
-            #pragma target 3.0
+            #pragma target 2.0
-            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHATEST_ON
             #pragma shader_feature _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
             #pragma shader_feature _METALLICSPECGLOSSMAP
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _EMISSION
-            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _OCCLUSIONMAP
-
-            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
-            #pragma shader_feature _SPECULAR_SETUP
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment LitPassFragmentNull
+            #pragma fragment ShadowPassFragment
 
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _EMISSION
-            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _OCCLUSIONMAP
-
-            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
-            #pragma shader_feature _SPECULAR_SETUP
-            #pragma vertex LitPassVertex
-            #pragma fragment LitPassFragmentNull
-
-            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

 // Only directional light is supported for lit particles
 // No shadow
 // No distortion
-Shader "LightweightPipeline/Particles/Standard"
+Shader "LightweightPipeline/Particles/Standard (Physically Based)"
 {
     Properties
     {
             #pragma vertex ParticlesLitVertex
             #pragma fragment ParticlesLitFragment
             #pragma multi_compile __ SOFTPARTICLES_ON
-            #pragma target 3.5
+            #pragma target 2.0
 
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON
             #pragma shader_feature _METALLICGLOSSMAP
             #pragma shader_feature _REQUIRE_UV2
+
+            #define NO_SHADOWS 1
 
             #include "LWRP/ShaderLibrary/Particles.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
                 VertexOutputLit o;
-#if _NORMALMAP
-                OutputTangentToWorld(v.tangent, v.normal, o.tangent, o.binormal, o.normal);
-#else
-                o.normal = normalize(TransformObjectToWorldNormal(v.normal));
-#endif
-                o.color = v.color;
+                OUTPUT_NORMAL(v, o);
+
+                o.color = v.color * _Color;
+                o.viewDirShininess.xyz = VertexViewDirWS(GetCameraPositionWS() - o.posWS.xyz);
                 vertTexcoord(v, o);
                 vertFading(o, o.posWS, o.clipPos);
                 return o;
         }
     }
 
-    Fallback "LightweightPipeline/Particles/Standard Unlit"
+    Fallback "LightweightPipeline/Particles/Standard (Simple Lighting)"
     CustomEditor "LightweightStandardParticlesShaderGUI"
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesUnlit.shader

 
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
 
-        _BumpScale("Scale", Float) = 1.0
-        _BumpMap("Normal Map", 2D) = "bump" {}
-
         _EmissionColor("Color", Color) = (0,0,0)
         _EmissionMap("Emission", 2D) = "white" {}
 
                 #pragma prefer_hlslcc gles
                 #pragma multi_compile __ SOFTPARTICLES_ON
                 #pragma multi_compile_fog
-                #pragma target 2.5
+                #pragma target 2.0
-                #pragma shader_feature _NORMALMAP
                 #pragma shader_feature _EMISSION
                 #pragma shader_feature _FADING_ON
                 #pragma shader_feature _REQUIRE_UV2
                     o.posWS.xyz = TransformObjectToWorld(v.vertex.xyz);
                     o.posWS.w = ComputeFogFactor(o.clipPos.z);
                     o.clipPos = TransformWorldToHClip(o.posWS.xyz);
-                    o.color = v.color;
+                    o.color = v.color * _Color;
 
                     vertColor(o.color);
                     vertTexcoord(v, o);
 
                 half4 fragParticleUnlit(VertexOutputLit IN) : SV_Target
                 {
-                    half4 albedo = readTexture(TEXTURE2D_PARAM(_MainTex, sampler_MainTex), IN);
-                    albedo *= _Color;
-
-                    fragColorMode(IN);
-                    fragSoftParticles(IN);
-                    fragCameraFading(IN);
-
-        #if defined(_NORMALMAP)
-                    float3 normal = normalize(UnpackNormalScale(readTexture(TEXTURE2D_PARAM(_BumpMap, sampler_BumpMap), IN), _BumpScale));
-        #else
-                    float3 normal = float3(0,0,1);
-        #endif
-
-        #if defined(_EMISSION)
-                    half3 emission = readTexture(TEXTURE2D_PARAM(_EmissionMap, sampler_EmissionMap), IN).rgb;
-        #else
-                    half3 emission = 0;
-        #endif
+                    half4 albedo = Albedo(IN);
+                    half alpha = AlphaBlendAndTest(albedo.a);
+                    half3 emission = Emission(IN);
+                    half3 diffuse = AlphaModulate(albedo.rgb, alpha);
-                    half4 result = albedo;
-
-        #if defined(_ALPHAMODULATE_ON)
-                    result.rgb = lerp(half3(1.0, 1.0, 1.0), albedo.rgb, albedo.a);
-        #endif
-
-                    result.rgb += emission * _EmissionColor.rgb;
-
-        #if !defined(_ALPHABLEND_ON) && !defined(_ALPHAPREMULTIPLY_ON) && !defined(_ALPHAOVERLAY_ON)
-                    result.a = 1;
-        #endif
-
-        #if defined(_ALPHATEST_ON)
-                    clip(albedo.a - _Cutoff + 0.0001);
-        #endif
+                    half3 result = diffuse + emission;
-                    ApplyFogColor(result.rgb, half3(0, 0, 0), fogFactor);
-                    return result;
+                    ApplyFogColor(result, half3(0, 0, 0), fogFactor);
+                    return half4(result, alpha);
                 }
                 ENDHLSL
             }

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
-            #pragma shader_feature _ALPHATEST_ON 
+            #pragma shader_feature _ALPHATEST_ON
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _EMISSION
 
 
             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragmentSimple
+            #define BUMP_SCALE_NOT_SUPPORTED 1
             #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
             ENDHLSL
         }
-            Tags{"Lightmode" = "ShadowCaster"}
+            Tags{"LightMode" = "ShadowCaster"}
 
             ZWrite On
             ZTest LEqual
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
             #pragma target 2.0
-            
+
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _EMISSION
+            #pragma shader_feature _ALPHATEST_ON
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
 
             //--------------------------------------
             // GPU Instancing
-            #pragma fragment LitPassFragmentSimpleNull
+            #pragma fragment ShadowPassFragment
 
             #include "LWRP/ShaderLibrary/LightweightPassShadow.hlsl"
             ENDHLSL
         {
-            Tags{"Lightmode" = "DepthOnly"}
+            Tags{"LightMode" = "DepthOnly"}
 
             ZWrite On
             ColorMask 0
             #pragma prefer_hlslcc gles
             #pragma target 2.0
 
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
-            #pragma shader_feature _ALPHATEST_ON 
-            #pragma shader_feature _ALPHAPREMULTIPLY_ON
-            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
-            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma shader_feature _NORMALMAP
-            #pragma shader_feature _EMISSION
+            #pragma shader_feature _ALPHATEST_ON
+            #pragma shader_feature _GLOSSINESS_FROM_BASE_ALPHA
-            #pragma vertex LitPassVertex
-            #pragma fragment LitPassFragmentSimpleNull
-        
-            #include "LWRP/ShaderLibrary/LightweightPassLit.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
 

ScriptableRenderPipeline/LightweightPipeline/package.json

     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
     "dependencies": {
-        "com.unity.shadergraph": "1.1.1-preview",
-        "com.unity.postprocessing": "2.0.2-preview",
-        "com.unity.render-pipelines.core": "1.1.1-preview"
+        "com.unity.shadergraph": "1.1.2-preview",
+        "com.unity.postprocessing": "2.0.3-preview",
+        "com.unity.render-pipelines.core": "1.1.2-preview"
-    "version": "1.1.1-preview",
+    "version": "1.1.2-preview",
     "unity": "2018.1"
 }

ScriptableRenderPipeline/LightweightPipeline/sub-package.json

         "com.unity.render-pipelines.core"
     ],
     "dependencies": {
-        "com.unity.shadergraph": "1.1.1-preview"
+        "com.unity.shadergraph": "1.1.2-preview"
     }
 }

ScriptableRenderPipeline/master-package.json

 {
-    "version": "1.1.1-preview",
+    "version": "1.1.2-preview",
-        "com.unity.postprocessing": "2.0.2-preview"
+        "com.unity.postprocessing": "2.0.3-preview"
     },
     "subPackages": [
         "Core",

ScriptableRenderPipeline/LightweightPipeline/LWRP/SceneViewDrawMode.cs

+#if UNITY_EDITOR
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering.LightweightPipeline
+{
+    internal static class SceneViewDrawMode
+    {
+        static bool RejectDrawMode(SceneView.CameraMode cameraMode)
+        {
+            if (cameraMode.drawMode == DrawCameraMode.TexturedWire ||
+                cameraMode.drawMode == DrawCameraMode.ShadowCascades ||
+                cameraMode.drawMode == DrawCameraMode.RenderPaths ||
+                cameraMode.drawMode == DrawCameraMode.AlphaChannel ||
+                cameraMode.drawMode == DrawCameraMode.Overdraw ||
+                cameraMode.drawMode == DrawCameraMode.Mipmaps ||
+                cameraMode.drawMode == DrawCameraMode.SpriteMask ||
+                cameraMode.drawMode == DrawCameraMode.DeferredDiffuse ||
+                cameraMode.drawMode == DrawCameraMode.DeferredSpecular ||
+                cameraMode.drawMode == DrawCameraMode.DeferredSmoothness ||
+                cameraMode.drawMode == DrawCameraMode.DeferredNormal ||
+                cameraMode.drawMode == DrawCameraMode.ValidateAlbedo ||
+                cameraMode.drawMode == DrawCameraMode.ValidateMetalSpecular ||
+                cameraMode.drawMode == DrawCameraMode.ShadowMasks ||
+                cameraMode.drawMode == DrawCameraMode.LightOverlap
+            )
+                return false;
+
+            return true;
+        }
+
+        public static void SetupDrawMode()
+        {
+            ArrayList sceneViewArray = SceneView.sceneViews;
+            foreach (SceneView sceneView in sceneViewArray)
+                sceneView.onValidateCameraMode += RejectDrawMode;
+        }
+
+        public static void ResetDrawMode()
+        {
+            ArrayList sceneViewArray = SceneView.sceneViews;
+            foreach (SceneView sceneView in sceneViewArray)
+                sceneView.onValidateCameraMode -= RejectDrawMode;
+        }
+    }
+}
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/SceneViewDrawMode.cs.meta

+fileFormatVersion: 2
+guid: d7255bed85944a04fa68dd4d1d28022a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl

+#ifndef LIGHTWEIGHT_PASS_DEPTH_ONLY_INCLUDED
+#define LIGHTWEIGHT_PASS_DEPTH_ONLY_INCLUDED
+
+#include "LWRP/ShaderLibrary/Core.hlsl"
+#include "LWRP/ShaderLibrary/InputSurface.hlsl"
+
+struct VertexInput
+{
+    float4 position     : POSITION;
+    float2 texcoord     : TEXCOORD0;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct VertexOutput
+{
+    float2 uv           : TEXCOORD0;
+    float4 clipPos      : SV_POSITION;
+};
+
+VertexOutput DepthOnlyVertex(VertexInput v)
+{
+    VertexOutput o = (VertexOutput)0;
+    UNITY_SETUP_INSTANCE_ID(v);
+
+    o.uv = TransformMainTextureCoord(v.texcoord);
+    o.clipPos = TransformObjectToHClip(v.position.xyz);
+    return o;
+}
+
+half4 DepthOnlyFragment(VertexOutput IN) : SV_TARGET
+{
+    Alpha(MainTexture(IN.uv).a);
+    return 0;
+}
+#endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl.meta

+fileFormatVersion: 2
+guid: 0acd4fdbcf0cf654a9cdf3e9ccc2edce
+timeCreated: 1488965025
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

+// ------------------------------------------
+// Only directional light is supported for lit particles
+// No shadow
+// No distortion
+Shader "LightweightPipeline/Particles/Standard (Simple Lighting)"
+{
+    Properties
+    {
+        _MainTex("Albedo", 2D) = "white" {}
+        _Color("Color", Color) = (1,1,1,1)
+
+        _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        _Shininess("Shininess", Range(0.01, 1.0)) = 1.0
+        _GlossMapScale("Smoothness Factor", Range(0.0, 1.0)) = 1.0
+
+        _Glossiness("Glossiness", Range(0.0, 1.0)) = 0.5
+        [Enum(Specular Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 0
+
+        [HideInInspector] _SpecSource("Specular Color Source", Float) = 0.0
+        _SpecColor("Specular", Color) = (1.0, 1.0, 1.0)
+        _SpecGlossMap("Specular", 2D) = "white" {}
+        [HideInInspector] _GlossinessSource("Glossiness Source", Float) = 0.0
+        [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
+        [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
+
+        [HideInInspector] _BumpScale("Scale", Float) = 1.0
+        [NoScaleOffset] _BumpMap("Normal Map", 2D) = "bump" {}
+
+        _EmissionColor("Color", Color) = (0,0,0)
+        _EmissionMap("Emission", 2D) = "white" {}
+
+        _SoftParticlesNearFadeDistance("Soft Particles Near Fade", Float) = 0.0
+        _SoftParticlesFarFadeDistance("Soft Particles Far Fade", Float) = 1.0
+        _CameraNearFadeDistance("Camera Near Fade", Float) = 1.0
+        _CameraFarFadeDistance("Camera Far Fade", Float) = 2.0
+
+        // Hidden properties
+        [HideInInspector] _Mode("__mode", Float) = 0.0
+        [HideInInspector] _FlipbookMode("__flipbookmode", Float) = 0.0
+        [HideInInspector] _LightingEnabled("__lightingenabled", Float) = 1.0
+        [HideInInspector] _EmissionEnabled("__emissionenabled", Float) = 0.0
+        [HideInInspector] _BlendOp("__blendop", Float) = 0.0
+        [HideInInspector] _SrcBlend("__src", Float) = 1.0
+        [HideInInspector] _DstBlend("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite("__zw", Float) = 1.0
+        [HideInInspector] _Cull("__cull", Float) = 2.0
+        [HideInInspector] _SoftParticlesEnabled("__softparticlesenabled", Float) = 0.0
+        [HideInInspector] _CameraFadingEnabled("__camerafadingenabled", Float) = 0.0
+        [HideInInspector] _SoftParticleFadeParams("__softparticlefadeparams", Vector) = (0,0,0,0)
+        [HideInInspector] _CameraFadeParams("__camerafadeparams", Vector) = (0,0,0,0)
+    }
+
+    SubShader
+    {
+        Tags{"RenderType" = "Opaque" "IgnoreProjector" = "True" "PreviewType" = "Plane" "PerformanceChecks" = "False" "RenderPipeline" = "LightweightPipeline"}
+
+        BlendOp[_BlendOp]
+        Blend[_SrcBlend][_DstBlend]
+        ZWrite[_ZWrite]
+        Cull[_Cull]
+
+        Pass
+        {
+            Tags {"LightMode" = "LightweightForward"}
+            HLSLPROGRAM
+            // Required to compile gles 2.0 with standard srp library
+            #pragma prefer_hlslcc gles
+            #pragma vertex ParticlesLitVertex
+            #pragma fragment ParticlesLitFragment
+            #pragma multi_compile __ SOFTPARTICLES_ON
+            #pragma target 2.0
+
+            #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON
+            #pragma shader_feature _ _SPECGLOSSMAP _SPECULAR_COLOR
+            #pragma shader_feature _ _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature _NORMALMAP
+            #pragma shader_feature _EMISSION
+            #pragma shader_feature _FADING_ON
+            #pragma shader_feature _REQUIRE_UV2
+
+            #define BUMP_SCALE_NOT_SUPPORTED 1
+            #define NO_SHADOWS 1
+
+            #include "LWRP/ShaderLibrary/Particles.hlsl"
+            #include "LWRP/ShaderLibrary/Lighting.hlsl"
+
+            VertexOutputLit ParticlesLitVertex(appdata_particles v)
+            {
+                VertexOutputLit o;
+
+                OUTPUT_NORMAL(v, o);
+
+                o.color = v.color * _Color;
+                o.posWS.xyz = TransformObjectToWorld(v.vertex.xyz).xyz;
+                o.posWS.w = ComputeFogFactor(o.clipPos.z);
+                o.clipPos = TransformWorldToHClip(o.posWS.xyz);
+                o.viewDirShininess.xyz = VertexViewDirWS(GetCameraPositionWS() - o.posWS.xyz);
+                o.viewDirShininess.w = _Shininess * 128.0h;
+                vertTexcoord(v, o);
+                vertFading(o, o.posWS, o.clipPos);
+                return o;
+            }
+
+            half4 ParticlesLitFragment(VertexOutputLit IN) : SV_Target
+            {
+                half4 albedo = Albedo(IN);
+                half alpha = AlphaBlendAndTest(albedo.a);
+                half3 diffuse = AlphaModulate(albedo.rgb, alpha);
+                half3 normalTS = NormalTS(IN);
+                half3 emission = Emission(IN);
+                half4 specularGloss = SpecularGloss(IN, albedo.a);
+                half shininess = IN.viewDirShininess.w;
+
+                InputData inputData;
+                InitializeInputData(IN, normalTS, inputData);
+
+                half4 color = LightweightFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
+
+                ApplyFog(color.rgb, inputData.fogCoord);
+                return color;
+            }
+
+            ENDHLSL
+        }
+    }
+
+    Fallback "LightweightPipeline/Particles/Standard Unlit"
+    CustomEditor "LightweightStandardParticlesShaderGUI"
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader.meta

+fileFormatVersion: 2
+guid: 8516d7a69675844a7a0b7095af7c46af
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: