Merge pull request #593 from Unity-Technologies/LightweightPipeline

Lightweight pipeline

ScriptableRenderPipeline/Core/CoreUtils.cs

         public static Color clearColorAllBlack { get { return new Color(0f, 0f, 0f, 0f); } }
 
         // Render Target Management.
-        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-            cmd.SetRenderTarget(buffer, miplevel, cubemapFace);
+            cmd.SetRenderTarget(buffer, miplevel, cubemapFace, depthSlice);
-        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.None, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.None, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-            SetRenderTarget(cmd, buffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace);
+            SetRenderTarget(cmd, buffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace, depthSlice);
-        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-            SetRenderTarget(cmd, colorBuffer, depthBuffer, ClearFlag.None, clearColorAllBlack, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, ClearFlag.None, clearColorAllBlack, miplevel, cubemapFace, depthSlice);
-        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-            SetRenderTarget(cmd, colorBuffer, depthBuffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace);
+            SetRenderTarget(cmd, colorBuffer, depthBuffer, clearFlag, clearColorAllBlack, miplevel, cubemapFace, depthSlice);
-        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
-            cmd.SetRenderTarget(colorBuffer, depthBuffer, miplevel, cubemapFace);
+            cmd.SetRenderTarget(colorBuffer, depthBuffer, miplevel, cubemapFace, depthSlice);
 
             if (clearFlag != ClearFlag.None)
                 cmd.ClearRenderTarget((clearFlag & ClearFlag.Depth) != 0, (clearFlag & ClearFlag.Color) != 0, clearColor);

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetEditor.cs

 
             public static GUIContent renderScaleLabel = new GUIContent("Render Scale", "Allows game to render at a resolution different than native resolution. UI is always rendered at native resolution.");
 
-            public static GUIContent maxAdditionalPixelLightsLabel = new GUIContent("Max Additional Pixel Lights",
-                    "Controls the additional per-pixel lights that run in fragment light loop.");
+            public static GUIContent maxPixelLightsLabel = new GUIContent("Max Pixel Lights",
+                    "Controls the amount of pixel lights that run in fragment light loop. Lights are sorted and culled per-object.");
 
             public static GUIContent enableVertexLightLabel = new GUIContent("Enable Vertex Light",
                     "If enabled, shades additional lights exceeding maxAdditionalPixelLights per-vertex up to the maximum of 8 lights.");
             public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing applied to all cameras.");
         }
 
-        private int kMaxSupportedAdditionalPixelLights = 8;
+        private int kMaxSupportedPixelLights = 8;
-        private SerializedProperty m_MaxAdditionalPixelLights;
+        private SerializedProperty m_MaxPixelLights;
         private SerializedProperty m_SupportsVertexLightProp;
         private SerializedProperty m_SupportSoftParticlesProp;
         private SerializedProperty m_ShadowTypeProp;
         void OnEnable()
         {
             m_RenderScale = serializedObject.FindProperty("m_RenderScale");
-            m_MaxAdditionalPixelLights = serializedObject.FindProperty("m_MaxAdditionalPixelLights");
+            m_MaxPixelLights = serializedObject.FindProperty("m_MaxPixelLights");
             m_SupportsVertexLightProp = serializedObject.FindProperty("m_SupportsVertexLight");
             m_SupportSoftParticlesProp = serializedObject.FindProperty("m_SupportSoftParticles");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
             m_RenderScale.floatValue = EditorGUILayout.Slider(m_RenderScale.floatValue, 0.1f, 1.0f);
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.BeginHorizontal();
-            EditorGUILayout.LabelField(Styles.maxAdditionalPixelLightsLabel);
-            m_MaxAdditionalPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxAdditionalPixelLights.intValue, 0, kMaxSupportedAdditionalPixelLights);
+            EditorGUILayout.LabelField(Styles.maxPixelLightsLabel);
+            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, kMaxSupportedPixelLights);
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_SupportSoftParticlesProp, Styles.enableSoftParticles);

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightCameraEditor.cs

     [CanEditMultipleObjects]
     public class LightweightameraEditor : Editor
     {
-        // Manually entered rendering path names/values, since we want to show them
-        // in different order than they appear in the enum.
-        private static readonly GUIContent[] kCameraRenderPaths =
-        {
-            new GUIContent("Use Graphics Settings"),
-            new GUIContent("Forward"),
-            new GUIContent("Deferred"),
-            new GUIContent("Legacy Vertex Lit"),
-            new GUIContent("Legacy Deferred (light prepass)")
-        };
-
-        private static readonly int[] kCameraRenderPathValues =
-        {
-            (int) RenderingPath.UsePlayerSettings,
-            (int) RenderingPath.Forward,
-            (int) RenderingPath.DeferredShading,
-            (int) RenderingPath.VertexLit,
-            (int) RenderingPath.DeferredLighting
-        };
-
-            public readonly GUIContent renderingPathWarning = new GUIContent("Lightweight Pipeline only supports Forward rendering path.");
+            public readonly GUIContent renderingPathLabel = new GUIContent("Rendering Path");
+            public readonly GUIContent[] renderingPathOptions = { new GUIContent("Forward") };
+            public readonly GUIContent renderingPathInfo = new GUIContent("Lightweight Pipeline only supports Forward rendering path.");
             public readonly GUIContent clipingPlanesLabel = new GUIContent("Clipping Planes", "Distances from the camera to start and stop rendering.");
             public readonly GUIContent nearPlaneLabel = new GUIContent("Near", "The closest point relative to the camera that drawing will occur.");
             public readonly GUIContent farPlaneLabel = new GUIContent("Far", "The furthest point relative to the camera that drawing will occur.");
+        private static readonly int[] kRenderingPathValues = {0};
         private static Styles s_Styles;
         private LightweightPipelineAsset lightweightPipeline;
 
         // Animation Properties
         private bool IsSameClearFlags { get { return !clearFlags.hasMultipleDifferentValues; } }
         private bool IsSameOrthographic { get { return !orthographic.hasMultipleDifferentValues; } }
-        private bool IsSameRenderingPath { get { return !renderingPath.hasMultipleDifferentValues; } }
-
-        private bool ShowRenderingPathWarning { get { return IsSameRenderingPath && renderingPath.intValue != (int)RenderingPath.Forward; } }
 
         readonly AnimBool showBGColorAnim = new AnimBool();
         readonly AnimBool showOrthoAnim = new AnimBool();
             orthographicSize = serializedObject.FindProperty("orthographic size");
             depth = serializedObject.FindProperty("m_Depth");
             cullingMask = serializedObject.FindProperty("m_CullingMask");
-            renderingPath = serializedObject.FindProperty("m_RenderingPath");
             occlusionCulling = serializedObject.FindProperty("m_OcclusionCulling");
             targetTexture = serializedObject.FindProperty("m_TargetTexture");
             HDR = serializedObject.FindProperty("m_HDR");
 
         public void DrawRenderingPath()
         {
-            EditorGUILayout.IntPopup(renderingPath, kCameraRenderPaths, kCameraRenderPathValues,
-                new GUIContent("Rendering Path"));
-
-            if (ShowRenderingPathWarning)
+            using (new EditorGUI.DisabledScope(true))
-                EditorGUILayout.HelpBox(s_Styles.renderingPathWarning.text, MessageType.Warning);
-
-                // Button (align lower right)
-                if (GUI.Button(new Rect(0.0f, 0.0f, 60.0f, 20.0f), s_Styles.fixNow))
-                    renderingPath.intValue = (int) RenderingPath.Forward;
+                EditorGUILayout.IntPopup(s_Styles.renderingPathLabel, 0, s_Styles.renderingPathOptions, kRenderingPathValues);
+
+            EditorGUILayout.HelpBox(s_Styles.renderingPathInfo.text, MessageType.Info);
         }
 
         public void DrawTargetTexture()

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightLightEditor.cs

                 if (group.visible) DrawRuntimeShadow();
             EditorGUI.indentLevel -= 1;
 
-            if (RealtimeShadowsWarningValue || BakingWarningValue)
-            {
+            if (BakingWarningValue)
+                EditorGUILayout.HelpBox(s_Styles.BakingWarning.text, MessageType.Warning);
+
+            if (RealtimeShadowsWarningValue)
-            }
 
             EditorGUILayout.Space();
         }

ScriptableRenderPipeline/LightweightPipeline/LightweightConstantBuffer.cs

     public static class PerFrameBuffer
     {
         public static int _GlossyEnvironmentColor;
+        public static int _SubtractiveShadowColor;
     }
 
     public static class PerCameraBuffer

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

         public bool shadowsRendered;
     }
 
+    public enum MixedLightingSetup
+    {
+        None = 0,
+        ShadowMask,
+        Subtractive,
+    };
+
     public static class CameraRenderTargetID
     {
         // Camera color target. Not used when camera is rendering to backbuffer or camera
         private readonly LightweightPipelineAsset m_Asset;
 
         // Maximum amount of visible lights the shader can process. This controls the constant global light buffer size.
-        // It must match the MAX_VISIBLE_LIGHTS in LightweightCore.cginc
-        private static readonly int kMaxVisibleAdditionalLights = 16;
+        // It must match the MAX_VISIBLE_LIGHTS in LightweightInput.cginc
+        private static readonly int kMaxVisibleLights = 16;
-        // Lights are culled per-object. This holds the maximum amount of additional lights that can shade each object.
+        // Lights are culled per-object. This holds the maximum amount of lights that can be shaded per-object.
-        private static readonly int kMaxPerObjectAdditionalLights = 8;
+        private static readonly int kMaxPerObjectLights = 8;
+
+        private static readonly int kMaxVertexLights = 4;
-        private Vector4[] m_LightPositions = new Vector4[kMaxVisibleAdditionalLights];
-        private Vector4[] m_LightColors = new Vector4[kMaxVisibleAdditionalLights];
-        private Vector4[] m_LightDistanceAttenuations = new Vector4[kMaxVisibleAdditionalLights];
-        private Vector4[] m_LightSpotDirections = new Vector4[kMaxVisibleAdditionalLights];
-        private Vector4[] m_LightSpotAttenuations = new Vector4[kMaxVisibleAdditionalLights];
+        private Vector4[] m_LightPositions = new Vector4[kMaxVisibleLights];
+        private Vector4[] m_LightColors = new Vector4[kMaxVisibleLights];
+        private Vector4[] m_LightDistanceAttenuations = new Vector4[kMaxVisibleLights];
+        private Vector4[] m_LightSpotDirections = new Vector4[kMaxVisibleLights];
+        private Vector4[] m_LightSpotAttenuations = new Vector4[kMaxVisibleLights];
-        private Camera m_CurrCamera = null;
+        private Camera m_CurrCamera;
 
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
         private RenderTargetIdentifier m_CopyDepth;
         private RenderTargetIdentifier m_Color;
 
-        private bool m_IntermediateTextureArray = false;
-        private bool m_RequiredDepth = false;
+        private bool m_IntermediateTextureArray;
+        private bool m_RequiredDepth;
+        private MixedLightingSetup m_MixedLightingSetup;
 
         private const int kShadowDepthBufferBits = 16;
         private const int kCameraDepthBufferBits = 32;
             BuildShadowSettings();
 
             PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
+            PerFrameBuffer._SubtractiveShadowColor = Shader.PropertyToID("_SubtractiveShadowColor");
 
             // Lights are culled per-camera. Therefore we need to reset light buffers on each camera render
             PerCameraBuffer._MainLightPosition = Shader.PropertyToID("_MainLightPosition");
             Shader.globalRenderPipeline = "LightweightPipeline";
 
             m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
-            m_BlitMaterial = new Material(m_Asset.BlitShader)
-            {
-                hideFlags = HideFlags.HideAndDontSave
-            };
-
-            m_CopyDepthMaterial = new Material(m_Asset.CopyDepthShader)
-            {
-                hideFlags = HideFlags.HideAndDontSave
-            };
+            m_BlitMaterial = CoreUtils.CreateEngineMaterial(m_Asset.BlitShader);
+            m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(m_Asset.CopyDepthShader);
         }
 
         public override void Dispose()
             // instead this should be forced when using SRP, since all SRP use linear lighting.
             GraphicsSettings.lightsUseLinearIntensity = true;
 
-            SetupPerFrameShaderConstants(ref context);
+            SetupPerFrameShaderConstants();
 
             // Sort cameras array by camera depth
             Array.Sort(cameras, m_CameraComparer);
         private void DepthPass(ref ScriptableRenderContext context)
         {
             CommandBuffer cmd = CommandBufferPool.Get("Depth Prepass");
-            cmd.SetRenderTarget(m_DepthRT);
+            SetRenderTarget(cmd, m_DepthRT);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
 
             };
 
             context.DrawRenderers(m_CullResults.visibleRenderers, ref opaqueDrawSettings, opaqueFilterSettings);
-            context.DrawSkybox(m_CurrCamera);
+
+            if (m_CurrCamera.clearFlags == CameraClearFlags.Skybox)
+                context.DrawSkybox(m_CurrCamera);
         }
 
         private void AfterOpaque(ref ScriptableRenderContext context, FrameRenderingConfiguration config)
             {
                 RenderTargetIdentifier colorRT = (m_IsOffscreenCamera) ? BuiltinRenderTextureType.CameraTarget : m_ColorRT;
                 CopyTexture(cmd, m_DepthRT, m_CopyDepth, m_CopyDepthMaterial);
-                SetupRenderTargets(cmd, colorRT, m_CopyDepth);
+                SetRenderTarget(cmd, colorRT, m_CopyDepth);
             }
 
             context.ExecuteCommandBuffer(cmd);
             if (msaaEnabled)
             {
                 configuration |= FrameRenderingConfiguration.Msaa;
-                intermediateTexture = !LightweightUtils.PlatformSupportsMSAABackBuffer();
+                intermediateTexture = intermediateTexture || !LightweightUtils.PlatformSupportsMSAABackBuffer();
             }
 
             Rect cameraRect = m_CurrCamera.rect;
 
             if (m_RequiredDepth)
             {
-                cmd.GetTemporaryRT(CameraRenderTargetID.depth, rtWidth, rtHeight, kCameraDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
+                RenderTextureDescriptor depthRTDesc = new RenderTextureDescriptor(rtWidth, rtHeight, RenderTextureFormat.Depth, kCameraDepthBufferBits);
+                cmd.GetTemporaryRT(CameraRenderTargetID.depth, depthRTDesc, FilterMode.Bilinear);
-                    cmd.GetTemporaryRT(CameraRenderTargetID.depthCopy, rtWidth, rtHeight, kCameraDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
+                    cmd.GetTemporaryRT(CameraRenderTargetID.depthCopy, depthRTDesc, FilterMode.Bilinear);
+            RenderTextureDescriptor colorRTDesc = new RenderTextureDescriptor(rtWidth, rtHeight, m_ColorFormat, kCameraDepthBufferBits);
+            colorRTDesc.msaaSamples = msaaSamples;
+            colorRTDesc.enableRandomWrite = false;
+
-                cmd.GetTemporaryRT(CameraRenderTargetID.color, rtWidth, rtHeight, kCameraDepthBufferBits,
-                    FilterMode.Bilinear, m_ColorFormat, RenderTextureReadWrite.Default, msaaSamples);
+                cmd.GetTemporaryRT(CameraRenderTargetID.color, colorRTDesc, FilterMode.Bilinear);
                 m_CurrCameraColorRT = m_ColorRT;
             }
 
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.BeforeTransparentPostProcess))
-            {
-                cmd.GetTemporaryRT(CameraRenderTargetID.copyColor, rtWidth, rtHeight, kCameraDepthBufferBits,
-                    FilterMode.Bilinear, m_ColorFormat, RenderTextureReadWrite.Default, msaaSamples);
-            }
+                cmd.GetTemporaryRT(CameraRenderTargetID.copyColor, colorRTDesc, FilterMode.Point);
         }
 
         private void SetupIntermediateResourcesStereo(CommandBuffer cmd, int msaaSamples)
 
         private void InitializeLightData(VisibleLight[] visibleLights, out LightData lightData)
         {
-            int visibleLightsCount = visibleLights.Length;
+            int visibleLightsCount = Math.Min(visibleLights.Length, m_Asset.MaxPixelLights);
             m_SortedLightIndexMap.Clear();
 
             lightData.shadowsRendered = false;
                 lightData.mainLightIndex = SortLights(visibleLights);
 
             // If we have a main light we don't shade it in the per-object light loop. We also remove it from the per-object cull list
-            int additionalLightsCount = (lightData.mainLightIndex > 0) ? visibleLightsCount - 1 : visibleLightsCount;
-            additionalLightsCount = Math.Min(additionalLightsCount, kMaxPerObjectAdditionalLights);
+            int mainLightPresent = (lightData.mainLightIndex >= 0) ? 1 : 0;
+            int additionalPixelLightsCount = visibleLightsCount - mainLightPresent;
+            int vertexLightCount = (m_Asset.SupportsVertexLight) ? Math.Min(visibleLights.Length, kMaxPerObjectLights) - additionalPixelLightsCount : 0;
+            vertexLightCount = Math.Min(vertexLightCount, kMaxVertexLights);
-            int pixelLightsCount = Math.Min(additionalLightsCount, m_Asset.MaxAdditionalPixelLights);
-            int vertexLightCount = (m_Asset.SupportsVertexLight) ? additionalLightsCount - pixelLightsCount : 0;
+            lightData.pixelAdditionalLightsCount = additionalPixelLightsCount;
+            lightData.totalAdditionalLightsCount = additionalPixelLightsCount + vertexLightCount;
-            lightData.pixelAdditionalLightsCount = pixelLightsCount;
-            lightData.totalAdditionalLightsCount = pixelLightsCount + vertexLightCount;
+            m_MixedLightingSetup = MixedLightingSetup.None;
         }
 
         private int SortLights(VisibleLight[] visibleLights)
             int totalVisibleLights = visibleLights.Length;
             bool shadowsEnabled = m_Asset.AreShadowsEnabled();
 
-            if (totalVisibleLights == 0)
+            if (totalVisibleLights == 0 || m_Asset.MaxPixelLights == 0)
                 return -1;
 
             int brighestDirectionalIndex = -1;
         private void InitializeLightConstants(VisibleLight[] lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightDistanceAttenuation, out Vector4 lightSpotDir,
             out Vector4 lightSpotAttenuation)
         {
+            float directContributionNotBaked = 1.0f;
-            lightDistanceAttenuation = new Vector4(0.0f, 1.0f, 0.0f, 0.0f);
+            lightDistanceAttenuation = new Vector4(0.0f, 1.0f, 0.0f, directContributionNotBaked);
             lightSpotDir = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
             lightSpotAttenuation = new Vector4(0.0f, 1.0f, 0.0f, 0.0f);
 
                 return;
 
-            VisibleLight light = lights[lightIndex];
-            if (light.lightType == LightType.Directional)
+            VisibleLight lightData = lights[lightIndex];
+            if (lightData.lightType == LightType.Directional)
-                Vector4 dir = -light.localToWorld.GetColumn(2);
+                Vector4 dir = -lightData.localToWorld.GetColumn(2);
-                Vector4 pos = light.localToWorld.GetColumn(3);
+                Vector4 pos = lightData.localToWorld.GetColumn(3);
-            lightColor = light.finalColor;
+            lightColor = lightData.finalColor;
-            if (light.lightType != LightType.Directional)
+            if (lightData.lightType != LightType.Directional)
             {
                 // Light attenuation in lightweight matches the unity vanilla one.
                 // attenuation = 1.0 / 1.0 + distanceToLightSqr * quadraticAttenuation
                 // with one MAD instruction
                 // smoothFactor =  distanceSqr * (1.0 / (fadeDistanceSqr - lightRangeSqr)) + (-lightRangeSqr / (fadeDistanceSqr - lightRangeSqr)
                 //                 distanceSqr *           oneOverFadeRangeSqr             +              lightRangeSqrOverFadeRangeSqr
-                float lightRangeSqr = light.range * light.range;
+                float lightRangeSqr = lightData.range * lightData.range;
-                lightDistanceAttenuation = new Vector4(quadAtten, oneOverFadeRangeSqr, lightRangeSqrOverFadeRangeSqr, 0.0f);
+                lightDistanceAttenuation = new Vector4(quadAtten, oneOverFadeRangeSqr, lightRangeSqrOverFadeRangeSqr, directContributionNotBaked);
-            if (light.lightType == LightType.Spot)
+            if (lightData.lightType == LightType.Spot)
-                Vector4 dir = light.localToWorld.GetColumn(2);
+                Vector4 dir = lightData.localToWorld.GetColumn(2);
                 lightSpotDir = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f);
 
                 // Spot Attenuation with a linear falloff can be defined as
                 // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange)
                 // If we precompute the terms in a MAD instruction
-                float spotAngle = Mathf.Deg2Rad * light.spotAngle;
+                float spotAngle = Mathf.Deg2Rad * lightData.spotAngle;
                 float cosOuterAngle = Mathf.Cos(spotAngle * 0.5f);
                 float cosInneAngle = Mathf.Cos(spotAngle * 0.25f);
                 float smoothAngleRange = cosInneAngle - cosOuterAngle;
                 float invAngleRange = 1.0f / smoothAngleRange;
                 float add = -cosOuterAngle * invAngleRange;
                 lightSpotAttenuation = new Vector4(invAngleRange, add, 0.0f);
+            }
+
+            Light light = lightData.light;
+            if (light.bakingOutput.lightmapBakeType == LightmapBakeType.Mixed)
+            {
+                // TODO: Add support to shadow mask
+                if (m_MixedLightingSetup == MixedLightingSetup.None && lightData.light.shadows != LightShadows.None)
+                {
+                    m_MixedLightingSetup = MixedLightingSetup.Subtractive;
+                    lightDistanceAttenuation.w = 0.0f;
+                }
-        private void SetupPerFrameShaderConstants(ref ScriptableRenderContext context)
+        private void SetupPerFrameShaderConstants()
+
+            // Used when subtractive mode is selected
+            Shader.SetGlobalColor(PerFrameBuffer._SubtractiveShadowColor, RenderSettings.subtractiveShadowColor.linear);
         }
 
         private void SetupShaderLightConstants(CommandBuffer cmd, VisibleLight[] lights, ref LightData lightData)
             Vector4 lightPos, lightColor, lightDistanceAttenuation, lightSpotDir, lightSpotAttenuation;
             InitializeLightConstants(lights, lightIndex, out lightPos, out lightColor, out lightDistanceAttenuation, out lightSpotDir, out lightSpotAttenuation);
 
+            if (lightIndex >= 0)
+            {
+                LightType mainLightType = lights[lightIndex].lightType;
+                Light mainLight = lights[lightIndex].light;
+
+                if (LightweightUtils.IsSupportedCookieType(mainLightType) && mainLight.cookie != null)
+                {
+                    Matrix4x4 lightCookieMatrix;
+                    LightweightUtils.GetLightCookieMatrix(lights[lightIndex], out lightCookieMatrix);
+                    cmd.SetGlobalTexture(PerCameraBuffer._MainLightCookie, mainLight.cookie);
+                    cmd.SetGlobalMatrix(PerCameraBuffer._WorldToLight, lightCookieMatrix);
+                }
+            }
+
-
-            if (lightIndex >= 0 && LightweightUtils.IsSupportedCookieType(lights[lightIndex].lightType) && lights[lightIndex].light.cookie != null)
-            {
-                Matrix4x4 lightCookieMatrix;
-                LightweightUtils.GetLightCookieMatrix(lights[lightIndex], out lightCookieMatrix);
-                cmd.SetGlobalTexture(PerCameraBuffer._MainLightCookie, lights[lightIndex].light.cookie);
-                cmd.SetGlobalMatrix(PerCameraBuffer._WorldToLight, lightCookieMatrix);
-            }
         }
 
         private void SetupAdditionalListConstants(CommandBuffer cmd, VisibleLight[] lights, ref LightData lightData)
             for (int i = 0; i < lights.Length; ++i)
                 perObjectLightIndexMap[i] = -1;
 
-            for (int i = 0; i < lights.Length && additionalLightIndex < kMaxVisibleAdditionalLights; ++i)
+            for (int i = 0; i < lights.Length && additionalLightIndex < kMaxVisibleLights; ++i)
             {
                 if (i != lightData.mainLightIndex)
                 {
             }
             m_CullResults.SetLightIndexMap(perObjectLightIndexMap);
 
-            cmd.SetGlobalVector(PerCameraBuffer._AdditionalLightCount, new Vector4 (lightData.pixelAdditionalLightsCount,
+            cmd.SetGlobalVector(PerCameraBuffer._AdditionalLightCount, new Vector4(lightData.pixelAdditionalLightsCount,
-            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightPosition, m_LightPositions);
-            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightColor, m_LightColors);
-            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightDistanceAttenuation, m_LightDistanceAttenuations);
-            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightSpotDir, m_LightSpotDirections);
-            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightSpotAttenuation, m_LightSpotAttenuations);
+            cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightPosition, m_LightPositions);
+            cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightColor, m_LightColors);
+            cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightDistanceAttenuation, m_LightDistanceAttenuations);
+            cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightSpotDir, m_LightSpotDirections);
+            cmd.SetGlobalVectorArray(PerCameraBuffer._AdditionalLightSpotAttenuation, m_LightSpotAttenuations);
+            float strength = 1.0f - light.shadowStrength;
+            float nearPlane = light.shadowNearPlane;
             float shadowResolution = m_ShadowSlices[0].shadowResolution;
 
             const int maxShadowCascades = 4;
 
             cmd.SetGlobalMatrixArray("_WorldToShadow", shadowMatrices);
             cmd.SetGlobalVectorArray("_DirShadowSplitSpheres", m_DirectionalShadowSplitDistances);
-            cmd.SetGlobalVector("_ShadowData", new Vector4(0.0f, bias, normalBias, 0.0f));
+            cmd.SetGlobalVector("_ShadowData", new Vector4(strength, bias, normalBias, nearPlane));
             cmd.SetGlobalFloatArray("_PCFKernel", pcfKernel);
         }
 
-            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
-            // Currently only directional light cookie is supported
-            LightweightUtils.SetKeyword(cmd, "_MAIN_LIGHT_COOKIE", mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
-            LightweightUtils.SetKeyword (cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
-            LightweightUtils.SetKeyword (cmd, "_MAIN_SPOT_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Spot);
-            LightweightUtils.SetKeyword (cmd, "_MAIN_POINT_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Point);
-            LightweightUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, "_MAIN_LIGHT_COOKIE", mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
+            CoreUtils.SetKeyword(cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
+            CoreUtils.SetKeyword(cmd, "_MAIN_SPOT_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Spot);
+            CoreUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);
+            CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SHADOWMASK", m_MixedLightingSetup == MixedLightingSetup.ShadowMask);
+            CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SUBTRACTIVE", m_MixedLightingSetup == MixedLightingSetup.Subtractive);
 
             string[] shadowKeywords = new string[] { "_HARD_SHADOWS", "_SOFT_SHADOWS", "_HARD_SHADOWS_CASCADES", "_SOFT_SHADOWS_CASCADES" };
             for (int i = 0; i < shadowKeywords.Length; ++i)
                 cmd.EnableShaderKeyword(shadowKeywords[keywordIndex]);
             }
 
-            LightweightUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_Asset.SupportsSoftParticles);
+            CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", m_Asset.SupportsSoftParticles);
         }
 
         private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
             if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
                 return false;
 
-            var setRenderTargetCommandBuffer = CommandBufferPool.Get();
-            setRenderTargetCommandBuffer.name = "Render packed shadows";
-            setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
+            var cmd = CommandBufferPool.Get();
+            cmd.name = "Render packed shadows";
+            cmd.GetTemporaryRT(m_ShadowMapRTID, m_ShadowSettings.shadowAtlasWidth,
-            setRenderTargetCommandBuffer.SetRenderTarget(m_ShadowMapRT);
-            setRenderTargetCommandBuffer.ClearRenderTarget(true, true, Color.black);
-            context.ExecuteCommandBuffer(setRenderTargetCommandBuffer);
-            CommandBufferPool.Release(setRenderTargetCommandBuffer);
+            SetRenderTarget(cmd, m_ShadowMapRT, ClearFlag.All);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
 
             float shadowNearPlane = m_Asset.ShadowNearOffset;
             Vector3 splitRatio = m_ShadowSettings.directionalLightCascades;
                     depthRT = m_DepthRT;
             }
 
-            SetupRenderTargets(cmd, colorRT, depthRT);
-            // 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
-            if (m_CurrCamera.clearFlags != CameraClearFlags.Nothing)
+            if (ForceClear())
-                bool clearDepth = (m_CurrCamera.clearFlags != CameraClearFlags.Nothing);
-                bool clearColor = (m_CurrCamera.clearFlags == CameraClearFlags.Color || m_CurrCamera.clearFlags == CameraClearFlags.Skybox);
-                cmd.ClearRenderTarget(clearDepth, clearColor, m_CurrCamera.backgroundColor.linear);
+                SetRenderTarget(cmd, colorRT, depthRT, ClearFlag.All);
+            }
+            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);
             }
 
             context.ExecuteCommandBuffer(cmd);
             var cmd = CommandBufferPool.Get("Blit");
             if (m_IntermediateTextureArray)
             {
-                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1);
+                SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
                 cmd.Blit(m_CurrCameraColorRT, BuiltinRenderTextureType.CurrentActive);
             }
             else if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture))
                     Blit(cmd, renderingConfig, BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
             }
 
-            SetupRenderTargets(cmd, BuiltinRenderTextureType.CameraTarget, BuiltinRenderTextureType.None);
+            SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
 
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
             return settings;
         }
 
-        private void SetupRenderTargets(CommandBuffer cmd, RenderTargetIdentifier colorRT, RenderTargetIdentifier depthRT)
+        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, ClearFlag clearFlag = ClearFlag.None)
-            if (depthRT != BuiltinRenderTextureType.None)
-                cmd.SetRenderTarget(colorRT, depthRT, 0, CubemapFace.Unknown, depthSlice);
-            else
-                cmd.SetRenderTarget(colorRT, 0, CubemapFace.Unknown, depthSlice);
+            CoreUtils.SetRenderTarget(cmd, colorRT, clearFlag, m_CurrCamera.backgroundColor.linear, 0, CubemapFace.Unknown, depthSlice);
+        }
+
+        private void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier colorRT, RenderTargetIdentifier depthRT, ClearFlag clearFlag = ClearFlag.None)
+        {
+            if (depthRT == BuiltinRenderTextureType.None)
+            {
+                SetRenderTarget(cmd, colorRT, clearFlag);
+                return;
+            }
+
+            int depthSlice = (m_IntermediateTextureArray) ? -1 : 0;
+            CoreUtils.SetRenderTarget(cmd, colorRT, depthRT, clearFlag, m_CurrCamera.backgroundColor.linear, 0, CubemapFace.Unknown, depthSlice);
         }
 
         private void RenderPostProcess(CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier dest, bool opaqueOnly)
             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)
         {
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.DefaultViewport))
                     m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
 
                 cmd.SetGlobalTexture(m_BlitTexID, sourceRT);
-                cmd.SetRenderTarget(destRT);
+                SetRenderTarget(cmd, destRT);
                 cmd.SetViewport(m_CurrCamera.pixelRect);
                 cmd.DrawMesh(m_BlitQuad, Matrix4x4.identity, m_BlitMaterial);
             }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_Script: {fileID: 11500000, guid: bf2edee5c58d82540a51f03df9d42094, type: 3}
   m_Name: LightweightPipelineAsset
   m_EditorClassIdentifier: 
-  m_MaxAdditionalPixelLights: 4
+  m_MaxPixelLights: 4
-  m_SupportSoftParticles: 1
+  m_SupportSoftParticles: 0
   m_MSAA: 4
   m_RenderScale: 1
   m_ShadowType: 1

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         public static readonly string m_SimpleLightShaderPath = "LightweightPipeline/Standard (Simple Lighting)";
         public static readonly string m_StandardShaderPath = "LightweightPipeline/Standard (Physically Based)";
 
-        [SerializeField] private int m_MaxAdditionalPixelLights = 4;
+        // Default values set when a new LightweightPipeline asset is created
+        [SerializeField] private int m_MaxPixelLights = 4;
         [SerializeField] private bool m_SupportsVertexLight = false;
         [SerializeField] private bool m_SupportSoftParticles = false;
         [SerializeField] private MSAAQuality m_MSAA = MSAAQuality._4x;
             return ShadowSetting != ShadowType.NO_SHADOW;
         }
 
-        public int MaxAdditionalPixelLights
+        public int MaxPixelLights
-            get { return m_MaxAdditionalPixelLights; }
+            get { return m_MaxPixelLights; }
         }
 
         public bool SupportsVertexLight

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineUtils.cs

             // Remaining light types don't support cookies
         }
 
-        public static void SetKeyword(CommandBuffer cmd, string keyword, bool enable)
-        {
-            if (enable)
-                cmd.EnableShaderKeyword(keyword);
-            else
-                cmd.DisableShaderKeyword(keyword);
-        }
-
         public static bool IsSupportedShadowType(LightType lightType)
         {
             return lightType == LightType.Directional || lightType == LightType.Spot;

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

 #define PI 3.14159265359f
 #define kDieletricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)
 
-#define MAX_VISIBLE_LIGHTS 16
-
 #ifndef UNITY_SPECCUBE_LOD_STEPS
 #define UNITY_SPECCUBE_LOD_STEPS 6
 #endif
     #endif
 #endif
 
-// Main light initialized without indexing
-#define INITIALIZE_MAIN_LIGHT(light) \
-    light.pos = _MainLightPosition; \
-    light.color = _MainLightColor; \
-    light.distanceAttenuation = _MainLightDistanceAttenuation; \
-    light.spotDirection = _MainLightSpotDir; \
-    light.spotAttenuation = _MainLightSpotAttenuation
-
-// Indexing might have a performance hit for old mobile hardware
-#define INITIALIZE_LIGHT(light, i) \
-    half4 indices = (i < 4) ? unity_4LightIndices0 : unity_4LightIndices1; \
-    int index = (i < 4) ? i : i - 4; \
-    int lightIndex = indices[index]; \
-    light.pos = _AdditionalLightPosition[lightIndex]; \
-    light.color = _AdditionalLightColor[lightIndex]; \
-    light.distanceAttenuation = _AdditionalLightDistanceAttenuation[lightIndex]; \
-    light.spotDirection = _AdditionalLightSpotDir[lightIndex]; \
-    light.spotAttenuation = _AdditionalLightSpotAttenuation[lightIndex]
-
-CBUFFER_START(_PerObject)
-half4 unity_LightIndicesOffsetAndCount;
-half4 unity_4LightIndices0;
-half4 unity_4LightIndices1;
-CBUFFER_END
-
-CBUFFER_START(_PerCamera)
-sampler2D _MainLightCookie;
-float4 _MainLightPosition;
-half4 _MainLightColor;
-half4 _MainLightDistanceAttenuation;
-half4 _MainLightSpotDir;
-half4 _MainLightSpotAttenuation;
-float4x4 _WorldToLight;
-
-half4 _AdditionalLightCount;
-float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightColor[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightDistanceAttenuation[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightSpotAttenuation[MAX_VISIBLE_LIGHTS];
-CBUFFER_END
-
-CBUFFER_START(_PerFrame)
-half4 _GlossyEnvironmentColor;
-CBUFFER_END
-
-// Must match Lightweigth ShaderGraph master node
-struct SurfaceData
-{
-    half3 albedo;
-    half3 specular;
-    half  metallic;
-    half  smoothness;
-    half3 normal;
-    half3 emission;
-    half  occlusion;
-    half  alpha;
-};
-
-struct LightInput
-{
-    float4 pos;
-    half4 color;
-    half4 distanceAttenuation;
-    half4 spotDirection;
-    half4 spotAttenuation;
-};
-
+///////////////////////////////////////////////////////////////////////////////
+//                         BRDF Functions                                    //
+///////////////////////////////////////////////////////////////////////////////
 struct BRDFData
 {
     half3 diffuse;
 #endif
 }
 
-half3 GlossyEnvironment(half3 reflectVector, half perceptualRoughness)
-{
-#if !defined(_GLOSSYREFLECTIONS_OFF)
-    half roughness = perceptualRoughness * (1.7 - 0.7 * perceptualRoughness);
-    half mip = roughness * UNITY_SPECCUBE_LOD_STEPS;
-    half4 rgbm = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, reflectVector, mip);
-    return DecodeHDR(rgbm, unity_SpecCube0_HDR);
-#endif
-
-    return _GlossyEnvironmentColor;
-}
-
 half3 LightweightEnvironmentBRDF(BRDFData brdfData, half3 indirectDiffuse, half3 indirectSpecular, half roughness2, half fresnelTerm)
 {
     half3 c = indirectDiffuse * brdfData.diffuse;
 // * NDF [Modified] GGX
 // * Modified Kelemen and Szirmay-​Kalos for Visibility term
 // * Fresnel approximated with 1/LdotH
-half3 LightweightBDRF(BRDFData brdfData, half roughness2, half3 normal, half3 lightDirection, half3 viewDir)
+half3 LightweightDirectBDRF(BRDFData brdfData, half roughness2, half3 normal, half3 lightDirection, half3 viewDir)
 {
 #ifndef _SPECULARHIGHLIGHTS_OFF
     half3 halfDir = SafeNormalize(lightDirection + viewDir);
 #endif
 }
 
-half3 LightingLambert(half3 lightColor, half3 lightDir, half3 normal)
-{
-    half NdotL = saturate(dot(normal, lightDir));
-    return lightColor * NdotL;
-}
-
-half3 LightingSpecular(half3 lightColor, half3 lightDir, half3 normal, half3 viewDir, half4 specularGloss, half shininess)
-{
-    half3 halfVec = SafeNormalize(lightDir + viewDir);
-    half NdotH = saturate(dot(normal, halfVec));
-    half3 specularReflection = specularGloss.rgb * pow(NdotH, shininess) * specularGloss.a;
-    return lightColor * specularReflection;
-}
-
+///////////////////////////////////////////////////////////////////////////////
+//                        Attenuation Functions                               /
+///////////////////////////////////////////////////////////////////////////////
-    #ifdef _MAIN_DIRECTIONAL_LIGHT
-        float2 cookieUV = mul(_WorldToLight, float4(worldPos, 1.0)).xy;
-        return tex2D(_MainLightCookie, cookieUV).a;
-    #elif defined(_MAIN_SPOT_LIGHT)
-        float4 projPos = mul(_WorldToLight, float4(worldPos, 1.0));
-        float2 cookieUV = projPos.xy / projPos.w + 0.5;
-        return tex2D(_MainLightCookie, cookieUV).a;
-    #endif // POINT LIGHT cookie not supported
+#ifdef _MAIN_DIRECTIONAL_LIGHT
+    float2 cookieUV = mul(_WorldToLight, float4(worldPos, 1.0)).xy;
+    return tex2D(_MainLightCookie, cookieUV).a;
+#elif defined(_MAIN_SPOT_LIGHT)
+    float4 projPos = mul(_WorldToLight, float4(worldPos, 1.0));
+    float2 cookieUV = projPos.xy / projPos.w + 0.5;
+    return tex2D(_MainLightCookie, cookieUV).a;
+#endif // POINT LIGHT cookie not supported
 #endif
 
     return 1;
+// Attenuation smoothly decreases to light range.
 half DistanceAttenuation(half3 distanceSqr, half4 distanceAttenuation)
 {
     // We use a shared distance attenuation for additional directional and puctual lights
     return saturate(SdotL * spotAttenuation.x + spotAttenuation.y);
 }
 
-// Attenuation smoothly decreases to light range.
-inline half ComputeLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
+inline half GetLightDirectionAndRealtimeAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
 {
     float3 posToLightVec = lightInput.pos.xyz - worldPos * lightInput.pos.w;
     float distanceSqr = max(dot(posToLightVec, posToLightVec), 0.001);
     return lightAtten;
 }
 
-inline half ComputeMainLightAttenuation(LightInput lightInput, half3 normalWS, float3 positionWS, out half3 lightDirection)
+inline half GetMainLightDirectionAndRealtimeAttenuation(LightInput lightInput, half3 normalWS, float3 positionWS, out half3 lightDirection)
 {
 #ifdef _MAIN_DIRECTIONAL_LIGHT
     // Light pos holds normalized light dir
-    half attenuation = ComputeLightAttenuation(lightInput, normalWS, positionWS, lightDirection);
+    half attenuation = GetLightDirectionAndRealtimeAttenuation(lightInput, normalWS, positionWS, lightDirection);
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Lighting Functions                                   //
+///////////////////////////////////////////////////////////////////////////////
+half3 LightingLambert(half3 lightColor, half3 lightDir, half3 normal)
+{
+    half NdotL = saturate(dot(normal, lightDir));
+    return lightColor * NdotL;
+}
+
+half3 LightingSpecular(half3 lightColor, half3 lightDir, half3 normal, half3 viewDir, half4 specularGloss, half shininess)
+{
+    half3 halfVec = SafeNormalize(lightDir + viewDir);
+    half NdotH = saturate(dot(normal, halfVec));
+    half3 specularReflection = specularGloss.rgb * pow(NdotH, shininess) * specularGloss.a;
+    return lightColor * specularReflection;
+}
+
 half3 VertexLighting(float3 positionWS, half3 normalWS)
 {
     half3 vertexLightColor = half3(0.0, 0.0, 0.0);
         INITIALIZE_LIGHT(light, lightIter);
 
         half3 lightDirection;
-        half atten = ComputeLightAttenuation(light, normalWS, positionWS, lightDirection);
+        half atten = GetLightDirectionAndRealtimeAttenuation(light, normalWS, positionWS, lightDirection);
         half3 lightColor = light.color * atten;
         vertexLightColor += LightingLambert(lightColor, lightDirection, normalWS);
     }
 }
 
-half4 LightweightFragmentPBR(float3 positionWS, half3 normalWS, half3 viewDirectionWS, half3 indirectDiffuse, half3 vertexLighting, half3 albedo, half metallic, half3 specular, half smoothness, half occlusion, half3 emission, half alpha)
+///////////////////////////////////////////////////////////////////////////////
+//                      Global Illumination                                  //
+///////////////////////////////////////////////////////////////////////////////
+half3 DiffuseGI(half3 indirectDiffuse, half3 lambert, half mainLightRealtimeAttenuation, half occlusion)
+    // If shadows and mixed subtractive mode is enabled we need to remove direct
+    // light contribution from lightmap from occluded pixels so we can have dynamic objects
+    // casting shadows onto static correctly.
+#if defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_ON) && defined(_SHADOWS)
+    indirectDiffuse = SubtractDirectMainLightFromLightmap(indirectDiffuse, mainLightRealtimeAttenuation, lambert);
+#endif
+
+    return indirectDiffuse * occlusion;
+}
+
+half3 GlossyEnvironmentReflection(half3 viewDirectionWS, half3 normalWS, half perceptualRoughness, half occlusion)
+{
+    half3 reflectVector = reflect(-viewDirectionWS, normalWS);
+
+#if !defined(_GLOSSYREFLECTIONS_OFF)
+    half roughness = perceptualRoughness * (1.7 - 0.7 * perceptualRoughness);
+    half mip = roughness * UNITY_SPECCUBE_LOD_STEPS;
+    half4 rgbm = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, reflectVector, mip);
+    return DecodeHDR(rgbm, unity_SpecCube0_HDR) * occlusion;
+#endif
+
+    return _GlossyEnvironmentColor * occlusion;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Fragment Functions                                   //
+//       Used by ShaderGraph and others builtin renderers                    //
+///////////////////////////////////////////////////////////////////////////////
+half4 LightweightFragmentPBR(float3 positionWS, half3 normalWS, half3 viewDirectionWS,
+    half3 bakedGI, half3 vertexLighting, half3 albedo, half metallic, half3 specular,
+    half smoothness, half occlusion, half3 emission, half alpha)
+{
+    half4 bakedOcclusion = half4(0, 0, 0, 0);
-    half3 reflectVec = reflect(-viewDirectionWS, normalWS);
-    half roughness2 = brdfData.roughness * brdfData.roughness;
-    indirectDiffuse *= occlusion;
-    half3 indirectSpecular = GlossyEnvironment(reflectVec, brdfData.perceptualRoughness) * occlusion;
+    half3 lightDirectionWS;
+
+    LightInput mainLight;
+    INITIALIZE_MAIN_LIGHT(mainLight);
-    // PBS
+    // No distance fade.
+    half realtimeMainLightAtten = GetMainLightDirectionAndRealtimeAttenuation(mainLight, normalWS, positionWS, lightDirectionWS);
+    half NdotL = saturate(dot(normalWS, lightDirectionWS));
+    half3 radiance = mainLight.color * NdotL;
+
+    half3 indirectDiffuse = DiffuseGI(bakedGI, radiance, realtimeMainLightAtten, occlusion);
+    half3 indirectSpecular = GlossyEnvironmentReflection(viewDirectionWS, normalWS, brdfData.perceptualRoughness, occlusion);
+
+    half roughness2 = brdfData.roughness * brdfData.roughness;
-    half3 lightDirectionWS;
-    LightInput light;
-    INITIALIZE_MAIN_LIGHT(light);
-    half lightAtten = ComputeMainLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
-    half NdotL = saturate(dot(normalWS, lightDirectionWS));
-    half3 radiance = light.color * (lightAtten * NdotL);
-    color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
+    half mainLightAtten = MixRealtimeAndBakedOcclusion(realtimeMainLightAtten, bakedOcclusion, mainLight.distanceAttenuation);
+    radiance *= mainLightAtten;
+
+    color += LightweightDirectBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
     color += vertexLighting * brdfData.diffuse;
 
 #ifdef _ADDITIONAL_LIGHTS
         LightInput light;
         INITIALIZE_LIGHT(light, lightIter);
-        half lightAtten = ComputeLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
+
+        half lightAttenuation = GetLightDirectionAndRealtimeAttenuation(light, normalWS, positionWS, lightDirectionWS);
+        lightAttenuation = MixRealtimeAndBakedOcclusion(lightAttenuation, bakedOcclusion, light.distanceAttenuation);
-        half3 radiance = light.color * (lightAtten * NdotL);
-        color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
+        half3 radiance = light.color * (lightAttenuation * NdotL);
+        color += LightweightDirectBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
     }
 #endif
 
 
-half4 LightweightFragmentLambert(float3 positionWS, half3 normalWS, half3 viewDirectionWS, half fogFactor, half3 diffuseGI, half3 diffuse, half3 emission, half alpha)
+half4 LightweightFragmentLambert(float3 positionWS, half3 normalWS, half3 viewDirectionWS,
+    half fogFactor, half3 diffuseGI, half3 diffuse, half3 emission, half alpha)
+    half4 bakedOcclusion = half4(0, 0, 0, 0);
-    half3 diffuseColor = diffuseGI;
-    half lightAtten = ComputeMainLightAttenuation(mainLight, normalWS, positionWS, lightDirection);
-    half3 lightColor = mainLight.color * lightAtten;
-    diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);
+    half realtimeMainLightAtten = GetMainLightDirectionAndRealtimeAttenuation(mainLight, normalWS, positionWS, lightDirection);
+    half3 NdotL = saturate(dot(normalWS, lightDirection));
+    half3 lambert = mainLight.color * NdotL;
+
+    half3 indirectDiffuse = DiffuseGI(diffuseGI, lambert, realtimeMainLightAtten, 1.0);
+    half mainLightAtten = MixRealtimeAndBakedOcclusion(realtimeMainLightAtten, bakedOcclusion, mainLight.distanceAttenuation);
+
+    half3 diffuseColor = lambert * mainLightAtten + indirectDiffuse;
-        LightInput lightData;
-        INITIALIZE_LIGHT(lightData, lightIter);
-        lightAtten = ComputeLightAttenuation(lightData, normalWS, positionWS, lightDirection);
-        lightColor = lightData.color * lightAtten;
+        LightInput light;
+        INITIALIZE_LIGHT(light, lightIter);
+
+        half lightAttenuation = GetLightDirectionAndRealtimeAttenuation(light, normalWS, positionWS, lightDirection);
+        lightAttenuation = MixRealtimeAndBakedOcclusion(lightAttenuation, bakedOcclusion, light.distanceAttenuation);
-        diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);
+        half3 attenuatedLightColor = light.color * lightAttenuation;
+        diffuseColor += LightingLambert(attenuatedLightColor, lightDirection, normalWS);
-#endif // _ADDITIONAL_LIGHTS
+#endif
 
     half3 finalColor = diffuseColor * diffuse + emission;
 
     return OUTPUT_COLOR(color);
 }
 
-half4 LightweightFragmentBlinnPhong(float3 positionWS, half3 normalWS, half3 viewDirectionWS, half fogFactor, half3 diffuseGI, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
+half4 LightweightFragmentBlinnPhong(float3 positionWS, half3 normalWS, half3 viewDirectionWS,
+    half fogFactor, half3 diffuseGI, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
+    half4 bakedOcclusion = half4(0, 0, 0, 0);
-    half3 diffuseColor = diffuseGI;
-    half3 specularColor;
-    half lightAtten = ComputeMainLightAttenuation(mainLight, normalWS, positionWS, lightDirection);
+    half realtimeMainLightAtten = GetMainLightDirectionAndRealtimeAttenuation(mainLight, normalWS, positionWS, lightDirection);
+    half3 NdotL = saturate(dot(normalWS, lightDirection));
+    half3 lambert = mainLight.color * NdotL;
-    half3 lightColor = mainLight.color * lightAtten;
-    diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);
-    specularColor = LightingSpecular(lightColor, lightDirection, normalWS, viewDirectionWS, specularGloss, shininess);
+    half3 indirectDiffuse = DiffuseGI(diffuseGI, lambert, realtimeMainLightAtten, 1.0);
+    half mainLightAtten = MixRealtimeAndBakedOcclusion(realtimeMainLightAtten, bakedOcclusion, mainLight.distanceAttenuation);
+
+    half3 diffuseColor = lambert * mainLightAtten + indirectDiffuse;
+    half3 specularColor = LightingSpecular(mainLight.color * mainLightAtten, lightDirection, normalWS, viewDirectionWS, specularGloss, shininess);
-        LightInput lightData;
-        INITIALIZE_LIGHT(lightData, lightIter);
-        lightAtten = ComputeLightAttenuation(lightData, normalWS, positionWS, lightDirection);
-        lightColor = lightData.color * lightAtten;
+        LightInput light;
+        INITIALIZE_LIGHT(light, lightIter);
+        half lightAttenuation = GetLightDirectionAndRealtimeAttenuation(light, normalWS, positionWS, lightDirection);
+        lightAttenuation = MixRealtimeAndBakedOcclusion(lightAttenuation, bakedOcclusion, light.distanceAttenuation);
-        diffuseColor += LightingLambert(lightColor, lightDirection, normalWS);
-        specularColor += LightingSpecular(lightColor, lightDirection, normalWS, viewDirectionWS, specularGloss, shininess);
+        half3 attenuatedLightColor = light.color * lightAttenuation;
+        diffuseColor += LightingLambert(attenuatedLightColor, lightDirection, normalWS);
+        specularColor += LightingSpecular(attenuatedLightColor, lightDirection, normalWS, viewDirectionWS, specularGloss, shininess);
-#endif // _ADDITIONAL_LIGHTS
+#endif
 
     half3 finalColor = diffuseColor * diffuse + emission;
     finalColor += specularColor;

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassLit.cginc

 #define SAMPLE_METALLICSPECULAR(uv) tex2D(_MetallicGlossMap, uv)
 #endif
 
+CBUFFER_START(MaterialProperties)
+half4 _MainTex_ST;
-sampler2D _MainTex; half4 _MainTex_ST;
-sampler2D _MetallicGlossMap;
+half _BumpScale;
+half _OcclusionStrength;
+half4 _EmissionColor;
+half _Shininess;
+CBUFFER_END
+
+sampler2D _MainTex;
+sampler2D _MetallicGlossMap;
-half _BumpScale;
-half _OcclusionStrength;
-half4 _EmissionColor;
-half _Shininess;
 
 struct LightweightVertexInput
 {
 {
     float4 uv01                     : TEXCOORD0; // xy: main UV, zw: lightmap UV (directional / non-directional)
     float3 posWS                    : TEXCOORD1;
+
 #if _NORMALMAP
     half3 tangent                   : TEXCOORD2;
     half3 binormal                  : TEXCOORD3;
 #endif
+
-#if defined(EVALUATE_SH_VERTEX) || defined(EVALUATE_SH_MIXED)
+
+#ifndef LIGHTMAP_ON
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Material Property Helpers                            //
+///////////////////////////////////////////////////////////////////////////////
 inline half Alpha(half albedoAlpha)
 {
 #if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
 #endif
 }
 
-half SpecularGloss(half2 uv, half alpha)
+half4 SpecularGloss(half2 uv, half alpha)
 {
     half4 specularGloss = half4(0, 0, 0, 1);
 #ifdef _SPECGLOSSMAP
     outSurfaceData.alpha = Alpha(albedoAlpha.a);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Vertex: Used for Standard and StandardSimpleLighting shaders
 LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
 {
     LightweightVertexOutput o = (LightweightVertexOutput)0;
     o.uv01.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
 #endif
 
-    float3 positionWS = mul(unity_ObjectToWorld, v.vertex).xyz;
-    half3 viewDirectionWS = SafeNormalize(_WorldSpaceCameraPos - positionWS);
+    float4 positionWS = mul(unity_ObjectToWorld, v.vertex);
+    half3 viewDirectionWS = SafeNormalize(_WorldSpaceCameraPos - positionWS.xyz);
 
 #if _NORMALMAP
     OutputTangentToWorld(v.tangent, v.normal, o.tangent, o.binormal, o.normal);
 
-    float4 clipPos = UnityObjectToClipPos(v.vertex);
+    float4 clipPos = mul(UNITY_MATRIX_VP, positionWS);
-#if defined(EVALUATE_SH_VERTEX) || defined(EVALUATE_SH_MIXED)
+#ifndef LIGHTMAP_ON
-    o.fogFactorAndVertexLight.yzw = VertexLighting(positionWS, o.normal);
+    o.fogFactorAndVertexLight.yzw = VertexLighting(positionWS.xyz, o.normal);
     o.fogFactorAndVertexLight.x = ComputeFogFactor(clipPos.z);
     o.clipPos = clipPos;
 
+// Used for Standard shader
 half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
 {
     SurfaceData surfaceData;
     return OUTPUT_COLOR(color);
 }
 
+// Used for StandardSimpleLighting shader
 half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
 {
     float2 uv = IN.uv01.xy;
     half fogFactor = IN.fogFactorAndVertexLight.x;
 
 #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
-    half4 specularGloss = SpecularGloss(uv, alpha);
+    half4 specularGloss = SpecularGloss(uv, diffuseAlpha.a);
     return LightweightFragmentBlinnPhong(positionWS, normalWS, viewDirectionWS, fogFactor, diffuseGI, diffuse, specularGloss, shininess, emission, alpha);
 #else
     return LightweightFragmentLambert(positionWS, normalWS, viewDirectionWS, fogFactor, diffuseGI, diffuse, emission, alpha);

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightShadows.cginc

 #ifndef LIGHTWEIGHT_SHADOWS_INCLUDED
 #define LIGHTWEIGHT_SHADOWS_INCLUDED
+
+#include "LightweightInput.cginc"
+
 #define MAX_SHADOW_CASCADES 4
 
 #if defined(_HARD_SHADOWS) || defined(_SOFT_SHADOWS) || defined(_HARD_SHADOWS_CASCADES) || defined(_SOFT_SHADOWS_CASCADES)
 #else
     return ShadowAttenuation(shadowCoord.xyz);
 #endif
+}
+
+half MixRealtimeAndBakedOcclusion(half realtimeAttenuation, half4 bakedOcclusion, half4 distanceAttenuation)
+{
+#if defined(LIGHTMAP_ON)
+#if defined(_MIXED_LIGHTING_SHADOWMASK)
+    // TODO:
+#elif defined(_MIXED_LIGHTING_SUBTRACTIVE)
+    // Subtractive Light mode has direct light contribution baked into lightmap for mixed lights.
+    // We need to remove direct realtime contribution from mixed lights
+    // distanceAttenuation.w is set 0.0 if this light is mixed, 1.0 otherwise.
+    return realtimeAttenuation * distanceAttenuation.w;
+#endif
+#endif
+
+    return realtimeAttenuation;
+}
+
+inline half3 SubtractDirectMainLightFromLightmap(half3 lightmap, half attenuation, half3 lambert)
+{
+    // Let's try to make realtime shadows work on a surface, which already contains
+    // baked lighting and shadowing from the main sun light.
+    // Summary:
+    // 1) Calculate possible value in the shadow by subtracting estimated light contribution from the places occluded by realtime shadow:
+    //      a) preserves other baked lights and light bounces
+    //      b) eliminates shadows on the geometry facing away from the light
+    // 2) Clamp against user defined ShadowColor.
+    // 3) Pick original lightmap value, if it is the darkest one.
+
+
+    // 1) Gives good estimate of illumination as if light would've been shadowed during the bake.
+    //    Preserves bounce and other baked lights
+    //    No shadows on the geometry facing away from the light
+    half shadowStrength = _ShadowData.x;
+    half3 estimatedLightContributionMaskedByInverseOfShadow = lambert * (1.0 - attenuation);
+    half3 subtractedLightmap = lightmap - estimatedLightContributionMaskedByInverseOfShadow;
+
+    // 2) Allows user to define overall ambient of the scene and control situation when realtime shadow becomes too dark.
+    half3 realtimeShadow = max(subtractedLightmap, _SubtractiveShadowColor);
+    realtimeShadow = lerp(realtimeShadow, lightmap, shadowStrength);
+
+    // 3) Pick darkest color
+    return min(lightmap, realtimeShadow);
 }
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandard.shader

             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
+            #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE _MIXED_LIGHTING_SHADOWMASK
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardParticles.shader

             #pragma vertex ParticlesLitVertex
             #pragma fragment ParticlesLitFragment
             #pragma multi_compile __ SOFTPARTICLES_ON
-            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT
             #pragma target 3.5
 
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

             #pragma shader_feature _EMISSION
 
             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
-            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT
+            #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE _MIXED_LIGHTING_SHADOWMASK
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardTerrain.shader

             #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
+            #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE _MIXED_LIGHTING_SHADOWMASK
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ DIRLIGHTMAP_COMBINED

Tests/GraphicsTests/Framework/Editor/TestFramework.cs

 			// Readback the rendered texture
 			var oldActive = RenderTexture.active;
 			RenderTexture.active = tempTarget;
-			var captured = new Texture2D(tempTarget.width, tempTarget.height, TextureFormat.ARGB32, false);
+			var captured = new Texture2D(tempTarget.width, tempTarget.height, TextureFormat.RGB24, false);
 			captured.ReadPixels(new Rect(0, 0, testSetup.width, testSetup.height), 0, 0);
 			RenderTexture.active = oldActive;
 

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_01_BaseWhite.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_01_BaseWhite
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _SPECULAR_COLOR
+  m_ShaderKeywords: _GLOSSINESS_FROM_BASE_ALPHA _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_02_BaseColor.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_02_BaseColor
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _SPECULAR_COLOR
+  m_ShaderKeywords: _GLOSSINESS_FROM_BASE_ALPHA _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_03_Specular.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_03_Specular
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _SPECGLOSSMAP_BASE_ALPHA
+  m_ShaderKeywords: _GLOSSINESS_FROM_BASE_ALPHA _SPECGLOSSMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_04_Normal.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_04_Normal
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _NORMALMAP _SPECULAR_COLOR
+  m_ShaderKeywords: _GLOSSINESS_FROM_BASE_ALPHA _NORMALMAP _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_05_Emission.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_05_Emission
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _EMISSION _SPECULAR_COLOR
+  m_ShaderKeywords: _EMISSION _GLOSSINESS_FROM_BASE_ALPHA _SPECULAR_COLOR
   m_LightmapFlags: 2
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/007_LitShaderMaps/007_LitShaderMaps_06_All.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: 007_LitShaderMaps_06_All
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _EMISSION _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA
-  m_LightmapFlags: 4
+  m_ShaderKeywords: _EMISSION _GLOSSINESS_FROM_BASE_ALPHA _NORMALMAP _SPECGLOSSMAP
+  m_LightmapFlags: 2
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/009_LightweightShading.unity

   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1177504217}
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 163, y: 47.8, z: 0}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 1084503480}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1447851825}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &1447851827
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 1
   m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
-  m_StereoMirrorMode: 0
 --- !u!4 &1447851830
 Transform:
   m_ObjectHideFlags: 0
   renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 1447851829}
   hdr: 0
+  msaaSamples: 4
   width: 1280
   height: 720
 --- !u!1 &1449522778

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/028_PostProcessing_Custom.unity

   - component: {fileID: 127406270}
   - component: {fileID: 127406275}
   - component: {fileID: 127406272}
+  - component: {fileID: 127406276}
   m_Layer: 0
   m_Name: Main Camera
   m_TagString: MainCamera
   - assemblyQualifiedName: HalfToneOpaque, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
       PublicKeyToken=null
   m_AfterStackBundles: []
+--- !u!114 &127406276
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 127406269}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
+  cameraToUse: {fileID: 127406273}
+  hdr: 0
+  msaaSamples: 1
+  width: 1280
+  height: 720
 --- !u!1 &203150636
 GameObject:
   m_ObjectHideFlags: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/036_Lighting_Scene_DirectionalBakedDirectional.unity

   renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 64132551}
   hdr: 0
-  msaaSamples: 1
+  msaaSamples: 4
   width: 1280
   height: 720
 --- !u!20 &64132551

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc

+#ifndef LIGHTWEIGHT_INPUT_INCLUDED
+#define LIGHTWEIGHT_INPUT_INCLUDED
+
+#define MAX_VISIBLE_LIGHTS 16
+
+// Must match Lightweigth ShaderGraph master node
+struct SurfaceData
+{
+    half3 albedo;
+    half3 specular;
+    half  metallic;
+    half  smoothness;
+    half3 normal;
+    half3 emission;
+    half  occlusion;
+    half  alpha;
+};
+
+struct LightInput
+{
+    float4 pos;
+    half4 color;
+    half4 distanceAttenuation;
+    half4 spotDirection;
+    half4 spotAttenuation;
+};
+
+// Main light initialized without indexing
+#define INITIALIZE_MAIN_LIGHT(light) \
+    light.pos = _MainLightPosition; \
+    light.color = _MainLightColor; \
+    light.distanceAttenuation = _MainLightDistanceAttenuation; \
+    light.spotDirection = _MainLightSpotDir; \
+    light.spotAttenuation = _MainLightSpotAttenuation
+
+// Indexing might have a performance hit for old mobile hardware
+#define INITIALIZE_LIGHT(light, i) \
+    half4 indices = (i < 4) ? unity_4LightIndices0 : unity_4LightIndices1; \
+    int index = (i < 4) ? i : i - 4; \
+    int lightIndex = indices[index]; \
+    light.pos = _AdditionalLightPosition[lightIndex]; \
+    light.color = _AdditionalLightColor[lightIndex]; \
+    light.distanceAttenuation = _AdditionalLightDistanceAttenuation[lightIndex]; \
+    light.spotDirection = _AdditionalLightSpotDir[lightIndex]; \
+    light.spotAttenuation = _AdditionalLightSpotAttenuation[lightIndex]
+
+///////////////////////////////////////////////////////////////////////////////
+//                      Constant Buffers                                     //
+///////////////////////////////////////////////////////////////////////////////
+
+CBUFFER_START(_PerFrame)
+half4 _GlossyEnvironmentColor;
+half4 _SubtractiveShadowColor;
+CBUFFER_END
+
+CBUFFER_START(_PerCamera)
+sampler2D _MainLightCookie;
+float4 _MainLightPosition;
+half4 _MainLightColor;
+half4 _MainLightDistanceAttenuation;
+half4 _MainLightSpotDir;
+half4 _MainLightSpotAttenuation;
+float4x4 _WorldToLight;
+
+half4 _AdditionalLightCount;
+float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightColor[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightDistanceAttenuation[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightSpotAttenuation[MAX_VISIBLE_LIGHTS];
+CBUFFER_END
+
+// These are set internally by the engine upon request by RendererConfiguration.
+// Check GetRendererSettings in LightweightPipeline.cs
+CBUFFER_START(_PerObject)
+half4 unity_LightIndicesOffsetAndCount;
+half4 unity_4LightIndices0;
+half4 unity_4LightIndices1;
+CBUFFER_END
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc.meta

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