Merge branch 'master' into shader-include-paths-2

ScriptableRenderPipeline/Core/CoreUtils.cs

         public const int assetCreateMenuPriority2 = 241;
 
         // 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/Core/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/API/Metal.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/API/PSSL.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/API/Vulkan.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D
 #define GATHER_TEXTURE2D(textureName, samplerName, coord2) textureName.Gather(samplerName, coord2)
 #define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index) textureName.Gather(samplerName, float3(coord2, index))
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3) textureName.Gather(samplerName, coord3)
-#define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))
+#define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index) textureName.Gather(samplerName, float4(coord3, index))

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 #endif
 #include "API/Validate.hlsl"
 
+#include "Macros.hlsl"
-// Some shader compiler don't support to do multiple ## for concatenation inside the same macro, it require an indirection.
-// This is the purpose of this macro
-#define MERGE_NAME(X, Y) X##Y
-
-// These define are use to abstract the way we sample into a cubemap array.
-// Some platform don't support cubemap array so we fallback on 2D latlong
-#ifdef UNITY_NO_CUBEMAP_ARRAY
-#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURE2D_ARRAY
-#define SAMPLERCUBE_ABSTRACT SAMPLER2D
-#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURE2D_ARRAY_ARGS
-#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURE2D_ARRAY_PARAM
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, DirectionToLatLongCoordinate(coord3), index, lod)
-#else
-#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURECUBE_ARRAY
-#define SAMPLERCUBE_ABSTRACT SAMPLERCUBE
-#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURECUBE_ARRAY_ARGS
-#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURECUBE_ARRAY_PARAM
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)
-#endif
-
 // ----------------------------------------------------------------------------
 // Common intrinsic (general implementation of intrinsic available on some platform)
 // ----------------------------------------------------------------------------
 }
 
 #ifndef INTRINSIC_WAVEREADFIRSTLANE
-// Warning: for correctness, the value you pass to the function must be constant across the wave!
-uint WaveReadFirstLane(uint scalarValue)
-{
-    return scalarValue;
-}
+    // Warning: for correctness, the argument must have the same value across the wave!
+    TEMPLATE_1_FLT(WaveReadFirstLane, scalarValue, return scalarValue)
+    TEMPLATE_1_INT(WaveReadFirstLane, scalarValue, return scalarValue)
-int Mul24(int a, int b)
-{
-    return a * b;
-}
-
-uint Mul24(uint a, uint b)
-{
-    return a * b;
-}
+    TEMPLATE_2_INT(Mul24, a, b, return a * b)
-int Mad24(int a, int b, int c)
-{
-    return a * b + c;
-}
-
-uint Mad24(uint a, uint b, uint c)
-{
-    return a * b + c;
-}
+    TEMPLATE_3_INT(Mad24, a, b, c, return a * b + c)
-float Min3(float a, float b, float c)
-{
-    return min(min(a, b), c);
-}
-
-float2 Min3(float2 a, float2 b, float2 c)
-{
-    return min(min(a, b), c);
-}
-
-float3 Min3(float3 a, float3 b, float3 c)
-{
-    return min(min(a, b), c);
-}
-
-float4 Min3(float4 a, float4 b, float4 c)
-{
-    return min(min(a, b), c);
-}
-
-float Max3(float a, float b, float c)
-{
-    return max(max(a, b), c);
-}
-
-float2 Max3(float2 a, float2 b, float2 c)
-{
-    return max(max(a, b), c);
-}
-
-float3 Max3(float3 a, float3 b, float3 c)
-{
-    return max(max(a, b), c);
-}
-
-float4 Max3(float4 a, float4 b, float4 c)
-{
-    return max(max(a, b), c);
-}
+    TEMPLATE_3_FLT(Min3, a, b, c, return min(min(a, b), c))
+    TEMPLATE_3_INT(Min3, a, b, c, return min(min(a, b), c))
+    TEMPLATE_3_FLT(Max3, a, b, c, return max(max(a, b), c))
+    TEMPLATE_3_INT(Max3, a, b, c, return max(max(a, b), c))
-void Swap(inout float a, inout float b)
-{
-    float  t = a; a = b; b = t;
-}
-
-void Swap(inout float2 a, inout float2 b)
-{
-    float2 t = a; a = b; b = t;
-}
-
-void Swap(inout float3 a, inout float3 b)
-{
-    float3 t = a; a = b; b = t;
-}
-
-void Swap(inout float4 a, inout float4 b)
-{
-    float4 t = a; a = b; b = t;
-}
+TEMPLATE_SWAP(Swap) // Define a Swap(a, b) function for all types
 
 #define CUBEMAPFACE_POSITIVE_X 0
 #define CUBEMAPFACE_NEGATIVE_X 1
 #define HALF_PI     1.57079632679
 #define INV_HALF_PI 0.636619772367
 #define INFINITY    asfloat(0x7F800000)
-#define FLT_SMALL   0.0001
 #define LOG2_E      1.44269504089
 
 #define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
 
 float DegToRad(float deg)
 {
-    return deg * PI / 180.0;
+    return deg * (PI / 180.0);
-    return rad * 180.0 / PI;
+    return rad * (180.0 / PI);
-float Sqr(float x)
-{
-    return x * x;
-}
-
-float3 Sqr(float3 x)
-{
-    return x * x;
-}
+TEMPLATE_1_FLT(Sq, x, return x * x)
+TEMPLATE_1_INT(Sq, x, return x * x)
 
 // Input [0, 1] and output [0, PI/2]
 // 9 VALU
 // Using pow often result to a warning like this
 // "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
 // PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
-float PositivePow(float base, float power)
-{
-    return pow(max(abs(base), float(FLT_EPSILON)), power);
-}
-
-float2 PositivePow(float2 base, float2 power)
-{
-    return pow(max(abs(base), float2(FLT_EPSILON, FLT_EPSILON)), power);
-}
-
-float3 PositivePow(float3 base, float3 power)
-{
-    return pow(max(abs(base), float3(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
-}
-
-float4 PositivePow(float4 base, float4 power)
-{
-    return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
-}
+TEMPLATE_2_FLT(PositivePow, base, power, return pow(max(abs(base), FLT_EPSILON), power))
-float3 FastSign(float x)
+float FastSign(float x)
-    return  saturate(x * FLT_MAX) * 2.0 - 1.0;
+    return saturate(x * FLT_MAX) * 2.0 - 1.0;
 }
 
 // Orthonormalizes the tangent frame using the Gram-Schmidt process.

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 // ior is a value between 1.0 and 2.5
 float IORToFresnel0(float ior)
 {
-    return Sqr((ior - 1.0) / (ior + 1.0));
+    return Sq((ior - 1.0) / (ior + 1.0));
 }
 
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/VolumeRendering.hlsl

 // Absorption coefficient from Disney: http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
 float3 TransmittanceColorAtDistanceToAbsorption(float3 transmittanceColor, float atDistance)
 {
-    return -log(transmittanceColor + 0.00001) / max(atDistance, 0.000001);
+    return -log(transmittanceColor + FLT_EPSILON) / max(atDistance, FLT_EPSILON);
 }
 
 

ScriptableRenderPipeline/Core/TextureCache.cs

 
             if (mismatch)
             {
-                if (!Graphics.ConvertTexture(texture, 0, m_Cache, sliceIndex))
+                if (!UnityEngine.Graphics.ConvertTexture(texture, 0, m_Cache, sliceIndex))
                 {
                     Debug.LogErrorFormat(texture, "Unable to convert texture \"{0}\" to match renderloop settings ({1}x{2} {3})",
                         texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
             {
-                Graphics.CopyTexture(texture, 0, m_Cache, sliceIndex);
+                UnityEngine.Graphics.CopyTexture(texture, 0, m_Cache, sliceIndex);
             }
         }
 
 
                     for (int f = 0; f < 6; f++)
                     {
-                        if (!Graphics.ConvertTexture(texture, f, m_Cache, 6 * sliceIndex + f))
+                        if (!UnityEngine.Graphics.ConvertTexture(texture, f, m_Cache, 6 * sliceIndex + f))
                         {
                             failed = true;
                             break;
                 else
                 {
                     for (int f = 0; f < 6; f++)
-                        Graphics.CopyTexture(texture, f, m_Cache, 6 * sliceIndex + f);
+                        UnityEngine.Graphics.CopyTexture(texture, f, m_Cache, 6 * sliceIndex + f);
                 }
             }
         }
             for (int m = 0; m < m_NumPanoMipLevels; m++)
             {
                 m_CubeBlitMaterial.SetInt(m_CubeMipLevelPropName, Mathf.Min(m_NumMipLevels - 1, m));
-                Graphics.SetRenderTarget(m_StagingRTs[m]);
-                Graphics.Blit(null, m_CubeBlitMaterial, 0);
+                UnityEngine.Graphics.SetRenderTarget(m_StagingRTs[m]);
+                UnityEngine.Graphics.Blit(null, m_CubeBlitMaterial, 0);
-                Graphics.CopyTexture(m_StagingRTs[m], 0, 0, m_CacheNoCubeArray, sliceIndex, m);
+                UnityEngine.Graphics.CopyTexture(m_StagingRTs[m], 0, 0, m_CacheNoCubeArray, sliceIndex, m);
         }
     }
 

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

         public static string kFullScreenDebugMip = "Fullscreen Debug Mip";
         public static string kDisplaySkyReflectionDebug = "Display Sky Reflection";
         public static string kSkyReflectionMipmapDebug = "Sky Reflection Mipmap";
-        public static string kTileDebug = "Tile Debug By Category";
+        public static string kTileClusterCategoryDebug = "Tile/Cluster Debug By Category";
+        public static string kTileClusterDebug = "Tile/Cluster Debug";
 
 
         public float debugOverlayRatio = 0.33f;
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, Color>(kDebugLightingAlbedo, () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Lighting", kDisplaySkyReflectionDebug, () => lightingDebugSettings.displaySkyReflection, (value) => lightingDebugSettings.displaySkyReflection = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, TilePass.TileSettings.TileDebug>(kTileDebug,() => lightingDebugSettings.tileDebugByCategory, (value) => lightingDebugSettings.tileDebugByCategory = (TilePass.TileSettings.TileDebug)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, TilePass.TileSettings.TileClusterDebug>(kTileClusterDebug,() => lightingDebugSettings.tileClusterDebug, (value) => lightingDebugSettings.tileClusterDebug = (TilePass.TileSettings.TileClusterDebug)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, TilePass.TileSettings.TileClusterCategoryDebug>(kTileClusterCategoryDebug,() => lightingDebugSettings.tileClusterDebugByCategory, (value) => lightingDebugSettings.tileClusterDebugByCategory = (TilePass.TileSettings.TileClusterCategoryDebug)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Opaque",() => renderingDebugSettings.displayOpaqueObjects, (value) => renderingDebugSettings.displayOpaqueObjects = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Transparency",() => renderingDebugSettings.displayTransparentObjects, (value) => renderingDebugSettings.displayTransparentObjects = (bool)value);
         public bool                 displaySkyReflection = false;
         public float                skyReflectionMipmap = 0.0f;
 
-        public TilePass.TileSettings.TileDebug  tileDebugByCategory = TilePass.TileSettings.TileDebug.None;
+        public TilePass.TileSettings.TileClusterDebug tileClusterDebug = TilePass.TileSettings.TileClusterDebug.None;
+        public TilePass.TileSettings.TileClusterCategoryDebug tileClusterDebugByCategory = TilePass.TileSettings.TileClusterCategoryDebug.Punctual;   
 
         public void OnValidate()
         {

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

             #define DEBUG_DISPLAY
             #include "../Debug/DebugDisplay.hlsl"
             #include "../Material/Material.hlsl"
-
-            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+            
             #ifdef SHADOWS_SHADOWMASK
             TEXTURE2D(_ShadowMaskTexture);
             #endif
                 float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
                 UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
 
-                FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-                DECODE_FROM_GBUFFER(gbuffer, 0xFFFFFFFF, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.unPositionSS, 0xFFFFFFFF, bsdfData, bakeLightingData.bakeDiffuseLighting);
                 #ifdef SHADOWS_SHADOWMASK
                 DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
                 #endif

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewTiles.shader

         Pass
         {
             ZWrite Off
+            ZTest Always
             Blend SrcAlpha OneMinusSrcAlpha
 
             HLSLPROGRAM

ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

-using UnityEngine;
+using UnityEngine;
 using System;
 
 #if UNITY_EDITOR
                         break;
                 }
 
-
-                m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileDebug).handler.OnEditorGUI();
+                DebugItem tileClusterDebug = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileClusterDebug);
+                tileClusterDebug.handler.OnEditorGUI();
+                if ((int)tileClusterDebug.GetValue() != 0 && (int)tileClusterDebug.GetValue() != 3) // None and FeatureVariant
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileClusterCategoryDebug).handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
 
                 DebugItem displaySkyReflecItem = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kDisplaySkyReflectionDebug);
                 displaySkyReflecItem.handler.OnEditorGUI();

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.Styles.cs

-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
             public readonly GUIContent enableComputeLightEvaluation = new GUIContent("Compute Light Evaluation");
             public readonly GUIContent enableComputeLightVariants = new GUIContent("Compute Light Variants");
             public readonly GUIContent enableComputeMaterialVariants = new GUIContent("Compute Material Variants");
-            public readonly GUIContent enableClustered = new GUIContent("Clustered");
-            public readonly GUIContent enableFptlForOpaqueWhenClustered = new GUIContent("Fptl For Opaque When Clustered");
+            public readonly GUIContent enableFptlForForwardOpaque = new GUIContent("Fptl for forward opaque");
             public readonly GUIContent enableBigTilePrepass = new GUIContent("Big tile prepass");
         }
 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

         SerializedProperty m_enableComputeLightEvaluation;
         SerializedProperty m_enableComputeLightVariants;
         SerializedProperty m_enableComputeMaterialVariants;
-        SerializedProperty m_enableClustered;
-        SerializedProperty m_enableFptlForOpaqueWhenClustered;
+        SerializedProperty m_enableFptlForForwardOpaque;
         SerializedProperty m_enableBigTilePrepass;
 
         // Rendering Settings
             m_enableComputeLightEvaluation = properties.Find(x => x.tileSettings.enableComputeLightEvaluation);
             m_enableComputeLightVariants = properties.Find(x => x.tileSettings.enableComputeLightVariants);
             m_enableComputeMaterialVariants = properties.Find(x => x.tileSettings.enableComputeMaterialVariants);
-            m_enableClustered = properties.Find(x => x.tileSettings.enableClustered);
-            m_enableFptlForOpaqueWhenClustered = properties.Find(x => x.tileSettings.enableFptlForOpaqueWhenClustered);
+            m_enableFptlForForwardOpaque = properties.Find(x => x.tileSettings.enableFptlForForwardOpaque);
             m_enableBigTilePrepass = properties.Find(x => x.tileSettings.enableBigTilePrepass);
 
             // Shadow settings
             {
                 EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(m_enableBigTilePrepass, s_Styles.enableBigTilePrepass);
-                EditorGUILayout.PropertyField(m_enableClustered, s_Styles.enableClustered);
-                // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                // if (m_enableClustered.boolValue)
-                if (m_enableClustered.boolValue && !m_enableComputeLightEvaluation.boolValue)
-                {
-                    EditorGUI.indentLevel++;
-                    EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, s_Styles.enableFptlForOpaqueWhenClustered);
-                    EditorGUI.indentLevel--;
-                }
+                // Allow to disable cluster for foward opaque when in forward only (option have no effect when MSAA is enabled)
+                // Deferred opaque are always tiled
+                EditorGUILayout.PropertyField(m_enableFptlForForwardOpaque, s_Styles.enableFptlForForwardOpaque);
+
-                    // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                    m_enableFptlForOpaqueWhenClustered.boolValue = true; // Force fptl to be always true if compute evaluation is enable
-
                     EditorGUI.indentLevel++;
                     EditorGUILayout.PropertyField(m_enableComputeLightVariants, s_Styles.enableComputeLightVariants);
                     EditorGUILayout.PropertyField(m_enableComputeMaterialVariants, s_Styles.enableComputeMaterialVariants);

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 
         static readonly string[] k_ForwardPassDebugName =
         {
-            "Forward Opaque Debug Display",
-            "Forward PreRefraction Debug Display",
-            "Forward Transparent Debug Display"
+            "Forward Opaque Debug",
+            "Forward PreRefraction Debug",
+            "Forward Transparent Debug"
-            "Forward Opaque Display",
-            "Forward PreRefraction Display",
-            "Forward Transparent Display"
+            "Forward Opaque",
+            "Forward PreRefraction",
+            "Forward Transparent"
         };
 
         static readonly RenderQueueRange k_RenderQueue_PreRefraction = new RenderQueueRange { min = (int)HDRenderQueue.PreRefraction, max = (int)HDRenderQueue.Transparent - 1 };
 
             m_MaterialList.ForEach(material => material.Build(asset.renderPipelineResources));
 
-            m_LightLoop.Build(asset.renderPipelineResources, asset.tileSettings, asset.textureSettings, asset.shadowInitParams, m_ShadowSettings);
+            m_LightLoop.Build(asset.renderPipelineResources, asset.renderingSettings, asset.tileSettings, asset.textureSettings, asset.shadowInitParams, m_ShadowSettings);
 
             m_SkyManager.Build(asset.renderPipelineResources);
             m_SkyManager.skySettings = skySettingsToUse;
 
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Tile/Cluster", () => m_Asset.tileSettings.enableTileAndCluster, (value) => m_Asset.tileSettings.enableTileAndCluster = (bool)value, DebugItemFlag.RuntimeOnly);
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Big Tile", () => m_Asset.tileSettings.enableBigTilePrepass, (value) => m_Asset.tileSettings.enableBigTilePrepass = (bool)value, DebugItemFlag.RuntimeOnly);
-            DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Cluster", () => m_Asset.tileSettings.enableClustered, (value) => m_Asset.tileSettings.enableClustered = (bool)value, DebugItemFlag.RuntimeOnly);
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Compute Lighting", () => m_Asset.tileSettings.enableComputeLightEvaluation, (value) => m_Asset.tileSettings.enableComputeLightEvaluation = (bool)value, DebugItemFlag.RuntimeOnly);
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Light Classification", () => m_Asset.tileSettings.enableComputeLightVariants, (value) => m_Asset.tileSettings.enableComputeLightVariants = (bool)value, DebugItemFlag.RuntimeOnly);
             DebugMenuManager.instance.AddDebugItem<bool>("HDRP", "Enable Material Classification", () => m_Asset.tileSettings.enableComputeMaterialVariants, (value) => m_Asset.tileSettings.enableComputeMaterialVariants = (bool)value, DebugItemFlag.RuntimeOnly);
         {
             // Currently, Unity does not offer a way to bind the stencil buffer as a texture in a compute shader.
             // Therefore, it's manually copied using a pixel shader.
-            return m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || LightLoop.GetFeatureVariantsEnabled(m_Asset.tileSettings);
+            return m_CurrentDebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_LightLoop.GetFeatureVariantsEnabled();
         }
 
         bool NeedHTileCopy()
                 RenderForward(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
                 RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
 
-                RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT, m_CurrentDebugDisplaySettings);
-
                 RenderSky(hdCamera, cmd);
 
                 // Do a depth pre-pass for transparent objects that want it that will fill the depth buffer to reduce the overdraw (typical usage is hair rendering)
                 }
             }
 
-            RenderDebug(hdCamera, cmd);
+            RenderDebug(hdCamera, cmd);                
 
 #if UNITY_EDITOR
             // bind depth surface for editor grid/gizmo/selection rendering
             return m_SkyManager.ExportSkyToTexture();
         }
 
-        void RenderLightingDebug(HDCamera camera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer, DebugDisplaySettings debugDisplaySettings)
-        {
-            m_LightLoop.RenderLightingDebug(camera, cmd, colorBuffer, debugDisplaySettings);
-        }
-
         // Render forward is use for both transparent and opaque objects. In case of deferred we can still render opaque object in forward.
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ForwardPass pass)
         {
                     HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.camera.pixelWidth);
                 }
 
-                m_LightLoop.RenderDebugOverlay(camera.camera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
+                m_LightLoop.RenderDebugOverlay(camera, cmd, m_CurrentDebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

 
             // Chose supported lighting architecture in case of deferred rendering
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
+
+            #define USE_FPTL_LIGHTLIST // deferred opaque always use FPTL
 
             //-------------------------------------------------------------------------------------
             // Include
             // variable declaration
             //-------------------------------------------------------------------------------------
 
-            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
             #ifdef SHADOWS_SHADOWMASK
             TEXTURE2D(_ShadowMaskTexture);
             #endif
                 UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
                 float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
 
-                FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-                DECODE_FROM_GBUFFER(gbuffer, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.unPositionSS, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
                 #ifdef SHADOWS_SHADOWMASK
                 DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
                 #endif

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Forward.hlsl

 // Those that are control from inside the "Material".shader with "Pass" concept like forward lighting. Call later forward lighting architecture.
 // Those that are control outside the "Material".shader in a "Lighting".shader like deferred lighting. Call later deferred lighting architecture.
 
-// When dealing with deferred lighting architecture, the renderloop is in charge to call the correct .shader.
-// RenderLoop can do multiple call of various deferred lighting architecture.
+// When dealing with deferred lighting architecture, the renderPipeline is in charge to call the correct .shader.
+// renderPipeline can do multiple call of various deferred lighting architecture.
-// When dealing with forward lighting architecture, the renderloop must specify a shader pass (like "forward") but it also need
+// When dealing with forward lighting architecture, the renderPipeline must specify a shader pass (like "forward") but it also need
-// Renderloop can suppose dynamically switching from regular forward to tile forward for example within the same "Forward" pass.
 
 // The purpose of the following pragma is to define the variant available for "Forward" Pass in "Material".shader.
 // If only one keyword is present it mean that only one type of forward lighting architecture is supported.
-
-// No USE_FPTL_LIGHTLIST as we are in forward and this use the cluster path (but cluster path can use the tile light list for opaque)
-#define USE_CLUSTERED_LIGHTLIST
+// For forward transparent are always cluster and opaque can be either cluster or fptl (sadly we have no to do multicompile only if opaque)
+// Moreover, we would like to do it only for LIGHTLOOP_TILE_PASS variant...
+// #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/Deferred.compute

-#pragma kernel Deferred_Direct_Fptl                                 SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl                                USE_FPTL_LIGHTLIST
-#pragma kernel Deferred_Direct_Fptl_DebugDisplay                    SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay                   USE_FPTL_LIGHTLIST          DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_ShadowMask_Fptl                     SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl                    USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK
-#pragma kernel Deferred_Direct_ShadowMask_Fptl_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl_DebugDisplay       USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK  DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_Clustered                            SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered                           USE_CLUSTERED_LIGHTLIST
-#pragma kernel Deferred_Direct_Clustered_DebugDisplay               SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered_DebugDisplay              USE_CLUSTERED_LIGHTLIST     DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_ShadowMask_Clustered                SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered               USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK
-#pragma kernel Deferred_Direct_ShadowMask_Clustered_DebugDisplay   SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered_DebugDisplay  USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK  DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_Fptl                                SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl
+#pragma kernel Deferred_Direct_Fptl_DebugDisplay                   SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay             DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_ShadowMask_Fptl                     SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl               SHADOWS_SHADOWMASK
+#pragma kernel Deferred_Direct_ShadowMask_Fptl_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl_DebugDisplay  SHADOWS_SHADOWMASK  DEBUG_DISPLAY
-#pragma kernel Deferred_Indirect_Fptl_Variant0      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=0
-#pragma kernel Deferred_Indirect_Fptl_Variant1      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=1
-#pragma kernel Deferred_Indirect_Fptl_Variant2      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=2
-#pragma kernel Deferred_Indirect_Fptl_Variant3      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=3
-#pragma kernel Deferred_Indirect_Fptl_Variant4      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=4
-#pragma kernel Deferred_Indirect_Fptl_Variant5      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=5
-#pragma kernel Deferred_Indirect_Fptl_Variant6      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=6
-#pragma kernel Deferred_Indirect_Fptl_Variant7      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=7
-#pragma kernel Deferred_Indirect_Fptl_Variant8      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=8
-#pragma kernel Deferred_Indirect_Fptl_Variant9      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=9
-#pragma kernel Deferred_Indirect_Fptl_Variant10     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=10
-#pragma kernel Deferred_Indirect_Fptl_Variant11     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=11
-#pragma kernel Deferred_Indirect_Fptl_Variant12     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=12
-#pragma kernel Deferred_Indirect_Fptl_Variant13     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=13
-#pragma kernel Deferred_Indirect_Fptl_Variant14     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=14
-#pragma kernel Deferred_Indirect_Fptl_Variant15     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=15
-#pragma kernel Deferred_Indirect_Fptl_Variant16     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=16
-#pragma kernel Deferred_Indirect_Fptl_Variant17     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=17
-#pragma kernel Deferred_Indirect_Fptl_Variant18     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=18
-#pragma kernel Deferred_Indirect_Fptl_Variant19     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=19
-#pragma kernel Deferred_Indirect_Fptl_Variant20     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=20
-#pragma kernel Deferred_Indirect_Fptl_Variant21     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=21
-#pragma kernel Deferred_Indirect_Fptl_Variant22     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=22
-#pragma kernel Deferred_Indirect_Fptl_Variant23     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=23
-#pragma kernel Deferred_Indirect_Fptl_Variant24     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=24
-#pragma kernel Deferred_Indirect_Fptl_Variant25     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Fptl_Variant26     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=26
-
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant0       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant0       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=0
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant1       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant1       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=1
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant2       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant2       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=2
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant3       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant3       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=3
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant4       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant4       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=4
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant5       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant5       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=5
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant6       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant6       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=6
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant7       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant7       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=7
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant8       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant8       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=8
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant9       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant9       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=9
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant10      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant10      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=10
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant11      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant11      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=11
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant12      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant12      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=12
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant13      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant13      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=13
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant14      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant14      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=14
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant15      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant15      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=15
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant16      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant16      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=16
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant17      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant17      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=17
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant18      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant18      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=18
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant19      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant19      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=19
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant20      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant20      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=20
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant21      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant21      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=21
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant22      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant22      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=22
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant23      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant23      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=23
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant24      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant24      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=24
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant25      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant25      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=25
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
+#pragma kernel Deferred_Indirect_Fptl_Variant0      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0      USE_INDIRECT    VARIANT=0
+#pragma kernel Deferred_Indirect_Fptl_Variant1      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1      USE_INDIRECT    VARIANT=1
+#pragma kernel Deferred_Indirect_Fptl_Variant2      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2      USE_INDIRECT    VARIANT=2
+#pragma kernel Deferred_Indirect_Fptl_Variant3      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3      USE_INDIRECT    VARIANT=3
+#pragma kernel Deferred_Indirect_Fptl_Variant4      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4      USE_INDIRECT    VARIANT=4
+#pragma kernel Deferred_Indirect_Fptl_Variant5      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5      USE_INDIRECT    VARIANT=5
+#pragma kernel Deferred_Indirect_Fptl_Variant6      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6      USE_INDIRECT    VARIANT=6
+#pragma kernel Deferred_Indirect_Fptl_Variant7      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7      USE_INDIRECT    VARIANT=7
+#pragma kernel Deferred_Indirect_Fptl_Variant8      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8      USE_INDIRECT    VARIANT=8
+#pragma kernel Deferred_Indirect_Fptl_Variant9      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9      USE_INDIRECT    VARIANT=9
+#pragma kernel Deferred_Indirect_Fptl_Variant10     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10     USE_INDIRECT    VARIANT=10
+#pragma kernel Deferred_Indirect_Fptl_Variant11     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11     USE_INDIRECT    VARIANT=11
+#pragma kernel Deferred_Indirect_Fptl_Variant12     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12     USE_INDIRECT    VARIANT=12
+#pragma kernel Deferred_Indirect_Fptl_Variant13     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13     USE_INDIRECT    VARIANT=13
+#pragma kernel Deferred_Indirect_Fptl_Variant14     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14     USE_INDIRECT    VARIANT=14
+#pragma kernel Deferred_Indirect_Fptl_Variant15     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15     USE_INDIRECT    VARIANT=15
+#pragma kernel Deferred_Indirect_Fptl_Variant16     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16     USE_INDIRECT    VARIANT=16
+#pragma kernel Deferred_Indirect_Fptl_Variant17     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17     USE_INDIRECT    VARIANT=17
+#pragma kernel Deferred_Indirect_Fptl_Variant18     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18     USE_INDIRECT    VARIANT=18
+#pragma kernel Deferred_Indirect_Fptl_Variant19     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19     USE_INDIRECT    VARIANT=19
+#pragma kernel Deferred_Indirect_Fptl_Variant20     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20     USE_INDIRECT    VARIANT=20
+#pragma kernel Deferred_Indirect_Fptl_Variant21     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21     USE_INDIRECT    VARIANT=21
+#pragma kernel Deferred_Indirect_Fptl_Variant22     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22     USE_INDIRECT    VARIANT=22
+#pragma kernel Deferred_Indirect_Fptl_Variant23     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23     USE_INDIRECT    VARIANT=23
+#pragma kernel Deferred_Indirect_Fptl_Variant24     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24     USE_INDIRECT    VARIANT=24
+#pragma kernel Deferred_Indirect_Fptl_Variant25     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25     USE_INDIRECT    VARIANT=25
+#pragma kernel Deferred_Indirect_Fptl_Variant26     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26     USE_INDIRECT    VARIANT=26
-/* Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-#pragma kernel Deferred_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
-#pragma kernel Deferred_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
-#pragma kernel Deferred_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
-#pragma kernel Deferred_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
-#pragma kernel Deferred_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
-#pragma kernel Deferred_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
-#pragma kernel Deferred_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
-#pragma kernel Deferred_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
-#pragma kernel Deferred_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
-#pragma kernel Deferred_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
-#pragma kernel Deferred_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
-#pragma kernel Deferred_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
-#pragma kernel Deferred_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
-#pragma kernel Deferred_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
-#pragma kernel Deferred_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
-#pragma kernel Deferred_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
-#pragma kernel Deferred_Indirect_Clustered_Variant16         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant16             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=16
-#pragma kernel Deferred_Indirect_Clustered_Variant17         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant17             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=17
-#pragma kernel Deferred_Indirect_Clustered_Variant18         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant18             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=18
-#pragma kernel Deferred_Indirect_Clustered_Variant19         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant19             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=19
-#pragma kernel Deferred_Indirect_Clustered_Variant20         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant20             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=20
-#pragma kernel Deferred_Indirect_Clustered_Variant21         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant21             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=21
-#pragma kernel Deferred_Indirect_Clustered_Variant22         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant22             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=22
-#pragma kernel Deferred_Indirect_Clustered_Variant23         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant23             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=23
-#pragma kernel Deferred_Indirect_Clustered_Variant24         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant24             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=24
-#pragma kernel Deferred_Indirect_Clustered_Variant25         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant25             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Clustered_Variant26         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant26             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=26
-*/
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant0       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant0       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=0
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant1       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant1       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=1
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant2       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant2       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=2
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant3       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant3       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=3
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant4       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant4       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=4
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant5       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant5       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=5
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant6       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant6       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=6
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant7       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant7       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=7
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant8       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant8       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=8
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant9       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant9       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=9
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant10      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant10      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=10
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant11      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant11      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=11
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant12      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant12      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=12
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant13      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant13      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=13
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant14      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant14      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=14
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant15      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant15      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=15
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant16      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant16      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=16
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant17      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant17      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=17
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant18      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant18      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=18
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant19      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant19      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=19
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant20      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant20      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=20
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant21      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant21      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=21
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant22      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant22      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=22
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant23      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant23      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=23
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant24      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant24      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=24
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant25      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant25      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=25
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
+// deferred opaque always use FPTL
+#define USE_FPTL_LIGHTLIST 1
 
 //#pragma enable_d3d11_debug_symbols
 
 // variable declaration
 //-------------------------------------------------------------------------------------
 
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 #ifdef SHADOWS_SHADOWMASK
 TEXTURE2D(_ShadowMaskTexture);
 #endif
     UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
     float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
 
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeLightingData.bakeDiffuseLighting);
+    DECODE_FROM_GBUFFER(posInput.unPositionSS, featureFlags, bsdfData, bakeLightingData.bakeDiffuseLighting);
     #ifdef SHADOWS_SHADOWMASK
     DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
     #endif

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             public bool enableComputeLightEvaluation;
             public bool enableComputeLightVariants;
             public bool enableComputeMaterialVariants;
+            // Deferred opaque always use FPTL, forward opaque can use FPTL or cluster, transparent always use cluster
+            // When MSAA is enabled, we only support cluster (Fptl is too slow with MSAA), and we don't support MSAA for deferred path (mean it is ok to keep fptl)
+            public bool enableFptlForForwardOpaque;
-            public bool enableClustered;
-            public bool enableFptlForOpaqueWhenClustered; // still useful on opaques. Should be true by default to force tile on opaque.
             public bool enableBigTilePrepass;
 
             [Range(0.0f, 1.0f)]
 
-            public enum TileDebug : int
+            public enum TileClusterDebug : int
+            {
+                None,
+                Tile,
+                Cluster,
+                FeatureVariants
+            };
+
+            public enum TileClusterCategoryDebug : int
-                None = 0, Punctual = 1, Area = 2, AreaAndPunctual = 3, Environment = 4, EnvironmentAndPunctual = 5, EnvironmentAndArea = 6, EnvironmentAndAreaAndPunctual = 7,
-                FeatureVariants = 8
-            }; //TODO: we should probably make this checkboxes
+                Punctual = 1,
+                Area = 2,
+                AreaAndPunctual = 3,
+                Environment = 4,
+                EnvironmentAndPunctual = 5,
+                EnvironmentAndArea = 6,
+                EnvironmentAndAreaAndPunctual = 7
+            };
 
             public TileSettings()
             {
                 enableComputeMaterialVariants = true;
 
-                enableClustered = true;
-                enableFptlForOpaqueWhenClustered = true;
+                enableFptlForForwardOpaque = true;
                 enableBigTilePrepass = true;
 
                 diffuseGlobalDimmer = 1.0f;
             static int s_BuildMaterialFlagsWriteKernel;
             static int s_BuildMaterialFlagsOrKernel;
 
-            static int s_shadeOpaqueDirectClusteredKernel;
-            static int s_shadeOpaqueDirectClusteredDebugDisplayKernel;
-
-            static int s_shadeOpaqueDirectShadowMaskClusteredKernel;
-            static int s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel;
-            // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-            //static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.s_NumFeatureVariants];
             static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
             static int[] s_shadeOpaqueIndirectShadowMaskFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
 
             static ComputeBuffer s_GlobalLightListAtomic = null;
             // clustered light list specific buffers and data end
 
-            bool usingFptl
-            {
-                get
-                {
-                    bool isEnabledMSAA = false;
-                    Debug.Assert(!isEnabledMSAA || m_TileSettings.enableClustered);
-                    bool disableFptl = (!m_TileSettings.enableFptlForOpaqueWhenClustered && m_TileSettings.enableClustered) || isEnabledMSAA;
-                    return !disableFptl;
-                }
-            }
+            bool m_isFptlEnabled;
+            bool m_isFptlEnabledForForwardOpaque;
-            Material[, , , ,] m_lightingMaterial;
+            Material[] m_deferredLightingMaterial;
             Material m_DebugViewTilesMaterial;
 
             Light m_CurrentSunLight;
                 return (camera.pixelHeight + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
             }
 
-            public static bool GetFeatureVariantsEnabled(TileSettings tileSettings)
+            public bool GetFeatureVariantsEnabled()
-                return tileSettings.enableComputeLightEvaluation && (tileSettings.enableComputeLightVariants || tileSettings.enableComputeMaterialVariants) && !(tileSettings.enableClustered && !tileSettings.enableFptlForOpaqueWhenClustered);
+                return m_isFptlEnabled && m_TileSettings.enableComputeLightEvaluation && (m_TileSettings.enableComputeLightVariants || m_TileSettings.enableComputeMaterialVariants);
             }
 
             TileSettings m_TileSettings = null;
             {}
 
-            public void Build(RenderPipelineResources renderPipelineResources, TileSettings tileSettings, TextureSettings textureSettings, ShadowInitParameters shadowInit, ShadowSettings shadowSettings)
+            int GetDeferredLightingMaterialIndex(int outputSplitLighting, int lightLoopTilePass, int shadowMask, int debugDisplay)
+            {
+                return (outputSplitLighting) | (lightLoopTilePass << 1) | (shadowMask << 2) | (debugDisplay << 3);
+            }
+
+            public void Build(  RenderPipelineResources renderPipelineResources,
+                                RenderingSettings renderingSettings,
+                                TileSettings tileSettings,
+                                TextureSettings textureSettings,
+                                ShadowInitParameters shadowInit, ShadowSettings shadowSettings)
+                // Deferred opaque are always using Fptl. Forward opaque can use Fptl or Cluster, transparent use cluster.
+                // When MSAA is enabled we disable Fptl as it become expensive compare to cluster
+                // In HD, MSAA is only supported for forward only rendering, no MSAA in deferred mode (for code complexity reasons)
+
+                // If Deferred, enable Fptl. If we are forward renderer only and not using Fptl for forward opaque, disable Fptl
+                m_isFptlEnabled = !renderingSettings.ShouldUseForwardRenderingOnly() || tileSettings.enableFptlForForwardOpaque; // TODO: Disable if MSAA
+                m_isFptlEnabledForForwardOpaque = tileSettings.enableFptlForForwardOpaque; // TODO: Disable if MSAA
+
                 m_Resources = renderPipelineResources;
                 m_TileSettings = tileSettings;
 
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
-                bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings);
-                if (enableFeatureVariants)
+                if (GetFeatureVariantsEnabled())
                 {
                     s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_TileSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile_FeatureFlags" : "TileLightListGen_FeatureFlags");
                 }
                 s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
                 s_DispatchIndirectBuffer = new ComputeBuffer(LightDefinitions.s_NumFeatureVariants * 3, sizeof(uint), ComputeBufferType.IndirectArguments);
 
-                if (m_TileSettings.enableClustered)
+                // Cluster
                 {
                     var kernelName = m_TileSettings.enableBigTilePrepass ? (k_UseDepthBuffer ? "TileLightListGen_DepthRT_SrcBigTile" : "TileLightListGen_NoDepthRT_SrcBigTile") : (k_UseDepthBuffer ? "TileLightListGen_DepthRT" : "TileLightListGen_NoDepthRT");
                     s_GenListPerVoxelKernel = buildPerVoxelLightListShader.FindKernel(kernelName);
                 s_BuildMaterialFlagsOrKernel = buildMaterialFlagsShader.FindKernel("MaterialFlagsGen_Or");
                 s_BuildMaterialFlagsWriteKernel = buildMaterialFlagsShader.FindKernel("MaterialFlagsGen_Write");
 
-                s_shadeOpaqueDirectClusteredKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered");
-                s_shadeOpaqueDirectClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_Clustered_DebugDisplay");
-                s_shadeOpaqueDirectShadowMaskClusteredKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Clustered");
-                s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Clustered_DebugDisplay");
                 s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel = deferredComputeShader.FindKernel("Deferred_Direct_ShadowMask_Fptl_DebugDisplay");
 
                 s_deferredDirectionalShadowKernel = deferredDirectionalShadowComputeShader.FindKernel("DeferredDirectionalShadow");
-                    // Tag: SUPPORT_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque (by default we support only fptl on opaque)
-                    // s_shadeOpaqueIndirectClusteredKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Clustered_Variant" + variant);
                     s_shadeOpaqueIndirectFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_Fptl_Variant" + variant);
                     s_shadeOpaqueIndirectShadowMaskFptlKernels[variant] = deferredComputeShader.FindKernel("Deferred_Indirect_ShadowMask_Fptl_Variant" + variant);
                 }
                 s_TileFeatureFlags = null;
 
-                // OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
-                m_lightingMaterial = new Material[2, 2, 2, 2, 2];
+                // OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - DEBUG_DISPLAY
+                m_deferredLightingMaterial = new Material[16];
-                        for (int ShadowMask = 0; ShadowMask < 2; ++ShadowMask)
+                        for (int shadowMask = 0; shadowMask < 2; ++shadowMask)
-                            for (int clustered = 0; clustered < 2; ++clustered)
+                            for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
-                                for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
-                                {
-                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay] = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
-                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "OUTPUT_SPLIT_LIGHTING", outputSplitLighting == 1);
-                                    CoreUtils.SelectKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "LIGHTLOOP_TILE_PASS", "LIGHTLOOP_SINGLE_PASS", lightLoopTilePass == 1);
-                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "SHADOWS_SHADOWMASK", ShadowMask == 1);
-                                    CoreUtils.SelectKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", clustered == 1);
-                                    CoreUtils.SetKeyword(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay], "DEBUG_DISPLAY", debugDisplay == 1);
+                                int index = GetDeferredLightingMaterialIndex(outputSplitLighting, lightLoopTilePass, shadowMask, debugDisplay);
+
+                                m_deferredLightingMaterial[index] = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
+                                CoreUtils.SetKeyword(m_deferredLightingMaterial[index], "OUTPUT_SPLIT_LIGHTING", outputSplitLighting == 1);
+                                CoreUtils.SelectKeyword(m_deferredLightingMaterial[index], "LIGHTLOOP_TILE_PASS", "LIGHTLOOP_SINGLE_PASS", lightLoopTilePass == 1);
+                                CoreUtils.SetKeyword(m_deferredLightingMaterial[index], "SHADOWS_SHADOWMASK", shadowMask == 1);
+                                CoreUtils.SetKeyword(m_deferredLightingMaterial[index], "DEBUG_DISPLAY", debugDisplay == 1);
-                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._StencilRef, outputSplitLighting == 1 ? (int)StencilLightingUsage.SplitLighting : (int)StencilLightingUsage.RegularLighting);
-                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
-                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
-                                    m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay].SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
-                                }
+                                m_deferredLightingMaterial[index].SetInt(HDShaderIDs._StencilRef, outputSplitLighting == 1 ? (int)StencilLightingUsage.SplitLighting : (int)StencilLightingUsage.RegularLighting);
+                                m_deferredLightingMaterial[index].SetInt(HDShaderIDs._StencilCmp, (int)CompareFunction.Equal);
+                                m_deferredLightingMaterial[index].SetInt(HDShaderIDs._SrcBlend, (int)BlendMode.One);
+                                m_deferredLightingMaterial[index].SetInt(HDShaderIDs._DstBlend, (int)BlendMode.Zero);
                             }
                         }
                     }
                 {
                     for (int lightLoopTilePass = 0; lightLoopTilePass < 2; ++lightLoopTilePass)
                     {
-                        for (int ShadowMask = 0; ShadowMask < 2; ++ShadowMask)
+                        for (int shadowMask = 0; shadowMask < 2; ++shadowMask)
-                            for (int clustered = 0; clustered < 2; ++clustered)
+                            for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
-                                for (int debugDisplay = 0; debugDisplay < 2; ++debugDisplay)
-                                {
-                                    CoreUtils.Destroy(m_lightingMaterial[outputSplitLighting, lightLoopTilePass, ShadowMask, clustered, debugDisplay]);
-                                }
+                                int index = GetDeferredLightingMaterialIndex(outputSplitLighting, lightLoopTilePass, shadowMask, debugDisplay);
+                                CoreUtils.Destroy(m_deferredLightingMaterial[index]);
                             }
                         }
                     }
             {
                 return s_LightList == null || s_TileList == null || s_TileFeatureFlags == null ||
                     (s_BigTileLightList == null && m_TileSettings.enableBigTilePrepass) ||
-                    (s_PerVoxelLightLists == null && m_TileSettings.enableClustered);
+                    (s_PerVoxelLightLists == null);
             }
 
             public void ReleaseResolutionDependentBuffers()
                 s_TileList = new ComputeBuffer((int)LightDefinitions.s_NumFeatureVariants * nrTiles, sizeof(uint));
                 s_TileFeatureFlags = new ComputeBuffer(nrTilesX * nrTilesY, sizeof(uint));
 
-                if (m_TileSettings.enableClustered)
+                // Cluster
                 {
                     var nrClustersX = (width + LightDefinitions.s_TileSizeClustered - 1) / LightDefinitions.s_TileSizeClustered;
                     var nrClustersY = (height + LightDefinitions.s_TileSizeClustered - 1) / LightDefinitions.s_TileSizeClustered;
                 var numTilesX = GetNumTileFtplX(camera);
                 var numTilesY = GetNumTileFtplY(camera);
                 var numTiles = numTilesX * numTilesY;
-                bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings);
+                bool enableFeatureVariants = GetFeatureVariantsEnabled();
-                if (usingFptl)       // optimized for opaques only
+                // optimized for opaques only
+                if (m_isFptlEnabled)
                 {
                     cmd.SetComputeIntParam(buildPerTileLightListShader, HDShaderIDs.g_isOrthographic, isOrthographic ? 1 : 0);
                     cmd.SetComputeIntParams(buildPerTileLightListShader, HDShaderIDs.g_viDimensions, w, h);
                     cmd.DispatchCompute(buildPerTileLightListShader, s_GenListPerTileKernel, numTilesX, numTilesY, 1);
                 }
 
-                if (m_TileSettings.enableClustered)        // works for transparencies too.
-                {
-                    VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
-                }
+                // Cluster
+                VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBufferRT);
 
                 if (enableFeatureVariants)
                 {
                     if (m_TileSettings.enableBigTilePrepass)
                         cmd.SetGlobalBuffer(HDShaderIDs.g_vBigTileLightList, s_BigTileLightList);
 
-                    if (m_TileSettings.enableClustered)
+                    // Cluster
                     {
                         cmd.SetGlobalFloat(HDShaderIDs.g_fClustScale, m_ClustScale);
                         cmd.SetGlobalFloat(HDShaderIDs.g_fClustBase, k_ClustLogBase);
                 m_ShadowMgr.RenderShadows(m_FrameId, renderContext, cmd, cullResults, cullResults.visibleLights);
             }
 
-            public void RenderLightingDebug(HDCamera hdCamera, CommandBuffer cmd, RenderTargetIdentifier colorBuffer, DebugDisplaySettings debugDisplaySettings)
-            {
-                LightingDebugSettings lightingDebug = debugDisplaySettings.lightingDebugSettings;
-                if (lightingDebug.tileDebugByCategory == TileSettings.TileDebug.None)
-                    return;
-
-                using (new ProfilingSample(cmd, "Tiled Lighting Debug", HDRenderPipeline.GetSampler(CustomSamplerId.TPTiledLightingDebug)))
-                {
-                    bool bUseClusteredForDeferred = !usingFptl;
-
-                    int w = hdCamera.camera.pixelWidth;
-                    int h = hdCamera.camera.pixelHeight;
-                    int numTilesX = (w + 15) / 16;
-                    int numTilesY = (h + 15) / 16;
-                    int numTiles = numTilesX * numTilesY;
-
-                    Vector2 mousePixelCoord = Input.mousePosition;
-    #if UNITY_EDITOR
-                    if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
-                    {
-                        mousePixelCoord = m_mousePosition;
-                        mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
-                    }
-    #endif
-
-                    // Debug tiles
-                    if (lightingDebug.tileDebugByCategory == TileSettings.TileDebug.FeatureVariants)
-                    {
-                        if (GetFeatureVariantsEnabled(m_TileSettings))
-                        {
-                            // featureVariants
-                            m_DebugViewTilesMaterial.SetInt(HDShaderIDs._NumTiles, numTiles);
-                            m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileDebugByCategory);
-                            m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
-                            m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_TileList, s_TileList);
-                            m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
-                            m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                            m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                            m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
-                            m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
-                            cmd.SetRenderTarget(colorBuffer);
-                            cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
-                        }
-                    }
-                    else if (lightingDebug.tileDebugByCategory != TileSettings.TileDebug.None)
-                    {
-                        // lightCategories
-                        m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileDebugByCategory);
-                        m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
-                        m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                        m_DebugViewTilesMaterial.DisableKeyword(!bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
-                        m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
-                        m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
-
-                        CoreUtils.DrawFullScreen(cmd, m_DebugViewTilesMaterial, 0, colorBuffer);
-                    }
-                }
-            }
-
             public struct LightingPassOptions
             {
                 public bool outputSplitLighting;
                                                 RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthStencilBuffer, RenderTargetIdentifier depthTexture,
                                                 LightingPassOptions options)
             {
-                var bUseClusteredForDeferred = !usingFptl;
-                cmd.SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                cmd.SetGlobalBuffer(HDShaderIDs.g_vLightListGlobal, s_LightList);
 
                 if (m_TileSettings.enableTileAndCluster && m_TileSettings.enableComputeLightEvaluation && options.outputSplitLighting)
                 {
                         int numTilesY = (h + 15) / 16;
                         int numTiles = numTilesX * numTilesY;
 
-                        bool enableFeatureVariants = GetFeatureVariantsEnabled(m_TileSettings) && !debugDisplaySettings.IsDebugDisplayEnabled();
+                        bool enableFeatureVariants = GetFeatureVariantsEnabled() && !debugDisplaySettings.IsDebugDisplayEnabled();
 
                         int numVariants = 1;
                         if (enableFeatureVariants)
 
                             if (enableFeatureVariants)
                             {
-                                // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Update the code with following comment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                                // kernel = usingFptl ? s_shadeOpaqueIndirectFptlKernels[variant] : s_shadeOpaqueIndirectClusteredKernels[variant];
                                 if (m_enableBakeShadowMask)
                                     kernel = s_shadeOpaqueIndirectShadowMaskFptlKernels[variant];
                                 else
                             {
                                 if (m_enableBakeShadowMask)
                                 {
-                                    if (debugDisplaySettings.IsDebugDisplayEnabled())
-                                        kernel = usingFptl ? s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel : s_shadeOpaqueDirectShadowMaskClusteredDebugDisplayKernel;
-                                    else
-                                        kernel = usingFptl ? s_shadeOpaqueDirectShadowMaskFptlKernel : s_shadeOpaqueDirectShadowMaskClusteredKernel;
+                                    kernel = debugDisplaySettings.IsDebugDisplayEnabled() ? s_shadeOpaqueDirectShadowMaskFptlDebugDisplayKernel : s_shadeOpaqueDirectShadowMaskFptlKernel;
-                                    if (debugDisplaySettings.IsDebugDisplayEnabled())
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectClusteredDebugDisplayKernel;
-                                    else
-                                        kernel = usingFptl ? s_shadeOpaqueDirectFptlKernel : s_shadeOpaqueDirectClusteredKernel;
+                                    kernel = debugDisplaySettings.IsDebugDisplayEnabled() ? s_shadeOpaqueDirectFptlDebugDisplayKernel : s_shadeOpaqueDirectFptlKernel;
                                 }
                             }
 
                     }
                     else // Pixel shader evaluation
                     {
-                        // OUTPUT_SPLIT_LIGHTING - LIGHTLOOP_TILE_PASS - SHADOWS_SHADOWMASK - USE_FPTL_LIGHTLIST/USE_CLUSTERED_LIGHTLIST - DEBUG_DISPLAY
-                        Material currentLightingMaterial = m_lightingMaterial[options.outputSplitLighting ? 1 : 0,
-                                                                                m_TileSettings.enableTileAndCluster ? 1 : 0,
-                                                                                m_enableBakeShadowMask ? 1 : 0,
-                                                                                bUseClusteredForDeferred ? 1 : 0,
-                                                                                debugDisplaySettings.IsDebugDisplayEnabled() ? 1 : 0];
+                        int index = GetDeferredLightingMaterialIndex(   options.outputSplitLighting ? 1 : 0,
+                                                                        m_TileSettings.enableTileAndCluster ? 1 : 0,
+                                                                        m_enableBakeShadowMask ? 1 : 0,
+                                                                        debugDisplaySettings.IsDebugDisplayEnabled() ? 1 : 0);
+
+                        Material currentLightingMaterial = m_deferredLightingMaterial[index];
 
                         if (options.outputSplitLighting)
                         {
                 else
                 {
                     // Only opaques can use FPTL, transparent must use clustered!
-                    bool useFptl = renderOpaque && usingFptl;
+                    bool useFptl = renderOpaque && m_isFptlEnabledForForwardOpaque;
 
                     using (new ProfilingSample(cmd, useFptl ? "Forward Tiled pass" : "Forward Clustered pass", HDRenderPipeline.GetSampler(CustomSamplerId.TPForwardTiledClusterpass)))
                     {
-                        cmd.SetGlobalFloat(HDShaderIDs._UseTileLightList, useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
+                        CoreUtils.SetKeyword(cmd, "USE_FPTL_LIGHTLIST", useFptl);
+                        CoreUtils.SetKeyword(cmd, "USE_CLUSTERED_LIGHTLIST", !useFptl);
-            public void RenderDebugOverlay(Camera camera, CommandBuffer cmd, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
+            public void RenderDebugOverlay(HDCamera hdCamera, CommandBuffer cmd, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)
+
+                using (new ProfilingSample(cmd, "Tiled/cluster Lighting Debug", HDRenderPipeline.GetSampler(CustomSamplerId.TPTiledLightingDebug)))
+                {
+                    if (lightingDebug.tileClusterDebug != TileSettings.TileClusterDebug.None)
+                    {
+
+                        int w = hdCamera.camera.pixelWidth;
+                        int h = hdCamera.camera.pixelHeight;
+                        int numTilesX = (w + 15) / 16;
+                        int numTilesY = (h + 15) / 16;
+                        int numTiles = numTilesX * numTilesY;
+
+                        Vector2 mousePixelCoord = Input.mousePosition;
+#if UNITY_EDITOR
+                        if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+                        {
+                            mousePixelCoord = m_mousePosition;
+                            mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
+                        }
+#endif
+
+                        // Debug tiles
+                        if (lightingDebug.tileClusterDebug == TileSettings.TileClusterDebug.FeatureVariants)
+                        {
+                            if (GetFeatureVariantsEnabled())
+                            {
+                                // featureVariants
+                                m_DebugViewTilesMaterial.SetInt(HDShaderIDs._NumTiles, numTiles);
+                                m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileClusterDebugByCategory);
+                                m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
+                                m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_TileList, s_TileList);
+                                m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_DispatchIndirectBuffer, s_DispatchIndirectBuffer);
+                                m_DebugViewTilesMaterial.EnableKeyword("USE_FPTL_LIGHTLIST");
+                                m_DebugViewTilesMaterial.DisableKeyword("USE_CLUSTERED_LIGHTLIST");
+                                m_DebugViewTilesMaterial.DisableKeyword("SHOW_LIGHT_CATEGORIES");
+                                m_DebugViewTilesMaterial.EnableKeyword("SHOW_FEATURE_VARIANTS");
+                                cmd.DrawProcedural(Matrix4x4.identity, m_DebugViewTilesMaterial, 0, MeshTopology.Triangles, numTiles * 6);
+                            }
+                        }
+                        else // tile or cluster
+                        {
+                            bool bUseClustered = lightingDebug.tileClusterDebug == TileSettings.TileClusterDebug.Cluster;
+
+                            // lightCategories
+                            m_DebugViewTilesMaterial.SetInt(HDShaderIDs._ViewTilesFlags, (int)lightingDebug.tileClusterDebugByCategory);
+                            m_DebugViewTilesMaterial.SetVector(HDShaderIDs._MousePixelCoord, mousePixelCoord);
+                            m_DebugViewTilesMaterial.SetBuffer(HDShaderIDs.g_vLightListGlobal, bUseClustered ? s_PerVoxelLightLists : s_LightList);
+                            m_DebugViewTilesMaterial.EnableKeyword(bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                            m_DebugViewTilesMaterial.DisableKeyword(!bUseClustered ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                            m_DebugViewTilesMaterial.EnableKeyword("SHOW_LIGHT_CATEGORIES");
+                            m_DebugViewTilesMaterial.DisableKeyword("SHOW_FEATURE_VARIANTS");
+
+                            CoreUtils.DrawFullScreen(cmd, m_DebugViewTilesMaterial, 0);
+                        }
+                    }
+                }
+ 
                 using (new ProfilingSample(cmd, "Display Shadows", HDRenderPipeline.GetSampler(CustomSamplerId.TPDisplayShadows)))
                 {
                     if (lightingDebug.shadowDebugMode == ShadowMapDebugMode.VisualizeShadowMap)
                             for (uint i = 0; i < faceCount; ++i)
                             {
                                 m_ShadowMgr.DisplayShadow(cmd, index, i, x, y, overlaySize, overlaySize, lightingDebug.shadowMinValue, lightingDebug.shadowMaxValue);
-                                HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
+                                HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, hdCamera.camera.pixelWidth);
                             }
                         }
                     }
-                        HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, camera.pixelWidth);
+                        HDUtils.NextOverlayCoord(ref x, ref y, overlaySize, overlaySize, hdCamera.camera.pixelWidth);
                     }
                 }
             }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

-#include "TilePass.cs.hlsl"
+#include "TilePass.cs.hlsl"
 #include "../../Sky/SkyVariables.hlsl"
 
 StructuredBuffer<uint> g_vLightListGlobal;      // don't support Buffer yet in unity
 int g_iLog2NumClusters; // We need to always define these to keep constant buffer layouts compatible
 
 uint g_isLogBaseBufferEnabled;
-uint _UseTileLightList;
 //#endif
 
 //#ifdef USE_CLUSTERED_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

 
 uint GetTileSize()
 {
-    if (_UseTileLightList)
-        return TILE_SIZE_FPTL;
-    else
-        return TILE_SIZE_CLUSTERED;
+    return TILE_SIZE_CLUSTERED;
 }
 
 void GetCountAndStartCluster(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
 
 void GetCountAndStart(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
 {
-    if (_UseTileLightList)
-        GetCountAndStartTile(posInput, lightCategory, start, lightCount);
-    else
-        GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
+    GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
-    uint offset = tileOffset + lightIndex;
-    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
-
-    if (_UseTileLightList)
-        offset = DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1);
-
-    // Avoid generated HLSL bytecode to always access g_vLightListGlobal with
-    // two different offsets, fixes out of bounds issue
-    uint value = g_vLightListGlobal[offset];
-
-    // Light index are store on 16bit
-    return (_UseTileLightList ? ((value >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff) : value);
+    return g_vLightListGlobal[tileOffset + lightIndex];
 }
 
 #endif // USE_FPTL_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/materialflags.compute

 RWStructuredBuffer<uint> g_TileFeatureFlags;
 
 TEXTURE2D(_StencilTexture);               // DXGI_FORMAT_R8_UINT is not supported by Unity
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
 [numthreads(NR_THREADS, 1, 1)]
 void MATERIALFLAGSGEN(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 		if (UnpackByte(LOAD_TEXTURE2D(_StencilTexture, uCrd).r) != STENCILLIGHTINGUSAGE_NO_LIGHTING) // This test is we are the sky/background or not
 		{
 			PositionInputs posInput = GetPositionInput(uCrd, invScreenSize);
-			FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-			materialFeatureFlags |= MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(gbuffer);
+            materialFeatureFlags |= MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(posInput.unPositionSS);
 		}
 	}
 

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../ShaderVariables.hlsl"
-            #include "../../Lighting/Forward.hlsl"
+            #include "../../ShaderVariables.hlsl"          
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLitTessellation.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"
             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "LayeredLitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 #define GBufferType3 float4
 #endif
 
+// GBuffer texture declaration
+TEXTURE2D(_GBufferTexture0);
+TEXTURE2D(_GBufferTexture1);
+TEXTURE2D(_GBufferTexture2);
+TEXTURE2D(_GBufferTexture3);
+
 // Reference Lambert diffuse / GGX Specular for IBL and area lights
 #ifdef HAS_LIGHTLOOP // Both reference define below need to be define only if LightLoop is present, else we get a compile error
 // #define LIT_DISPLAY_REFERENCE_AREA
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
 void EncodeIntoGBuffer( SurfaceData surfaceData,
                         float3 bakeDiffuseLighting,
+                        uint2 unPositionSS,
                         #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
                         out GBufferType0 outGBufferU0,
                         out GBufferType1 outGBufferU1
 }
 
 void DecodeFromGBuffer(
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    GBufferType0 inGBufferU0,
-    GBufferType1 inGBufferU1,
-#else
-    GBufferType0 inGBuffer0,
-    GBufferType1 inGBuffer1,
-    GBufferType2 inGBuffer2,
-    GBufferType3 inGBuffer3,
-#endif
+    uint2 unPositionSS,
+#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+    GBufferType0 inGBufferU0 = LOAD_TEXTURE2D(_GBufferTexture0, unPositionSS);
+    GBufferType1 inGBufferU1 = LOAD_TEXTURE2D(_GBufferTexture1, unPositionSS);
+#else
+    GBufferType0 inGBuffer0 = LOAD_TEXTURE2D(_GBufferTexture0, unPositionSS);
+    GBufferType1 inGBuffer1 = LOAD_TEXTURE2D(_GBufferTexture1, unPositionSS);
+    GBufferType2 inGBuffer2 = LOAD_TEXTURE2D(_GBufferTexture2, unPositionSS);
+    GBufferType3 inGBuffer3 = LOAD_TEXTURE2D(_GBufferTexture3, unPositionSS);
+#endif
+
     ZERO_INITIALIZE(BSDFData, bsdfData);
 
     g_FeatureFlags = featureFlags;
 
 // Function call from the material classification compute shader
 // Note that as we store materialId on two buffer (for anisotropy case), the code need to load 2 RGBA8 buffer
-uint MaterialFeatureFlagsFromGBuffer(
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    GBufferType0 inGBufferU0,
-    GBufferType1 inGBufferU1
-#else
-    GBufferType0 inGBuffer0,
-    GBufferType1 inGBuffer1,
-    GBufferType2 inGBuffer2,
-    GBufferType3 inGBuffer3
-#endif
-)
+uint MaterialFeatureFlagsFromGBuffer(uint2 unPositionSS)
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-        inGBufferU0, inGBufferU1,
-#else
-        inGBuffer0, inGBuffer1, inGBuffer2, inGBuffer3,
-#endif
+        unPositionSS,
         0xFFFFFFFF,
         bsdfData,
         unused
 
         float ieta = 1.0 / bsdfData.coatIOR; // inverse eta
         preLightData.ieta = ieta;
-        preLightData.coatFresnel0 = Sqr(bsdfData.coatIOR - 1.0) / Sqr(bsdfData.coatIOR + 1.0);
+        preLightData.coatFresnel0 = Sq(bsdfData.coatIOR - 1.0) / Sq(bsdfData.coatIOR + 1.0);
 
         // Clear coat IBL
         preLightData.coatIblDirWS = reflect(-V, N);
         // Update the roughness and the IBL miplevel
         // Bottom layer is affected by upper layer BRDF, result can't be more sharp than input (it is to mimic what a path tracer will do)
         float roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
-        float shininess = Sqr(preLightData.ieta) * (2.0 / Sqr(roughness) - 2.0);
+        float shininess = Sq(preLightData.ieta) * (2.0 / Sq(roughness) - 2.0);
         roughness = sqrt(2.0 / (shininess + 2.0));
         preLightData.iblDirWS = GetSpecularDominantDir(N, iblR, roughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(RoughnessToPerceptualRoughness(roughness));
     {
         // Change the Fresnel term to account for transmission through Clear Coat and reflection on the base layer
         float F = F_Schlick(preLightData.coatFresnel0, preLightData.coatNdotV);
-        F = Sqr(-F * bsdfData.coatCoverage + 1.0);
+        F = Sq(-F * bsdfData.coatCoverage + 1.0);
         F /= preLightData.ieta; //TODO: LaurentB why / ieta here and not for other lights ?
 
         preLightData.ltcMagnitudeFresnel = F * bsdfData.fresnel0 * ltcGGXFresnelMagnitudeDiff + (float3)ltcGGXFresnelMagnitude;
         float NdotL = saturate(dot(bsdfData.coatNormalWS, L));
         float NdotV = preLightData.coatNdotV;
         float LdotV = dot(L, V);
-        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_SMALL));
+        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPSILON));
         float NdotH = saturate((NdotL + NdotV) * invLenLV);
         float LdotH = saturate(invLenLV * LdotV + invLenLV);
 
         specularLighting += F * D_GGX(NdotH, 0.01) * NdotL * bsdfData.coatCoverage;
 
         // Change the Fresnel term to account for transmission through Clear Coat and reflection on the base layer
-        F = Sqr(-F * bsdfData.coatCoverage + 1.0);
+        F = Sq(-F * bsdfData.coatCoverage + 1.0);
 
         // Change the Light and View direction to account for IOR change.
         // Update the half vector accordingly
     float NdotL    = saturate(dot(bsdfData.normalWS, L)); // Must have the same value without the clamp
     float NdotV    = preLightData.NdotV;                  // Get the unaltered (geometric) version
     float LdotV    = dot(L, V);
-    float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_SMALL)); // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
+    float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPSILON)); // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
     float NdotH    = saturate((NdotL + NdotV) * invLenLV);
     float LdotH    = saturate(invLenLV * LdotV + invLenLV);
 
         envLighting += F * preLD.rgb * bsdfData.coatCoverage;
 
         // Change the Fresnel term to account for transmission through Clear Coat and reflection on the base layer.
-        F = Sqr(-F * bsdfData.coatCoverage + 1.0);
+        F = Sq(-F * bsdfData.coatCoverage + 1.0);
     }
 
     float4 preLD = SampleEnv(lightLoopContext, lightData.envIndex, R, preLightData.iblMipLevel);

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     // Ambient occlusion is cosine weighted, thus use following equation. See slide 129
     float cosAv = sqrt(1.0 - surfaceData.ambientOcclusion);
     float roughness = max(PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness), 0.01); // Clamp to 0.01 to avoid edge cases
-    float cosAs = exp2(-3.32193 * Sqr(roughness));
+    float cosAs = exp2((-log(10.0)/log(2.0)) * Sq(roughness));
     float cosB = dot(bentNormalWS, reflect(-V, surfaceData.normalWS));
 
     return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs));

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitTessellation.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile _ SHADOWS_SHADOWMASK
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
-            #include "../../Lighting/Forward.hlsl"
             #include "../../Lighting/Lighting.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.compute

 float4 _WorldScales[SSS_N_PROFILES];                             // Size of the world unit in meters (only the X component is used)
 float4 _FilterKernels[SSS_N_PROFILES][SSS_N_SAMPLES_NEAR_FIELD]; // XY = near field, ZW = far field; 0 = radius, 1 = reciprocal of the PDF
 
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);           // Contains the albedo and SSS parameters
 TEXTURE2D(_DepthTexture);                           // Z-buffer
 TEXTURE2D(_HTile);                                  // DXGI_FORMAT_R8_UINT is not supported by Unity
 TEXTURE2D(_IrradianceSource);                       // Includes transmitted light
 
     [branch] if (!passedStencilTest || isOffScreen) { return; }
 
-    PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);
-
-    float3 unused;
+    PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw);    
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, pixelCoord);
-    DECODE_FROM_GBUFFER(gbuffer, MATERIALFEATUREFLAGS_LIT_SSS, bsdfData, unused);
+    float3 unused;
+    DECODE_FROM_GBUFFER(pixelCoord, MATERIALFEATUREFLAGS_LIT_SSS, bsdfData, unused);
 
     int    profileID   = bsdfData.subsurfaceProfile;
     float  distScale   = bsdfData.subsurfaceRadius;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/SubsurfaceScattering.shader

             float4 _HalfRcpWeightedVariances[SSS_BASIC_N_SAMPLES];           // RGB for chromatic, A for achromatic
 
             TEXTURE2D(_IrradianceSource);             // Includes transmitted light
-            DECLARE_GBUFFER_TEXTURE(_GBufferTexture); // Contains the albedo and SSS parameters
 
             //-------------------------------------------------------------------------------------
             // Implementation
 
             float4 Frag(Varyings input) : SV_Target
             {
-                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
-
-                float3 unused;
+                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);                
 
                 // Note: When we are in this SubsurfaceScattering shader we know that we are a SSS material. This shader is strongly coupled with the deferred Lit.shader.
                 // We can use the material classification facility to help the compiler to know we use SSS material and optimize the code (and don't require to read gbuffer with materialId).
-                FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-                DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, unused);
+                float3 unused;
+                DECODE_FROM_GBUFFER(posInput.unPositionSS, featureFlags, bsdfData, unused);
 
                 int    profileID   = bsdfData.subsurfaceProfile;
                 float  distScale   = bsdfData.subsurfaceRadius;

ScriptableRenderPipeline/HDRenderPipeline/Material/Material.hlsl

         out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
         out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1
 
-#define DECLARE_GBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));
-
-#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);
-
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
-#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
-#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
 
 #ifdef SHADOWS_SHADOWMASK
     #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target2
         out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
         out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2
 
-#define DECLARE_GBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));
-
-#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);
-
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
-#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
-#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
 
 #ifdef SHADOWS_SHADOWMASK
     #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target3
         out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
         out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3
 
-#define DECLARE_GBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));  \
-        TEXTURE2D(MERGE_NAME(NAME, 3));
-
-#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
-        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2);
-
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
-#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
-#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
 
 #ifdef SHADOWS_SHADOWMASK
     #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target4
         out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3,    \
         out GBufferType4 MERGE_NAME(NAME, 4) : SV_Target4
 
-#define DECLARE_GBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));  \
-        TEXTURE2D(MERGE_NAME(NAME, 3));  \
-        TEXTURE2D(MERGE_NAME(NAME, 4));
-
-#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
-        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2); \
-        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), unCoord2);
-
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
-#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
-#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
 
 #ifdef SHADOWS_SHADOWMASK
     #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target5
         out GBufferType4 MERGE_NAME(NAME, 4) : SV_Target4,    \
         out GBufferType5 MERGE_NAME(NAME, 5) : SV_Target5
 
-#define DECLARE_GBUFFER_TEXTURE(NAME)   \
-        TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        TEXTURE2D(MERGE_NAME(NAME, 1));  \
-        TEXTURE2D(MERGE_NAME(NAME, 2));  \
-        TEXTURE2D(MERGE_NAME(NAME, 3));  \
-        TEXTURE2D(MERGE_NAME(NAME, 4));  \
-        TEXTURE2D(MERGE_NAME(NAME, 5));
-
-#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
-        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
-        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
-        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
-        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2); \
-        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), unCoord2); \
-        GBufferType5 MERGE_NAME(NAME, 5) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 5), unCoord2);
-
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5))
-#define DECODE_FROM_GBUFFER(NAME, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5), FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
-#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(NAME) MaterialFeatureFlagsFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5))
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, UNPOSITIONSS, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), MERGE_NAME(NAME, 5))
 
 #ifdef SHADOWS_SHADOWMASK
     #define OUTPUT_GBUFFER_SHADOWMASK(NAME) ,out float4 NAME : SV_Target6
 #endif
 
 #endif
+
+#define DECODE_FROM_GBUFFER(UNPOSITIONSS, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(UNPOSITIONSS, FEATURE_FLAGS, BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+#define MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(UNPOSITIONSS) MaterialFeatureFlagsFromGBuffer(UNPOSITIONSS)
 
 #ifdef SHADOWS_SHADOWMASK
 #define ENCODE_SHADOWMASK_INTO_GBUFFER(SHADOWMASK, NAME) EncodeShadowMask(SHADOWMASK, NAME)

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassGBuffer.hlsl

 
     float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
 
-    ENCODE_INTO_GBUFFER(surfaceData, bakeDiffuseLighting, outGBuffer);
+    ENCODE_INTO_GBUFFER(surfaceData, bakeDiffuseLighting, posInput.unPositionSS, outGBuffer);
     ENCODE_SHADOWMASK_INTO_GBUFFER(float4(builtinData.shadowMask0, builtinData.shadowMask1, builtinData.shadowMask2, builtinData.shadowMask3), outShadowMaskBuffer);
     ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outVelocityBuffer);
 

ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

             int offset = 0;
             for (int i = 0; i < 6; ++i)
             {
-                Graphics.SetRenderTarget(m_SkyboxCubemapRT, 0, (CubemapFace)i);
+                UnityEngine.Graphics.SetRenderTarget(m_SkyboxCubemapRT, 0, (CubemapFace)i);
                 temp.ReadPixels(new Rect(0, 0, resolution, resolution), offset, 0);
                 temp.Apply();
                 offset += resolution;
             // Temporarily disabled until proper API reaches trunk
-            Graphics.Blit(temp, tempRT, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 0.0f));
+            UnityEngine.Graphics.Blit(temp, tempRT, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 0.0f));
-            Graphics.SetRenderTarget(null);
+            UnityEngine.Graphics.SetRenderTarget(null);
             Object.DestroyImmediate(temp);
             Object.DestroyImmediate(tempRT);
 

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/Core/ShaderLibrary/Macros.hlsl

+#ifndef UNITY_MACROS_INCLUDED
+#define UNITY_MACROS_INCLUDED
+
+// Some shader compiler don't support to do multiple ## for concatenation inside the same macro, it require an indirection.
+// This is the purpose of this macro
+#define MERGE_NAME(X, Y) X##Y
+
+// These define are use to abstract the way we sample into a cubemap array.
+// Some platform don't support cubemap array so we fallback on 2D latlong
+#ifdef  UNITY_NO_CUBEMAP_ARRAY
+#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURE2D_ARRAY
+#define SAMPLERCUBE_ABSTRACT SAMPLER2D
+#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURE2D_ARRAY_ARGS
+#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURE2D_ARRAY_PARAM
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, DirectionToLatLongCoordinate(coord3), index, lod)
+#else
+#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURECUBE_ARRAY
+#define SAMPLERCUBE_ABSTRACT SAMPLERCUBE
+#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURECUBE_ARRAY_ARGS
+#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURECUBE_ARRAY_PARAM
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)
+#endif
+
+#define TEMPLATE_1_FLT(FunctionName, Parameter1, FunctionBody) \
+float  FunctionName(float  Parameter1) { FunctionBody; } \
+float2 FunctionName(float2 Parameter1) { FunctionBody; } \
+float3 FunctionName(float3 Parameter1) { FunctionBody; } \
+float4 FunctionName(float4 Parameter1) { FunctionBody; }
+
+#define TEMPLATE_1_INT(FunctionName, Parameter1, FunctionBody) \
+int    FunctionName(int    Parameter1) { FunctionBody; } \
+int2   FunctionName(int2   Parameter1) { FunctionBody; } \
+int3   FunctionName(int3   Parameter1) { FunctionBody; } \
+int4   FunctionName(int4   Parameter1) { FunctionBody; } \
+uint   FunctionName(uint   Parameter1) { FunctionBody; } \
+uint2  FunctionName(uint2  Parameter1) { FunctionBody; } \
+uint3  FunctionName(uint3  Parameter1) { FunctionBody; } \
+uint4  FunctionName(uint4  Parameter1) { FunctionBody; }
+
+#define TEMPLATE_2_FLT(FunctionName, Parameter1, Parameter2, FunctionBody) \
+float  FunctionName(float  Parameter1, float  Parameter2) { FunctionBody; } \
+float2 FunctionName(float2 Parameter1, float2 Parameter2) { FunctionBody; } \
+float3 FunctionName(float3 Parameter1, float3 Parameter2) { FunctionBody; } \
+float4 FunctionName(float4 Parameter1, float4 Parameter2) { FunctionBody; }
+
+#define TEMPLATE_2_INT(FunctionName, Parameter1, Parameter2, FunctionBody) \
+int    FunctionName(int    Parameter1, int    Parameter2) { FunctionBody; } \
+int2   FunctionName(int2   Parameter1, int2   Parameter2) { FunctionBody; } \
+int3   FunctionName(int3   Parameter1, int3   Parameter2) { FunctionBody; } \
+int4   FunctionName(int4   Parameter1, int4   Parameter2) { FunctionBody; } \
+uint   FunctionName(uint   Parameter1, uint   Parameter2) { FunctionBody; } \
+uint2  FunctionName(uint2  Parameter1, uint2  Parameter2) { FunctionBody; } \
+uint3  FunctionName(uint3  Parameter1, uint3  Parameter2) { FunctionBody; } \
+uint4  FunctionName(uint4  Parameter1, uint4  Parameter2) { FunctionBody; }
+
+#define TEMPLATE_3_FLT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
+float  FunctionName(float  Parameter1, float  Parameter2, float  Parameter3) { FunctionBody; } \
+float2 FunctionName(float2 Parameter1, float2 Parameter2, float2 Parameter3) { FunctionBody; } \
+float3 FunctionName(float3 Parameter1, float3 Parameter2, float3 Parameter3) { FunctionBody; } \
+float4 FunctionName(float4 Parameter1, float4 Parameter2, float4 Parameter3) { FunctionBody; }
+
+#define TEMPLATE_3_INT(FunctionName, Parameter1, Parameter2, Parameter3, FunctionBody) \
+int    FunctionName(int    Parameter1, int    Parameter2, int    Parameter3) { FunctionBody; } \
+int2   FunctionName(int2   Parameter1, int2   Parameter2, int2   Parameter3) { FunctionBody; } \
+int3   FunctionName(int3   Parameter1, int3   Parameter2, int3   Parameter3) { FunctionBody; } \
+int4   FunctionName(int4   Parameter1, int4   Parameter2, int4   Parameter3) { FunctionBody; } \
+uint   FunctionName(uint   Parameter1, uint   Parameter2, uint   Parameter3) { FunctionBody; } \
+uint2  FunctionName(uint2  Parameter1, uint2  Parameter2, uint2  Parameter3) { FunctionBody; } \
+uint3  FunctionName(uint3  Parameter1, uint3  Parameter2, uint3  Parameter3) { FunctionBody; } \
+uint4  FunctionName(uint4  Parameter1, uint4  Parameter2, uint4  Parameter3) { FunctionBody; }
+
+#define TEMPLATE_SWAP(FunctionName) \
+void FunctionName(inout float  a, inout float  b) { float  t = a; a = b; b = t; } \
+void FunctionName(inout float2 a, inout float2 b) { float2 t = a; a = b; b = t; } \
+void FunctionName(inout float3 a, inout float3 b) { float3 t = a; a = b; b = t; } \
+void FunctionName(inout float4 a, inout float4 b) { float4 t = a; a = b; b = t; } \
+void FunctionName(inout int    a, inout int    b) { int    t = a; a = b; b = t; } \
+void FunctionName(inout int2   a, inout int2   b) { int2   t = a; a = b; b = t; } \
+void FunctionName(inout int3   a, inout int3   b) { int3   t = a; a = b; b = t; } \
+void FunctionName(inout int4   a, inout int4   b) { int4   t = a; a = b; b = t; } \
+void FunctionName(inout uint   a, inout uint   b) { uint   t = a; a = b; b = t; } \
+void FunctionName(inout uint2  a, inout uint2  b) { uint2  t = a; a = b; b = t; } \
+void FunctionName(inout uint3  a, inout uint3  b) { uint3  t = a; a = b; b = t; } \
+void FunctionName(inout uint4  a, inout uint4  b) { uint4  t = a; a = b; b = t; } \
+void FunctionName(inout bool   a, inout bool   b) { bool   t = a; a = b; b = t; } \
+void FunctionName(inout bool2  a, inout bool2  b) { bool2  t = a; a = b; b = t; } \
+void FunctionName(inout bool3  a, inout bool3  b) { bool3  t = a; a = b; b = t; } \
+void FunctionName(inout bool4  a, inout bool4  b) { bool4  t = a; a = b; b = t; }
+
+#endif // UNITY_MACROS_INCLUDED

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: