Merge branch 'master' into OnTileDeferred

Assets/Editor/Tests/RenderloopTests/CullResultsTest.cs

 {
     void InspectCullResults(Camera camera, CullResults cullResults, ScriptableRenderContext renderContext)
     {
-        VisibleReflectionProbe[] probes = cullResults.visibleReflectionProbes;
+        VisibleReflectionProbe[] probes = cullResults.visibleReflectionProbes.ToArray();
 
         Assert.AreEqual(1, probes.Length, "Incorrect reflection probe count");
 
-        VisibleLight[] lights = cullResults.visibleLights;
+        VisibleLight[] lights = cullResults.visibleLights.ToArray();
         Assert.AreEqual(3, lights.Length, "Incorrect light count");
 
         LightType[] expectedTypes = new LightType[] { LightType.Directional, LightType.Spot, LightType.Point };

Assets/Editor/Tests/RenderloopTests/RenderPipelineTestFixture.cs

 
     private static RenderLoopTestFixture m_Instance;
 
+    CullResults m_CullResults;
     public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
     {
         base.Render(renderContext, cameras);
             bool gotCullingParams = CullResults.GetCullingParameters(camera, out cullingParams);
             Assert.IsTrue(gotCullingParams);
 
-            CullResults cullResults = CullResults.Cull(ref cullingParams, renderContext);
+            CullResults.Cull(ref cullingParams, renderContext, ref m_CullResults);
-                s_Callback(camera, cullResults, renderContext);
+                s_Callback(camera, m_CullResults, renderContext);
         }
 
         renderContext.Submit();

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/MultiplePointLights.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.12731749, g: 0.13414757, b: 0.1210787, a: 1}
+  m_IndirectSpecularColor: {r: 0.12732536, g: 0.13415334, b: 0.121077195, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
-    m_PVRFiltering: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
-    m_PVRFilteringAtrousColorSigma: 1
-    m_PVRFilteringAtrousNormalSigma: 1
-    m_PVRFilteringAtrousPositionSigma: 1
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
   m_LightingDataAsset: {fileID: 0}
   m_UseShadowmask: 1
 --- !u!196 &4
   m_Script: {fileID: 11500000, guid: c20dfc007a9a74ad8a2bfd0d59abe398, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  renderPipeline: {fileID: 0}
+  renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 232121474}
   hdr: 0
   width: 1280

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/Shaders/LDPipe_LitShaderMaps.unity

     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
-    m_PVRFiltering: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
-    m_PVRFilteringAtrousColorSigma: 1
-    m_PVRFilteringAtrousNormalSigma: 1
-    m_PVRFilteringAtrousPositionSigma: 1
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
   m_LightingDataAsset: {fileID: 0}
   m_UseShadowmask: 1
 --- !u!196 &4
   m_Father: {fileID: 0}
   m_RootOrder: 3
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &222008785
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 222008789}
-  - component: {fileID: 222008788}
-  - component: {fileID: 222008787}
-  - component: {fileID: 222008786}
-  m_Layer: 0
-  m_Name: Quad (1)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!23 &222008786
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_Materials:
-  - {fileID: 2100000, guid: 96f2a4d5f3b72eb468a638a4bed6ca76, type: 2}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 1
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
---- !u!64 &222008787
-MeshCollider:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Material: {fileID: 0}
-  m_IsTrigger: 0
-  m_Enabled: 1
-  serializedVersion: 2
-  m_Convex: 0
-  m_InflateMesh: 0
-  m_SkinWidth: 0.01
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!33 &222008788
-MeshFilter:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!4 &222008789
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 222008785}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0.68, y: 0.041, z: -2.541}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 11
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &316403771
 GameObject:
   m_ObjectHideFlags: 0
   m_Children: []
   m_Father: {fileID: 0}
   m_RootOrder: 7
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1 &576034924
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 576034928}
-  - component: {fileID: 576034927}
-  - component: {fileID: 576034926}
-  - component: {fileID: 576034925}
-  m_Layer: 0
-  m_Name: Quad
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!23 &576034925
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_Materials:
-  - {fileID: 2100000, guid: f51bbc8f90c3bf54588afe5d142636b3, type: 2}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 1
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
---- !u!64 &576034926
-MeshCollider:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Material: {fileID: 0}
-  m_IsTrigger: 0
-  m_Enabled: 1
-  serializedVersion: 2
-  m_Convex: 0
-  m_InflateMesh: 0
-  m_SkinWidth: 0.01
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!33 &576034927
-MeshFilter:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!4 &576034928
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 576034924}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: -0.504, y: 0.041, z: -2.541}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 0}
-  m_RootOrder: 10
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &952102529
 GameObject:

Assets/ScriptableRenderPipeline/BasicRenderPipeline/BasicRenderPipeline.cs

             ScriptableCullingParameters cullingParams;
             if (!CullResults.GetCullingParameters(camera, out cullingParams))
                 continue;
-            CullResults cull = CullResults.Cull(ref cullingParams, context);
+            CullResults cull = new CullResults();
+            CullResults.Cull(ref cullingParams, context, ref cull);
 
             // Setup camera for rendering (sets render target, view/projection matrices and other
             // per-camera built-in shader variables).
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
-            cmd.Release();
+            CommandBufferPool.Release(cmd);
 
             // Setup global lighting shader variables
             SetupLightShaderVariables(cull.visibleLights, context);
 
     // Setup lighting variables for shader to use
 
-    private static void SetupLightShaderVariables(VisibleLight[] lights, ScriptableRenderContext context)
+    private static void SetupLightShaderVariables(List<VisibleLight> lights, ScriptableRenderContext context)
     {
         // We only support up to 8 visible lights here. More complex approaches would
         // be doing some sort of per-object light setups, but here we go for simplest possible
         // to the viewer, so that "most important" lights in the scene are picked, and not the 8
         // that happened to be first.
-        int lightCount = Mathf.Min(lights.Length, kMaxLights);
+        int lightCount = Mathf.Min(lights.Count, kMaxLights);
 
         // Prepare light data
         Vector4[] lightColors = new Vector4[kMaxLights];
         GetShaderConstantsFromNormalizedSH(ref ambientSH, shConstants);
 
         // setup global shader variables to contain all the data computed above
-        CommandBuffer cmd = new CommandBuffer();
+        CommandBuffer cmd = CommandBufferPool.Get();
         cmd.SetGlobalVectorArray("globalLightColor", lightColors);
         cmd.SetGlobalVectorArray("globalLightPos", lightPositions);
         cmd.SetGlobalVectorArray("globalLightSpotDir", lightSpotDirections);
         context.ExecuteCommandBuffer(cmd);
-        cmd.Dispose();
+        CommandBufferPool.Release(cmd);
     }
 
     // Prepare L2 spherical harmonics values for efficient evaluation in a shader

Assets/ScriptableRenderPipeline/BasicRenderPipeline/BasicRenderPipelineShader.shader

 
     SubShader
     {
-        Tags { "RenderType" = "Opaque" "PerformanceChecks" = "False" }
-        LOD 300
-
         // Include forward (base + additive) pass from regular Standard shader.
         // They are not used by the scriptable render loop; only here so that
         // if we turn off our example loop, then regular forward rendering kicks in

Assets/ScriptableRenderPipeline/Core/Shadow/Resources/DebugDisplayShadowMap.shader

         {
             Varyings output;
             output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-            output.texcoord   = GetFullScreenTriangleTexcoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
+            output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID) * _TextureScaleBias.xy + _TextureScaleBias.zw;
 
             return output;
         }

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

 using UnityEngine.Rendering;
 using System;
-
+using System.Collections.Generic;
 
 namespace UnityEngine.Experimental.Rendering
 {
             Object.DestroyImmediate(m_DebugMaterial);
         }
 
-        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, VisibleLight[] lights )
+        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
         {
             for( uint i = 0, cnt = sr.facecount; i < cnt; ++i )
             {
             return Reserve( frameId, ref shadowData, sr, m_TmpWidths, m_TmpHeights, ref entries, ref payload, lights );
         }
 
-        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, VisibleLight[] lights )
+        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
         {
             if( m_FrameId.frameCount != frameId.frameCount )
                 m_ActiveEntriesCount = 0;
             float[] cascadeRatios = null;
             if( sr.shadowType == GPUShadowType.Directional )
             {
-                AdditionalLightData ald = lights[sr.index].light.GetComponent<AdditionalLightData>();
-                if( !ald )
+                AdditionalShadowData asd = lights[sr.index].light.GetComponent<AdditionalShadowData>();
+                if( !asd )
-                ald.GetShadowCascades( out cascadeCnt, out cascadeRatios );
+                asd.GetShadowCascades( out cascadeCnt, out cascadeRatios );
             }
 
 
                 bit <<= 1;
             }
 
-            WritePerLightPayload( ref lights[sr.index], sr, ref sd, ref payload, ref originalPayloadCount );
+            WritePerLightPayload(lights, sr, ref sd, ref payload, ref originalPayloadCount );
 
             return true;
         }
         }
 
         // Writes additional per light data into the payload vector. Make sure to call base.WritePerLightPayload first.
-        virtual protected void WritePerLightPayload( ref VisibleLight light, ShadowRequest sr, ref ShadowData sd, ref ShadowPayloadVector payload, ref uint payloadOffset )
+        virtual protected void WritePerLightPayload(List<VisibleLight> lights, ShadowRequest sr, ref ShadowData sd, ref ShadowPayloadVector payload, ref uint payloadOffset )
         {
             ShadowPayload sp = new ShadowPayload();
             if( sr.shadowType == GPUShadowType.Directional )
             ShadowUtils.Unpack( sr.shadowAlgorithm, out algo, out vari, out prec );
             if( algo == ShadowAlgorithm.PCF )
             {
-                AdditionalLightData ald = light.light.GetComponent<AdditionalLightData>();
-                if( !ald )
+                AdditionalShadowData asd = lights[sr.index].light.GetComponent<AdditionalShadowData>();
+                if( !asd )
-                int[] shadowData = ald.GetShadowData( out shadowDataFormat );
+                int[] shadowData = asd.GetShadowData( out shadowDataFormat );
-                    ald.SetShadowAlgorithm( (int)algo, (int)vari, (int) prec, shadowDataFormat, shadowData );
+                    asd.SetShadowAlgorithm( (int)algo, (int)vari, (int) prec, shadowDataFormat, shadowData );
                     Debug.Log( "Fixed up shadow data for algorithm " + algo + ", variant " + vari );
                 }
 
             cb.ClearRenderTarget( true, !IsNativeDepth(), m_ClearColor );
         }
 
-        override public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights )
+        override public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights)
-            var profilingSample = new HDPipeline.Utilities.ProfilingSample("Shadowmap" + m_TexSlot, renderContext);
+            var profilingSample = new HDPipeline.Utilities.ProfilingSample(string.Format("Shadowmap{0}",m_TexSlot), renderContext);
-                var cb = new CommandBuffer();
+                var cb = CommandBufferPool.Get();
-                cb.Dispose();
+                CommandBufferPool.Release(cb);
             }
 
             // loop for generating each individual shadowmap
                 if( !cullResults.GetShadowCasterBounds( m_EntryCache[i].key.visibleIdx, out bounds ) )
                     continue;
 
-                var cb = new CommandBuffer();
+                var cb = CommandBufferPool.Get();
-                    cb.name = "Shadowmap.Update.Slice" + entrySlice;
+                    cb.name = string.Format("Shadowmap.Update.Slice{0}", entrySlice);
 
                     if( curSlice != uint.MaxValue )
                     {
                     PreUpdate( frameId, cb, curSlice );
                 }
 
-                cb.name = "Shadowmap.Update - slice: " + curSlice + ", vp.x: " + m_EntryCache[i].current.viewport.x + ", vp.y: " + m_EntryCache[i].current.viewport.y + ", vp.w: " + m_EntryCache[i].current.viewport.width + ", vp.h: " + m_EntryCache[i].current.viewport.height;
+                cb.name = string.Format("Shadowmap.Update - slice: {0}, vp.x: {1}, vp.y: {2}, vp.w: {3}, vp.h: {4}", curSlice, m_EntryCache[i].current.viewport.x, m_EntryCache[i].current.viewport.y, m_EntryCache[i].current.viewport.width, m_EntryCache[i].current.viewport.height);
-                cb.Dispose();
+                CommandBufferPool.Release(cb);
 
                 dss.lightIndex = m_EntryCache[i].key.visibleIdx;
                 dss.splitData = m_EntryCache[i].current.splitData;
             // post update
-            var cblast = new CommandBuffer();
+            var cblast = CommandBufferPool.Get();
             PostUpdate( frameId, cblast, curSlice, lights );
             if( !string.IsNullOrEmpty( m_ShaderKeyword ) )
             {
             renderContext.ExecuteCommandBuffer( cblast );
-            cblast.Dispose();
+            CommandBufferPool.Release(cblast);
 
             m_ActiveEntriesCount = 0;
 
-        virtual protected void PostUpdate( FrameId frameId, CommandBuffer cb, uint rendertargetSlice, VisibleLight[] lights )
+        virtual protected void PostUpdate( FrameId frameId, CommandBuffer cb, uint rendertargetSlice, List<VisibleLight> lights)
         {
             if( !IsNativeDepth() )
                 cb.ReleaseTemporaryRT( m_TempDepthId );
 
         override public void DisplayShadowMap(ScriptableRenderContext renderContext, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
         {
-            CommandBuffer debugCB = new CommandBuffer();
+            CommandBuffer debugCB = CommandBufferPool.Get();
             debugCB.name = "";
 
             Vector4 validRange = new Vector4(minValue, 1.0f / (maxValue - minValue));
             debugCB.DrawProcedural(Matrix4x4.identity, m_DebugMaterial, m_DebugMaterial.FindPass("REGULARSHADOW"), MeshTopology.Triangles, 3, 1, propertyBlock);
 
             renderContext.ExecuteCommandBuffer(debugCB);
-            debugCB.Dispose();
+
+            CommandBufferPool.Release(debugCB);
         }
     }
 
         }
 
         // Writes additional per light data into the payload vector. Make sure to call base.WritePerLightPayload first.
-        override protected void WritePerLightPayload( ref VisibleLight light, ShadowRequest sr, ref ShadowData sd, ref ShadowPayloadVector payload, ref uint payloadOffset )
+        override protected void WritePerLightPayload(List<VisibleLight> lights, ShadowRequest sr, ref ShadowData sd, ref ShadowPayloadVector payload, ref uint payloadOffset )
-            base.WritePerLightPayload( ref light, sr, ref sd, ref payload, ref payloadOffset );
+            base.WritePerLightPayload(lights, sr, ref sd, ref payload, ref payloadOffset );
-            AdditionalLightData ald = light.light.GetComponent<AdditionalLightData>();
-            if( !ald )
+            AdditionalShadowData asd = lights[sr.index].light.GetComponent<AdditionalShadowData>();
+            if( !asd )
-            int[] shadowData = ald.GetShadowData( out shadowDataFormat );
+            int[] shadowData = asd.GetShadowData( out shadowDataFormat );
             if( shadowData == null )
                 return;
 
             cb.ClearRenderTarget( true, true, m_ClearColor );
         }
 
-        protected override void PostUpdate( FrameId frameId, CommandBuffer cb, uint rendertargetSlice, VisibleLight[] lights )
+        protected override void PostUpdate( FrameId frameId, CommandBuffer cb, uint rendertargetSlice, List<VisibleLight> lights)
         {
             cb.name = "VSM conversion";
             if ( rendertargetSlice == uint.MaxValue )
 
             while( i < cnt && m_EntryCache[i].current.slice == rendertargetSlice )
             {
-                AdditionalLightData ald = lights[m_EntryCache[i].key.visibleIdx].light.GetComponent<AdditionalLightData>();
+                AdditionalShadowData asd = lights[m_EntryCache[i].key.visibleIdx].light.GetComponent<AdditionalShadowData>();
-                int[] shadowData = ald.GetShadowData( out shadowDataFormat );
+                int[] shadowData = asd.GetShadowData( out shadowDataFormat );
 
                 ShadowAlgorithm algo;
                 ShadowVariant vari;
 
         override public void DisplayShadowMap(ScriptableRenderContext renderContext, Vector4 scaleBias, uint slice, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue)
         {
-            CommandBuffer debugCB = new CommandBuffer();
+            CommandBuffer debugCB = CommandBufferPool.Get();
             debugCB.name = "";
 
             Vector4 validRange = new Vector4(minValue, 1.0f / (maxValue - minValue));
             debugCB.DrawProcedural(Matrix4x4.identity, m_DebugMaterial, m_DebugMaterial.FindPass("VARIANCESHADOW"), MeshTopology.Triangles, 3, 1, propertyBlock);
 
             renderContext.ExecuteCommandBuffer(debugCB);
-            debugCB.Dispose();
+            CommandBufferPool.Release(debugCB);
         }
     }
 // -------------------------------------------------------------------------------------------------------------------------------------------------
 
 #if UNITY_EDITOR
             // and register itself
-            AdditionalLightDataEditor.SetRegistry( this );
+            AdditionalShadowDataEditor.SetRegistry( this );
 #endif
         }
 
         }
 
-        public override void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, VisibleLight[] lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices )
+        public override void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices )
         {
             shadowDataIndices = null;
 
             }
         }
 
-        protected override void PrioritizeShadowCasters( Camera camera, VisibleLight[] lights, uint shadowRequestsCount, int[] shadowRequests )
+        protected override void PrioritizeShadowCasters( Camera camera, List<VisibleLight> lights, uint shadowRequestsCount, int[] shadowRequests )
         {
             // this function simply looks at the projected area on the screen, ignoring all light types and shapes
             m_TmpSortKeys.Reset( shadowRequestsCount );
             m_TmpSortKeys.ExtractTo( shadowRequests, 0, out shadowRequestsCount, delegate(long key) { return (int) (key & 0xffffffff); } );
         }
 
-        protected override void PruneShadowCasters( Camera camera, VisibleLight[] lights, ref VectorArray<int> shadowRequests, ref ShadowRequestVector requestsGranted, out uint totalRequestCount )
+        protected override void PruneShadowCasters( Camera camera, List<VisibleLight> lights, ref VectorArray<int> shadowRequests, ref ShadowRequestVector requestsGranted, out uint totalRequestCount )
         {
             Debug.Assert( shadowRequests.Count() > 0 );
             // at this point the array is sorted in order of some importance determined by the prioritize function
                 int facecount         = 0;
                 GPUShadowType shadowType = GPUShadowType.Point;
 
-                AdditionalLightData ald = vl.light.GetComponent<AdditionalLightData>();
+                AdditionalShadowData asd = vl.light.GetComponent<AdditionalShadowData>();
-                bool    add             = (distToCam < ald.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;
+                bool    add             = (distToCam < asd.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;
 
                 if( add )
                 {
                             add = --m_MaxShadows[(int)GPUShadowType.Directional, 0] >= 0;
                             shadowType = GPUShadowType.Directional;
-                            facecount = ald.cascadeCount;
+                            facecount = asd.cascadeCount;
                             break;
                         case LightType.Point:
                             add = --m_MaxShadows[(int)GPUShadowType.Point, 0] >= 0;
                 if( add )
                 {
                     sreq.instanceId = vl.light.GetInstanceID();
-                    sreq.index      = (uint) requestIdx;
+                    sreq.index      = requestIdx;
-                    ald.GetShadowAlgorithm( out sa, out sv, out sp );
+                    asd.GetShadowAlgorithm( out sa, out sv, out sp );
                     sreq.shadowAlgorithm = ShadowUtils.Pack( (ShadowAlgorithm) sa, (ShadowVariant) sv, (ShadowPrecision) sp );
                     totalRequestCount += (uint) facecount;
                     requestsGranted.AddUnchecked( sreq );
             m_TmpSortKeys.ExtractTo( ref shadowRequests, (long idx) => { return (int) idx; } );
         }
 
-        protected override void AllocateShadows( FrameId frameId, VisibleLight[] lights, uint totalGranted, ref ShadowRequestVector grantedRequests, ref ShadowIndicesVector shadowIndices, ref ShadowDataVector shadowDatas, ref ShadowPayloadVector shadowmapPayload )
+        protected override void AllocateShadows( FrameId frameId, List<VisibleLight> lights, uint totalGranted, ref ShadowRequestVector grantedRequests, ref ShadowIndicesVector shadowIndices, ref ShadowDataVector shadowDatas, ref ShadowPayloadVector shadowmapPayload )
         {
             ShadowData sd = new ShadowData();
             shadowDatas.Reserve( totalGranted );
-                VisibleLight        vl  = lights[grantedRequests[i].index];
-                Light               l   = vl.light;
-                AdditionalLightData ald = l.GetComponent<AdditionalLightData>();
+                Light l = lights[grantedRequests[i].index].light;
+                AdditionalShadowData asd = l.GetComponent<AdditionalShadowData>();
-                GPUShadowType shadowtype;
-                ShadowUtils.MapLightType( ald.archetype, vl.lightType, out shadowtype );
+                GPUShadowType shadowtype = GetShadowLightType(l);
                 // current bias value range is way too large, so scale by 0.01 for now until we've decided  whether to actually keep this value or not.
                 sd.bias = 0.01f * (SystemInfo.usesReversedZBuffer ? l.shadowBias : -l.shadowBias);
                 sd.normalBias = 100.0f * l.shadowNormalBias;
                 int smidx = 0;
                 while( smidx < k_MaxShadowmapPerType )
                 {
-                    if( m_ShadowmapsPerType[(int)shadowtype,smidx] != null && m_ShadowmapsPerType[(int)shadowtype,smidx].Reserve( frameId, ref sd, grantedRequests[i], (uint) ald.shadowResolution, (uint) ald.shadowResolution, ref shadowDatas, ref shadowmapPayload, lights ) )
+                    if( m_ShadowmapsPerType[(int)shadowtype,smidx] != null && m_ShadowmapsPerType[(int)shadowtype,smidx].Reserve( frameId, ref sd, grantedRequests[i], (uint) asd.shadowResolution, (uint) asd.shadowResolution, ref shadowDatas, ref shadowmapPayload, lights ) )
                         break;
                     smidx++;
                 }
             }
         }
 
-        public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights )
+        public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights)
         {
             using (new HDPipeline.Utilities.ProfilingSample("Render Shadows Exp", renderContext))
             {
             m_ShadowCtxt.SyncData();
         }
 
-        public override void BindResources( ScriptableRenderContext renderContext )
+        public override void BindResources(ScriptableRenderContext renderContext)
-            foreach( var sm in m_Shadowmaps )
+            foreach (var sm in m_Shadowmaps)
-                sm.Fill( m_ShadowCtxt );
+                sm.Fill(m_ShadowCtxt);
-            CommandBuffer cb = new CommandBuffer(); // <- can we just keep this around or does this have to be newed every frame?
+            CommandBuffer cb = CommandBufferPool.Get(); // <- can we just keep this around or does this have to be newed every frame?
-            m_ShadowCtxt.BindResources( cb );
-            renderContext.ExecuteCommandBuffer( cb );
-            cb.Dispose();
+            m_ShadowCtxt.BindResources(cb);
+            renderContext.ExecuteCommandBuffer(cb);
+            CommandBufferPool.Release(cb);
         }
 
         // resets the shadow slot counters and returns the sum of all slots

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

 
         public delegate void VariantDelegate( Light l, ShadowAlgorithm dataAlgorithm, ShadowVariant dataVariant, ShadowPrecision dataPrecision, ref int[] dataContainer );
 
+        public delegate GPUShadowType ShadowLightTypeDelegate(Light l);
+
+        // default implementation based on legacy Unity
+        static public GPUShadowType ShadowLightType(Light l)
+        {
+            GPUShadowType shadowType = GPUShadowType.Unknown;
+
+            switch (l.type)
+            {
+                case LightType.Spot:
+                    shadowType = GPUShadowType.Spot;
+                    break;
+                case LightType.Directional:
+                    shadowType = GPUShadowType.Directional;
+                    break;
+                case LightType.Point:
+                    shadowType = GPUShadowType.Point;
+                    break;
+                // area lights by themselves can't be mapped to any GPU type
+            }
+
+            return shadowType;
+        }
+
         struct Dels
         {
             public VariantDelegate low;
         }
 
         Override[] m_GlobalOverrides = new Override[(int)GPUShadowType.MAX];
+        ShadowLightTypeDelegate m_shadowLightType;
 
         Dictionary<ShadowAlgorithm, Entry>[] m_Entries = new Dictionary<ShadowAlgorithm, Entry>[ShadowConstants.Counts.k_GPUShadowType]
                                                         {   new Dictionary<ShadowAlgorithm, Entry>(),
+        // Init default delegate
+        public ShadowRegistry() { m_shadowLightType = ShadowLightType;  }
+
+        }
+
+        public GPUShadowType GetShadowLightType(Light l)
+        {
+            return m_shadowLightType(l);
+        }
+
+        public void SetShadowLightTypeDelegate(ShadowLightTypeDelegate del)
+        {
+            m_shadowLightType = del;
         }
 
         public void Register( GPUShadowType type, ShadowPrecision precision, ShadowAlgorithm algorithm, string algorithmDescriptor, ShadowVariant[] variants, string[] variantDescriptors, VariantDelegate[] variantDelegates )
 
         public void Draw( Light l )
         {
-            AdditionalLightData ald = l.GetComponent<AdditionalLightData>();
-            Debug.Assert(ald != null, "Light has no valid AdditionalLightData component attached.");
+            AdditionalShadowData asd = l.GetComponent<AdditionalShadowData>();
+            Debug.Assert(asd != null, "Light has no valid AdditionalShadowData component attached.");
-            GPUShadowType shadowType;
-            ShadowUtils.MapLightType( ald.archetype, l.type, out shadowType );
+            GPUShadowType shadowType = GetShadowLightType(l);
 
             // check if this has supported shadows
             if( (int) shadowType >= ShadowConstants.Counts.k_GPUShadowType )
                 shadowPrecision = (int) m_GlobalOverrides[(int)shadowType].precision;
             }
             else
-                ald.GetShadowAlgorithm( out shadowAlgorithm, out shadowVariant, out shadowPrecision );
+                asd.GetShadowAlgorithm( out shadowAlgorithm, out shadowVariant, out shadowPrecision );
 
             DrawWidgets( l, shadowType, (ShadowAlgorithm) shadowAlgorithm, (ShadowVariant) shadowVariant, (ShadowPrecision) shadowPrecision, globalOverride );
         }
                 }
             }
 
-            AdditionalLightData ald = l.GetComponent<AdditionalLightData>();
+            AdditionalShadowData asd = l.GetComponent<AdditionalShadowData>();
-                shadowData = ald.GetShadowData( (int) packedAlgo );
+                shadowData = asd.GetShadowData( (int) packedAlgo );
 
             UnityEditor.EditorGUILayout.EndHorizontal();
 
                 e.variantDels[(int) shadowVariant].high( l, shadowAlgorithm, shadowVariant, shadowPrecision, ref shadowData );
-            ald.SetShadowAlgorithm( (int) shadowAlgorithm, (int) shadowVariant, (int) shadowPrecision, (int) packedAlgo, shadowData );
+            asd.SetShadowAlgorithm( (int) shadowAlgorithm, (int) shadowVariant, (int) shadowPrecision, (int) packedAlgo, shadowData );
 
             UnityEditor.EditorGUI.indentLevel--;
 #endif
                 set { m_ShadowTypeAndAlgorithm = (m_ShadowTypeAndAlgorithm & ~(ShadowConstants.Masks.k_GPUShadowAlgorithm)) | (int)value; }
             }
             // index into the visible lights array
-            public uint index
+            public int index // use "int" and not "uint" as it is use to index inside List<>
-                get { return m_MaskIndex & k_MaxIndex; }
-                set { m_MaskIndex = value & k_MaxIndex; }
+                get { return (int)(m_MaskIndex & k_MaxIndex); }
+                set { m_MaskIndex = (uint)value & k_MaxIndex; }
             }
             // mask of which faces are requested:
             // - for spotlights the value is always 1
                  public ShadowSupport QueryShadowSupport() { return m_ShadowSupport; }
                  public uint GetMaxPayload() { return m_MaxPayloadCount; }
                  public void Assign( CullResults cullResults ) { m_CullResults = cullResults; } // TODO: Remove when m_CullResults is removed again
-        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, VisibleLight[] lights );
-        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, VisibleLight[] lights );
+        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
+        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
-        abstract public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights );
+        abstract public void Update( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
         abstract public void ReserveSlots( ShadowContextStorage sc );
         abstract public void Fill( ShadowContextStorage cs );
         abstract public void CreateShadowmap();
         //          shadowPayloads contains implementation specific data that is accessed from the shader by indexing into an Buffer<int> using ShadowData.ShadowmapData.payloadOffset.
         //          This is the equivalent of a void pointer in the shader and there needs to be loader code that knows how to interpret the data.
         //          If there are no valid shadow casters all output arrays will be null, otherwise they will contain valid data that can be passed to shaders.
-        void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, VisibleLight[] lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
+        void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
-        void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights );
+        void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
         // Debug function to display a shadow at the screen coordinate
         void DisplayShadow(ScriptableRenderContext renderContext, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
         void DisplayShadowMap(ScriptableRenderContext renderContext, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
 
     abstract public class ShadowManagerBase : ShadowRegistry, IShadowManager
     {
-        public  abstract void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, VisibleLight[] lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
-        public  abstract void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, VisibleLight[] lights );
+        public  abstract void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
+        public  abstract void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CullResults cullResults, List<VisibleLight> lights);
         public  abstract void DisplayShadow(ScriptableRenderContext renderContext, int shadowIndex, uint faceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
         public  abstract void DisplayShadowMap(ScriptableRenderContext renderContext, uint shadowMapIndex, uint sliceIndex, float screenX, float screenY, float screenSizeX, float screenSizeY, float minValue, float maxValue);
         public  abstract void SyncData();
-        protected abstract void PrioritizeShadowCasters( Camera camera, VisibleLight[] lights, uint shadowRequestsCount, int[] shadowRequests );
+        protected abstract void PrioritizeShadowCasters( Camera camera, List<VisibleLight> lights, uint shadowRequestsCount, int[] shadowRequests );
-        protected abstract void PruneShadowCasters( Camera camera, VisibleLight[] lights, ref VectorArray<int> shadowRequests, ref VectorArray<ShadowmapBase.ShadowRequest> requestsGranted, out uint totalRequestCount );
+        protected abstract void PruneShadowCasters( Camera camera, List<VisibleLight> lights, ref VectorArray<int> shadowRequests, ref VectorArray<ShadowmapBase.ShadowRequest> requestsGranted, out uint totalRequestCount );
-        protected abstract void AllocateShadows( FrameId frameId, VisibleLight[] lights, uint totalGranted, ref VectorArray<ShadowmapBase.ShadowRequest> grantedRequests, ref VectorArray<int> shadowIndices, ref VectorArray<ShadowData> shadowmapDatas, ref VectorArray<ShadowPayload> shadowmapPayload );
+        protected abstract void AllocateShadows( FrameId frameId, List<VisibleLight> lights, uint totalGranted, ref VectorArray<ShadowmapBase.ShadowRequest> grantedRequests, ref VectorArray<int> shadowIndices, ref VectorArray<ShadowData> shadowmapDatas, ref VectorArray<ShadowPayload> shadowmapPayload );
 
         public abstract uint GetShadowMapCount();
         public abstract uint GetShadowMapSliceCount(uint shadowMapIndex);

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderPipeline/core/Shadow/ShadowBase.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADOWBASE_CS_HLSL

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowUtilities.cs

         // Cubemap faces with flipped z coordinate.
         // These matrices do NOT match what we have in Skybox.cpp.
         // The C++ runtime flips y as well and requires patching up
-        // the culling state. Using these matrices keeps the winding 
+        // the culling state. Using these matrices keeps the winding
         // order, but may need some special treatment if rendering
         // into an actual cubemap.
         public static readonly Matrix4x4[] kCubemapFaces = new Matrix4x4[]
             cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives( lightIndex, (int) cascadeIdx, cascadeCount, ratios, (int) width, nearPlaneOffset, out view, out proj, out splitData );
             // and the compound
             return proj * view;
-        }
-
-        public static bool MapLightType( LightType lt,  out HDPipeline.GPULightType gputype, out GPUShadowType shadowtype )
-        {
-            switch( lt )
-            {
-            case LightType.Spot         : gputype = HDPipeline.GPULightType.Spot;          shadowtype = GPUShadowType.Spot;        return true;
-            case LightType.Directional  : gputype = HDPipeline.GPULightType.Directional;   shadowtype = GPUShadowType.Directional; return true;
-            case LightType.Point        : gputype = HDPipeline.GPULightType.Point;         shadowtype = GPUShadowType.Point;       return true;
-            default:
-            case LightType.Area         : gputype = HDPipeline.GPULightType.Rectangle; shadowtype = GPUShadowType.Unknown; return false;   // area lights by themselves can't be mapped to any GPU type
-            }
-        }
-        public static bool MapLightType(LightArchetype la, LightType lt, out GPUShadowType shadowtype)
-        {
-            switch (la)
-            {
-                case LightArchetype.Punctual:
-                    return MapLightType(lt, out shadowtype);
-                case LightArchetype.Area:
-                    shadowtype = GPUShadowType.Unknown;
-                    return true;
-                case LightArchetype.Projector:
-                    shadowtype = GPUShadowType.Unknown;
-                    return true;
-                default:
-                    shadowtype = GPUShadowType.Unknown;
-                    return false; // <- probably not what you want
-            }
-
-        }
-        public static bool MapLightType(LightType lt, out GPUShadowType shadowtype)
-        {
-            switch (lt)
-            {
-                case LightType.Spot:
-                    shadowtype = GPUShadowType.Spot;
-                    return true;
-                case LightType.Directional:
-                    shadowtype = GPUShadowType.Directional;
-                    return true;
-                case LightType.Point:
-                    shadowtype = GPUShadowType.Point;
-                    return true;
-                default:
-                case LightType.Area:
-                    shadowtype = GPUShadowType.Unknown;
-                    return false;   // area lights by themselves can't be mapped to any GPU type
-            }
         }
 
         public static GPUShadowAlgorithm Pack( ShadowAlgorithm algo, ShadowVariant vari, ShadowPrecision prec )

Assets/ScriptableRenderPipeline/Core/TextureCache.cs

             return sliceIndex;
         }
 
+        private static List<int> s_TempIntList = new List<int>();
-            var tmpBuffer = new int[m_NumTextures];
+            s_TempIntList.Clear();
-                tmpBuffer[i] = m_SortedIdxArray[i];     // copy buffer
+                s_TempIntList.Add(m_SortedIdxArray[i]);     // copy buffer
-                if (m_SliceArray[tmpBuffer[i]].countLRU == 0)
+                if (m_SliceArray[s_TempIntList[i]].countLRU == 0)
-                    m_SortedIdxArray[zerosBase + numNonZeros] = tmpBuffer[i];
+                    m_SortedIdxArray[zerosBase + numNonZeros] = s_TempIntList[i];
-                    m_SortedIdxArray[nonZerosBase] = tmpBuffer[i];
+                    m_SortedIdxArray[nonZerosBase] = s_TempIntList[i];
                     ++nonZerosBase;
                 }
             }

Assets/ScriptableRenderPipeline/Fptl/FptlLighting.cs

         static void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext loop)
         {
             // setup GBuffer for rendering
-            var cmd = new CommandBuffer { name = "Create G-Buffer" };
+            var cmd = CommandBufferPool.Get ("Create G-Buffer");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
 
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("Deferred"))
 
         void RenderForward(CullResults cull, Camera camera, ScriptableRenderContext loop, bool opaquesOnly)
         {
-            var cmd = new CommandBuffer { name = opaquesOnly ? "Prep Opaques Only Forward Pass" : "Prep Forward Pass" };
+            var cmd = CommandBufferPool.Get(opaquesOnly ? "Prep Opaques Only Forward Pass" : "Prep Forward Pass" );
 
             bool useFptl = opaquesOnly && usingFptl;     // requires depth pre-pass for forward opaques!
 
             cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
 
             loop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
+
 
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("ForwardSinglePass"))
 
         static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, ScriptableRenderContext loop)
         {
-            var cmd = new CommandBuffer { name = "Forward Opaques - Depth Only" };
+            var cmd = CommandBufferPool.Get("Forward Opaques - Depth Only" );
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
 
             // render opaque objects using Deferred pass
             var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("DepthOnly"))
 
         static void CopyDepthAfterGBuffer(ScriptableRenderContext loop)
         {
-            var cmd = new CommandBuffer { name = "Copy depth" };
+            var cmd = CommandBufferPool.Get("Copy depth");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
+
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
 
             m_DeferredMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
             m_DeferredReflectionMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
             cmd.SetRenderTarget(new RenderTargetIdentifier(s_CameraTarget), new RenderTargetIdentifier(s_CameraDepthTexture));
 
             loop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         private static void SetMatrixCS(CommandBuffer cmd, ComputeShader shadercs, string name, Matrix4x4 mat)
                     dirLightCount++;
                 }
             }
-            s_DirLightList.SetData(lights.ToArray());
+            s_DirLightList.SetData(lights);
 
             return dirLightCount;
         }
                 m_FrameId.frameCount++;
                 // get the indices for all lights that want to have shadows
                 m_ShadowRequests.Clear();
-                m_ShadowRequests.Capacity = inputs.visibleLights.Length;
-                int lcnt = inputs.visibleLights.Length;
+                m_ShadowRequests.Capacity = inputs.visibleLights.Count;
+                int lcnt = inputs.visibleLights.Count;
-                    if (vl.light.shadows != LightShadows.None && vl.light.GetComponent<AdditionalLightData>().shadowDimmer > 0.0f)
+                    if (vl.light.shadows != LightShadows.None && vl.light.GetComponent<AdditionalShadowData>().shadowDimmer > 0.0f)
                         m_ShadowRequests.Add(i);
                 }
                 // pass this list to a routine that assigns shadows based on some heuristic
             }
 
 
-            var numLights = inputs.visibleLights.Length;
-            var numProbes = probes.Length;
+            var numLights = inputs.visibleLights.Count;
+            var numProbes = probes.Count;
             var numVolumes = numLights + numProbes;
 
 
             return numLightsOut + numProbesOut;
         }
 
+        CullResults m_CullResults;
         public void Render(ScriptableRenderContext renderContext, IEnumerable<Camera> cameras)
         {
             foreach (var camera in cameras)
 
                 m_ShadowMgr.UpdateCullingParameters( ref cullingParams );
 
-                var cullResults = CullResults.Cull(ref cullingParams, renderContext);
-                ExecuteRenderLoop(camera, cullResults, renderContext);
+                CullResults.Cull(ref cullingParams, renderContext, ref m_CullResults);
+                ExecuteRenderLoop(camera, m_CullResults, renderContext);
             }
 
             renderContext.Submit();
         {
-            var cmd = new CommandBuffer { name = "FinalPass" };
+            var cmd = CommandBufferPool.Get("FinalPass");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
+
         }
 
         void ExecuteRenderLoop(Camera camera, CullResults cullResults, ScriptableRenderContext loop)
             if (enableClustered) RenderForward(cullResults, camera, loop, false);
 
             // debug views.
-            if (enableDrawLightBoundsDebug) DrawLightBoundsDebug(loop, cullResults.visibleLights.Length);
+            if (enableDrawLightBoundsDebug) DrawLightBoundsDebug(loop, cullResults.visibleLights.Count);
 
             // present frame buffer.
             FinalPass(loop);
             {
-                var cmd = new CommandBuffer();
+                var cmd = CommandBufferPool.Get();
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
+
             }
             loop.Submit();
         }
-            var cmd = new CommandBuffer { name = "DrawLightBoundsDebug" };
+            var cmd = CommandBufferPool.Get("DrawLightBoundsDebug");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
+
         }
 
         void NewFrame()
             var numBigTilesX = (w + 63) / 64;
             var numBigTilesY = (h + 63) / 64;
 
-            var cmd = new CommandBuffer() { name = "Build light list" };
+            var cmd = CommandBufferPool.Get("Build light list" );
 
             // generate screen-space AABBs (used for both fptl and clustered).
             if (numLights != 0)
             }
 
             loop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
-            var cmd = new CommandBuffer { name = "Push Global Parameters" };
+            var cmd = CommandBufferPool.Get("Push Global Parameters");
 
             cmd.SetGlobalFloat("g_widthRT", (float)camera.pixelWidth);
             cmd.SetGlobalFloat("g_heightRT", (float)camera.pixelHeight);
             cmd.SetGlobalVector("g_vShadow3x3PCFTerms3", m_Shadow3X3PCFTerms[3]);
 
             loop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+
         }
 
         private float PerceptualRoughnessToBlinnPhongPower(float perceptualRoughness)

Assets/ScriptableRenderPipeline/Fptl/LightDefinitions.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/Fptl/LightDefinitions.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderPipeline/fptl/LightDefinitions.cs.  Please don't edit by hand.
 //
 
 #ifndef LIGHTDEFINITIONS_CS_HLSL

Assets/ScriptableRenderPipeline/Fptl/SkyboxHelper.cs

                 return;
             }
 
-            var cmd = new CommandBuffer { name = "Skybox" };
+            var cmd = CommandBufferPool.Get("Skybox");
 
             var looksLikeSixSidedShader = true;
             looksLikeSixSidedShader &= (mat.passCount == 6); // should have six passes
             }
 
             loop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         public static Matrix4x4 GetProjectionMatrix(Camera camera)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayLatlong.shader

             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord = GetFullScreenTriangleTexcoord(input.vertexID);// *_TextureScaleBias.xy + _TextureScaleBias.zw;
+                output.texcoord = GetFullScreenTriangleTexCoord(input.vertexID);// *_TextureScaleBias.xy + _TextureScaleBias.zw;
 
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugFullScreen.shader

             {
                 Varyings output;
                 output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
-                output.texcoord   = GetFullScreenTriangleTexcoord(input.vertexID);
+                output.texcoord   = GetFullScreenTriangleTexCoord(input.vertexID);
 
                 return output;
             }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 {
     public class HDRenderPipelineMenuItems
     {
-        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light Data\" (if not present)")]
+        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
         static void AddAdditionalLightData()
         {
             Light[] lights = GameObject.FindObjectsOfType(typeof(Light)) as Light[];
                 // Do not add a component if there already is one.
-                if (light.GetComponent<AdditionalLightData>() == null)
+                if (light.GetComponent<HDAdditionalLightData>() == null)
-                    light.gameObject.AddComponent<AdditionalLightData>();
+                    light.gameObject.AddComponent<HDAdditionalLightData>();
+                }
+
+                if (light.GetComponent<AdditionalShadowData>() == null)
+                {
+                    light.gameObject.AddComponent<AdditionalShadowData>();
-        // This script is a helper for the artists to re-synchronise all layered materials
+        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Camera Data\" (if not present)")]
+        static void AddAdditionalCameraData()
+        {
+            Camera[] cameras = GameObject.FindObjectsOfType(typeof(Camera)) as Camera[];
+
+            foreach (Camera camera in cameras)
+            {
+                // Do not add a component if there already is one.
+                if (camera.GetComponent<HDAdditionalCameraData>() == null)
+                {
+                    camera.gameObject.AddComponent<HDAdditionalCameraData>();
+                }
+            }
+        }
+
+        // This script is a helper for the artists to re-synchronize all layered materials
         [MenuItem("HDRenderPipeline/Synchronize all Layered materials")]
         static void SynchronizeAllLayeredMaterial()
         {
             }
         }
 
-        // Funtion used only to check performance of data with and without tessellation
+        // Function used only to check performance of data with and without tessellation
         [MenuItem("HDRenderPipeline/Test/Remove tessellation materials (not reversible)")]
         static void RemoveTessellationMaterials()
         {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 using System;
 using System.Linq;
     // not used during a frame.
     public class HDCamera
     {
-        public readonly Camera camera;
+        public Matrix4x4 viewMatrix;
+        public Matrix4x4 projMatrix;
+        public Vector4   screenSize;
+        public Camera    camera;
-        public Vector4   screenSize { get; private set; }
-        public Matrix4x4 viewProjectionMatrix { get; private set; }
-        public Matrix4x4 prevViewProjectionMatrix { get; private set; }
-        public Matrix4x4 invViewProjectionMatrix { get; private set; }
-        public Matrix4x4 invProjectionMatrix { get; private set; }
-        public Vector4   invProjectionParam { get; private set; }
+        public Matrix4x4 viewProjMatrix
+        {
+            get { return projMatrix * viewMatrix; }
+        }
+
+        public Vector4 invProjParam
+        {
+            // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
+            get { var p = projMatrix; return new Vector4(p.m20 / (p.m00 * p.m23), p.m21 / (p.m11 * p.m23), -1.0f / p.m23, (-p.m22 + p.m20 * p.m02 / p.m00 + p.m21 * p.m12 / p.m11) / p.m23); }
+        }
+
+        // View-projection matrix from the previous frame.
+        public Matrix4x4 prevViewProjMatrix;
 
         // The only way to reliably keep track of a frame change right now is to compare the frame
         // count Unity gives us. We need this as a single camera could be rendered several times per
 
         public void Update()
         {
-            screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
-
-            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false);
+            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true); // Had to change this from 'false'
-                prevViewProjectionMatrix = !m_FirstFrame
-                    ? viewProjectionMatrix
+                prevViewProjMatrix = !m_FirstFrame
+                    ? viewProjMatrix
-            // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
-            var invProjParam = new Vector4(
-                gpuProj.m20 / (gpuProj.m00 * gpuProj.m23),
-                gpuProj.m21 / (gpuProj.m11 * gpuProj.m23),
-                -1.0f / gpuProj.m23,
-                (-gpuProj.m22
-                + gpuProj.m20 * gpuProj.m02 / gpuProj.m00
-                + gpuProj.m21 * gpuProj.m12 / gpuProj.m11) / gpuProj.m23
-            );
-
-            viewProjectionMatrix = gpuVP;
-            invViewProjectionMatrix = gpuVP.inverse;
-            invProjectionMatrix = gpuProj.inverse;
-            invProjectionParam = invProjParam;
+            viewMatrix = camera.worldToCameraMatrix;
+            projMatrix = gpuProj;
+            screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
-        public void SetupMaterial(Material material)
-        {
-            material.SetVector("_ScreenSize",         screenSize);
-            material.SetMatrix("_ViewProjMatrix",     viewProjectionMatrix);
-            material.SetMatrix("_PrevViewProjMatrix", prevViewProjectionMatrix);
-            material.SetMatrix("_InvViewProjMatrix",  invViewProjectionMatrix);
-            material.SetMatrix("_InvProjMatrix",      invProjectionMatrix);
-            material.SetVector("_InvProjParam",       invProjectionParam);
-        }
-
-        
+
         static Dictionary<Camera, HDCamera> m_Cameras = new Dictionary<Camera, HDCamera>();
         static List<Camera> m_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
 
 
             m_Cleanup.Clear();
         }
+
+        public void SetupGlobalParams(CommandBuffer cmd)
+        {
+            cmd.SetGlobalMatrix("_ViewMatrix",         viewMatrix);
+            cmd.SetGlobalMatrix("_InvViewMatrix",      viewMatrix.inverse);
+            cmd.SetGlobalMatrix("_ProjMatrix",         projMatrix);
+            cmd.SetGlobalMatrix("_InvProjMatrix",      projMatrix.inverse);
+            cmd.SetGlobalMatrix("_ViewProjMatrix",     viewProjMatrix);
+            cmd.SetGlobalMatrix("_InvViewProjMatrix",  viewProjMatrix.inverse);
+            cmd.SetGlobalVector("_InvProjParam",       invProjParam);
+            cmd.SetGlobalVector("_ScreenSize",         screenSize);
+            cmd.SetGlobalMatrix("_PrevViewProjMatrix", prevViewProjMatrix);
+        }
+
+        // Does not modify global settings. Used for shadows, low res. rendering, etc.
+        public void OverrideGlobalParams(Material material)
+        {
+            material.SetMatrix("_ViewMatrix",         viewMatrix);
+            material.SetMatrix("_InvViewMatrix",      viewMatrix.inverse);
+            material.SetMatrix("_ProjMatrix",         projMatrix);
+            material.SetMatrix("_InvProjMatrix",      projMatrix.inverse);
+            material.SetMatrix("_ViewProjMatrix",     viewProjMatrix);
+            material.SetMatrix("_InvViewProjMatrix",  viewProjMatrix.inverse);
+            material.SetVector("_InvProjParam",       invProjParam);
+            material.SetVector("_ScreenSize",         screenSize);
+            material.SetMatrix("_PrevViewProjMatrix", prevViewProjMatrix);
+        }
+
+        public void SetupComputeShader(ComputeShader cs, CommandBuffer cmd)
+        {
+            Utilities.SetMatrixCS(cmd, cs, "_ViewMatrix",         viewMatrix);
+            Utilities.SetMatrixCS(cmd, cs, "_InvViewMatrix",      viewMatrix.inverse);
+            Utilities.SetMatrixCS(cmd, cs, "_ProjMatrix",         projMatrix);
+            Utilities.SetMatrixCS(cmd, cs, "_InvProjMatrix",      projMatrix.inverse);
+            Utilities.SetMatrixCS(cmd, cs, "_ViewProjMatrix",     viewProjMatrix);
+            Utilities.SetMatrixCS(cmd, cs, "_InvViewProjMatrix",  viewProjMatrix.inverse);
+            cmd.SetComputeVectorParam( cs, "_InvProjParam",       invProjParam);
+            cmd.SetComputeVectorParam( cs, "_ScreenSize",         screenSize);
+            Utilities.SetMatrixCS(cmd, cs, "_PrevViewProjMatrix", prevViewProjMatrix);
+        }
     }
 
     public class GBufferManager
             }
         }
 
+        private RenderTargetIdentifier[] m_ColorMRTs;
-            var colorMRTs = new RenderTargetIdentifier[gbufferCount];
+            if (m_ColorMRTs == null || m_ColorMRTs.Length != gbufferCount)
+                m_ColorMRTs = new RenderTargetIdentifier[gbufferCount];
+
-                colorMRTs[index] = RTIDs[index];
+                m_ColorMRTs[index] = RTIDs[index];
-            return colorMRTs;
+            return m_ColorMRTs;
         }
 
         public int gbufferCount { get; set; }
 
         public void PushGlobalParams(HDCamera hdCamera, ScriptableRenderContext renderContext, SubsurfaceScatteringSettings sssParameters)
         {
-            var cmd = new CommandBuffer {name = "Push Global Parameters"};
+            var cmd = CommandBufferPool.Get("Push Global Parameters");
-            cmd.SetGlobalVector("_ScreenSize",         hdCamera.screenSize);
-            cmd.SetGlobalMatrix("_ViewProjMatrix",     hdCamera.viewProjectionMatrix);
-            cmd.SetGlobalMatrix("_PrevViewProjMatrix", hdCamera.prevViewProjectionMatrix);
-            cmd.SetGlobalMatrix("_InvViewProjMatrix",  hdCamera.invViewProjectionMatrix);
-            cmd.SetGlobalMatrix("_InvProjMatrix",      hdCamera.invProjectionMatrix);
-            cmd.SetGlobalVector("_InvProjParam",       hdCamera.invProjectionParam);
+            hdCamera.SetupGlobalParams(cmd);
 
             // TODO: cmd.SetGlobalInt() does not exist, so we are forced to use Shader.SetGlobalInt() instead.
 
             cmd.SetGlobalVectorArray("_TransmissionTints",       sssParameters.transmissionTints);
 
             renderContext.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         bool NeedDepthBufferCopy()
 
         private void CopyDepthBufferIfNeeded(ScriptableRenderContext renderContext)
         {
-            var cmd = new CommandBuffer() { name = NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer"};
+            var cmd = CommandBufferPool.Get(NeedDepthBufferCopy() ? "Copy DepthBuffer" : "Set DepthBuffer");
 
             if (NeedDepthBufferCopy())
             {
 
             cmd.SetGlobalTexture("_MainDepthTexture", GetDepthTexture());
             renderContext.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         public void UpdateCommonSettings()
             m_ShadowSettings.directionalLightNearPlaneOffset = commonSettings.shadowNearPlaneOffset;
         }
 
+        CullResults m_CullResults;
         public override void Render(ScriptableRenderContext renderContext, Camera[] cameras)
         {
             base.Render(renderContext, cameras);
             // we only want to render one camera for now
             // select the most main camera!
 
-            Camera camera = cameras.OrderByDescending(x => x.tag == "MainCamera").FirstOrDefault();
+            Camera camera = null;
+            foreach (var cam in cameras)
+            {
+                if (cam == Camera.main)
+                {
+                    camera = cam;
+                    break;
+
+                }
+            }
+
+            if (camera == null && cameras.Length > 0)
+                camera = cameras[0];
+
             if (camera == null)
             {
                 renderContext.Submit();
 
             m_LightLoop.UpdateCullingParameters( ref cullingParams );
 
-            var cullResults = CullResults.Cull(ref cullingParams, renderContext);
+            CullResults.Cull(ref cullingParams, renderContext,ref m_CullResults);
 
             Resize(camera);
 
             // We have to bind the material specific global parameters in this mode
             m_MaterialList.ForEach(material => material.Bind());
 
+            var additionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
+            if (additionalCameraData && additionalCameraData.renderingPath == RenderingPathHDRP.Unlit)
+            {
+                // TODO: Add another path dedicated to planar reflection / real time cubemap that implement simpler lighting
+                string passName = "Forward"; // It is up to the users to only send unlit object for this camera path
+
+                using (new Utilities.ProfilingSample(passName, renderContext))
+                {
+                    Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearColor | ClearFlag.ClearDepth);
+                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, passName);
+                    RenderTransparentRenderList(m_CullResults, camera, renderContext, passName);
+                }
+
+                renderContext.Submit();
+                return;
+            }
+
-            RenderDepthPrepass(cullResults, camera, renderContext);
+            RenderDepthPrepass(m_CullResults, camera, renderContext);
-            RenderForwardOnlyOpaqueDepthPrepass(cullResults, camera, renderContext);
-            RenderGBuffer(cullResults, camera, renderContext);
+            RenderForwardOnlyOpaqueDepthPrepass(m_CullResults, camera, renderContext);
+            RenderGBuffer(m_CullResults, camera, renderContext);
 
             // If full forward rendering, we did not do any rendering yet, so don't need to copy the buffer.
             // If Deferred then the depth buffer is full (regular GBuffer + ForwardOnly depth prepass are done so we can copy it safely.
 
             if (m_DebugDisplaySettings.IsDebugMaterialDisplayEnabled())
             {
-                RenderDebugViewMaterial(cullResults, hdCamera, renderContext);
+                RenderDebugViewMaterial(m_CullResults, hdCamera, renderContext);
             }
             else
             {
                     m_SsaoEffect.Render(ssaoSettingsToUse, this, hdCamera, renderContext, m_Asset.renderingSettings.useForwardRenderingOnly);
-                    m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, cullResults, camera);
-                    m_LightLoop.RenderShadows(renderContext, cullResults);
+                    m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
+                    m_LightLoop.RenderShadows(renderContext, m_CullResults);
                     renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
                     m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT);
                 }
                 // For opaque forward we have split rendering in two categories
                 // Material that are always forward and material that can be deferred or forward depends on render pipeline options (like switch to rendering forward only mode)
                 // Material that are always forward are unlit and complex (Like Hair) and don't require sorting, so it is ok to split them.
-                RenderForward(cullResults, camera, renderContext, true); // Render deferred or forward opaque
-                RenderForwardOnlyOpaque(cullResults, camera, renderContext);
+                RenderForward(m_CullResults, camera, renderContext, true); // Render deferred or forward opaque
+                RenderForwardOnlyOpaque(m_CullResults, camera, renderContext);
 
                 RenderLightingDebug(hdCamera, renderContext, m_CameraColorBufferRT);
 
                 RenderSky(hdCamera, renderContext);
 
                 // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
-                RenderForward(cullResults, camera, renderContext, false);
+                RenderForward(m_CullResults, camera, renderContext, false);
-                    var cmd = new CommandBuffer { name = "Blit to final RT" };
+                    var cmd = CommandBufferPool.Get("Blit to final RT" );
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
+
-                    RenderVelocity(cullResults, hdCamera, renderContext); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
+                    RenderVelocity(m_CullResults, hdCamera, renderContext); // Note we may have to render velocity earlier if we do temporalAO, temporal volumetric etc... Mean we will not take into account forward opaque in case of deferred rendering ?
-                    RenderDistortion(cullResults, camera, renderContext);
+                    RenderDistortion(m_CullResults, camera, renderContext);
 
                     RenderPostProcesses(camera, renderContext);
                 }
             // bind depth surface for editor grid/gizmo/selection rendering
             if (camera.cameraType == CameraType.SceneView)
             {
-                var cmd = new CommandBuffer();
+                var cmd = CommandBufferPool.Get();
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
             renderContext.Submit();
                 // Render GBuffer opaque
                 if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 {
-                    hdCamera.SetupMaterial(m_DebugViewMaterialGBuffer);
-
-                    var cmd = new CommandBuffer { name = "DebugViewMaterialGBuffer" };
+                    var cmd = CommandBufferPool.Get("DebugViewMaterialGBuffer" );
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
                 }
 
                 // Render forward transparent
 
             // Last blit
             {
-                var cmd = new CommandBuffer { name = "Blit DebugView Material Debug" };
+                var cmd = CommandBufferPool.Get("Blit DebugView Material Debug");
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
         }
 
             if (!m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
                 return;
 
-            var cmd = new CommandBuffer() { name = "Subsurface Scattering" };
+            var cmd = CommandBufferPool.Get("Subsurface Scattering");
-                // Temp >>>
-                Matrix4x4 viewMatrix = hdCamera.camera.worldToCameraMatrix;
-                viewMatrix.SetRow(2, -viewMatrix.GetRow(2));        // Make Z axis point forwards in the view space (left-handed CS)
-                Matrix4x4 projMatrix = GL.GetGPUProjectionMatrix(hdCamera.camera.projectionMatrix, false);
-                projMatrix.SetColumn(2, -projMatrix.GetColumn(2));  // Undo the view-space transformation
-                m_FilterAndCombineSubsurfaceScattering.SetMatrix("_ViewMatrix", viewMatrix);
-                m_FilterAndCombineSubsurfaceScattering.SetMatrix("_ProjMatrix", projMatrix);
-                // <<< Temp
-                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
             }
             else
             {
                 m_FilterSubsurfaceScattering.SetVectorArray("_FilterKernelsBasic",       sssParameters.filterKernelsBasic);
                 m_FilterSubsurfaceScattering.SetVectorArray("_HalfRcpWeightedVariances", sssParameters.halfRcpWeightedVariances);
-                Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, hdCamera, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
+                Utilities.DrawFullScreen(cmd, m_FilterSubsurfaceScattering, m_CameraFilteringBufferRT, m_CameraDepthStencilBufferRT);
 
                 // Perform the horizontal SSS filtering pass, and combine diffuse and specular lighting.
                 cmd.SetGlobalTexture("_IrradianceSource", m_CameraFilteringBufferRT);  // Cannot set a RT on a material
-                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, hdCamera, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
+                Utilities.DrawFullScreen(cmd, m_FilterAndCombineSubsurfaceScattering, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         void UpdateSkyEnvironment(HDCamera hdCamera, ScriptableRenderContext renderContext)
                 int w = (int)hdcam.screenSize.x;
                 int h = (int)hdcam.screenSize.y;
 
-                var cmd = new CommandBuffer { name = "" };
+                var cmd = CommandBufferPool.Get("");
-                cmd.Dispose();
-                
+
                 RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, "MotionVectors", RendererConfiguration.PerObjectMotionVectors);
             }
         }
                 int w = camera.pixelWidth;
                 int h = camera.pixelHeight;
 
-                var cmd = new CommandBuffer { name = "" };
+                var cmd = CommandBufferPool.Get("");
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
 
                 // Only transparent object can render distortion vectors
                 RenderTransparentRenderList(cullResults, camera, renderContext, "DistortionVectors");
             using (new Utilities.ProfilingSample("Post-processing", renderContext))
             {
                 var postProcessLayer = camera.GetComponent<PostProcessLayer>();
-                var cmd = new CommandBuffer { name = "" };
+                var cmd = CommandBufferPool.Get("");
 
                 if (postProcessLayer != null && postProcessLayer.enabled)
                 {
                 }
 
                 renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
         }
 
             }
         }
 
+        MaterialPropertyBlock m_SharedPropertyBlock = new MaterialPropertyBlock();
         void RenderDebug(HDCamera camera, ScriptableRenderContext renderContext)
         {
             // We don't want any overlay for these kind of rendering
             // We make sure the depth buffer is bound because we need it to write depth at near plane for overlays otherwise the editor grid end up visible in them.
             Utilities.SetRenderTarget(renderContext, BuiltinRenderTextureType.CameraTarget, m_CameraDepthStencilBufferRT);
 
-            CommandBuffer debugCB = new CommandBuffer();
+            CommandBuffer debugCB = CommandBufferPool.Get();
             debugCB.name = "Render Debug";
 
             // First render full screen debug texture
                 debugCB.SetGlobalTexture("_DebugFullScreenTexture", m_DebugFullScreenTempRT);
                 m_DebugFullScreen.SetFloat("_FullScreenDebugMode", (float)m_DebugDisplaySettings.lightingDebugSettings.fullScreenDebugMode);
-                Utilities.DrawFullScreen(debugCB, m_DebugFullScreen, camera, BuiltinRenderTextureType.CameraTarget);
+                Utilities.DrawFullScreen(debugCB, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
             }
 
             // Then overlays
             float y = camera.camera.pixelHeight - overlaySize;
-
-            MaterialPropertyBlock propertyBlock = new MaterialPropertyBlock();
 
             LightingDebugSettings lightingDebug = m_DebugDisplaySettings.lightingDebugSettings;
 
-                propertyBlock.SetTexture("_InputCubemap", skyReflection);
-                propertyBlock.SetFloat("_Mipmap", lightingDebug.skyReflectionMipmap);
+                m_SharedPropertyBlock.SetTexture("_InputCubemap", skyReflection);
+                m_SharedPropertyBlock.SetFloat("_Mipmap", lightingDebug.skyReflectionMipmap);
-                debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, propertyBlock);
+                debugCB.DrawProcedural(Matrix4x4.identity, m_DebugDisplayLatlong, 0, MeshTopology.Triangles, 3, 1, m_SharedPropertyBlock);
+            CommandBufferPool.Release(debugCB);
 
             m_LightLoop.RenderDebugOverlay(camera.camera, renderContext, m_DebugDisplaySettings, ref x, ref y, overlaySize, camera.camera.pixelWidth);
         }
                 // Clear depth/stencil and init buffers
                 using (new Utilities.ProfilingSample("InitGBuffers and clear Depth/Stencil", renderContext))
                 {
-                    var cmd = new CommandBuffer();
+                    var cmd = CommandBufferPool.Get();
                     cmd.name = "";
 
                     // Init buffer
                     }
 
                     renderContext.ExecuteCommandBuffer(cmd);
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
 
                     Utilities.SetRenderTarget(renderContext, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.ClearDepth);
                 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

     useForwardRenderingOnly: 0
     useDepthPrepass: 0
   sssSettings:
-    numProfiles: 3
+    numProfiles: 4
+    - {fileID: 11400000, guid: 15cd040d2fa59074d90956ea9badbee8, type: 2}
     useDisneySSS: 1
   tileSettings:
     enableTileAndCluster: 1

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.cs

 
             if (m_Command == null)
             {
-                m_Command = new CommandBuffer { name = "Ambient Occlusion" };
+                m_Command = new CommandBuffer();
+                m_Command.name = "Ambient Occlusion";
             }
             else
             {
 
             // AO estimation.
             m_Command.GetTemporaryRT(Uniforms._TempTex1, width / downsize, height / downsize, 0, kFilter, kTempFormat, kRWMode);
-            Utilities.DrawFullScreen(m_Command, m_Material, hdCamera, Uniforms._TempTex1, null, 0);
+            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex1, null, 0);
-            Utilities.DrawFullScreen(m_Command, m_Material, hdCamera, Uniforms._TempTex2, null, 1);
+            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex2, null, 1);
-            Utilities.DrawFullScreen(m_Command, m_Material, hdCamera, Uniforms._TempTex1, null, 2);
+            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex1, null, 2);
-            Utilities.DrawFullScreen(m_Command, m_Material, hdCamera, Uniforms._AOBuffer, null, 3);
+            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._AOBuffer, null, 3);
             m_Command.ReleaseTemporaryRT(Uniforms._TempTex1);
 
             // Setup texture for lighting pass (automagic of unity)
         public void Cleanup()
         {
             Utilities.Destroy(m_Material);
-            if (m_Command != null) m_Command.Dispose();
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.cs.meta

 fileFormatVersion: 2
-guid: d8a84f4cdff7d6e4c9864e0e606c1692
+guid: 610c595da286db7468ad0bd43535e07a
 timeCreated: 1494889441
 licenseType: Pro
 MonoImporter:

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/FeatureFlags.hlsl

 
 static const uint FeatureVariantFlags[NUM_FEATURE_VARIANTS] =
 {
-/*  0 */ 0 | MATERIALFEATUREFLAGS_MASK,
+/*  0 */ 0 | MATERIALFEATUREFLAGS_MASK, // TODO: ask Runes if this is really needed ? In case of material only, it mean debug and we don't care about performance
 /*  1 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | MATERIALFEATUREFLAGS_LIT_STANDARD,
 /*  2 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
 /*  3 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_STANDARD,

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

         static ComputeBuffer    s_ShadowDataBuffer;
         static ComputeBuffer    s_ShadowPayloadBuffer;
 
+        public static GPUShadowType HDShadowLightType(Light l)
+        {
+            // We only process light with additional data
+            var ald = l.GetComponent<HDAdditionalLightData>();
+
+            if (ald == null)
+            {
+                return ShadowRegistry.ShadowLightType(l);
+            }
+
+            GPUShadowType shadowType = GPUShadowType.Unknown;
+
+            switch (ald.archetype)
+            {
+                case LightArchetype.Punctual:
+                    shadowType = ShadowRegistry.ShadowLightType(l);
+                    break;
+                // Area and projector not supported yet
+            }
+
+            return shadowType;
+        }
+
         public ShadowSetup(ShadowInitParameters shadowInit, ShadowSettings shadowSettings, out IShadowManager shadowManager)
         {
             s_ShadowDataBuffer      = new ComputeBuffer( k_MaxShadowDataSlots, System.Runtime.InteropServices.Marshal.SizeOf( typeof( ShadowData ) ) );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Spot         , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Directional  , ShadowAlgorithm.PCF, ShadowVariant.V4, ShadowPrecision.High, useGlobalOverrides );
+
+            m_ShadowMgr.SetShadowLightTypeDelegate(HDShadowLightType);
+
             shadowManager = m_ShadowMgr;
         }
 
             // clustered light list specific buffers and data end
 
             private static GameObject s_DefaultAdditionalLightDataGameObject;
-            private static AdditionalLightData s_DefaultAdditionalLightData;
+            private static HDAdditionalLightData s_DefaultAdditionalLightData;
 
             bool usingFptl
             {
                 }
             }
 
-            private static AdditionalLightData DefaultAdditionalLightData
+            private static HDAdditionalLightData DefaultAdditionalLightData
             {
                 get
                 {
                         s_DefaultAdditionalLightDataGameObject.hideFlags = HideFlags.HideAndDontSave;
-                        s_DefaultAdditionalLightData = s_DefaultAdditionalLightDataGameObject.AddComponent<AdditionalLightData>();
+                        s_DefaultAdditionalLightData = s_DefaultAdditionalLightDataGameObject.AddComponent<HDAdditionalLightData>();
                         s_DefaultAdditionalLightDataGameObject.SetActive(false);
                     }
                     return s_DefaultAdditionalLightData;
                 return new Vector3(light.finalColor.r, light.finalColor.g, light.finalColor.b);
             }
 
-            public bool GetDirectionalLightData(ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex)
+            public bool GetDirectionalLightData(ShadowSettings shadowSettings, GPULightType gpuLightType, VisibleLight light, HDAdditionalLightData additionalData, AdditionalShadowData additionalShadowData, int lightIndex)
             {
                 var directionalLightData = new DirectionalLightData();
 
                 return 1.0f - Mathf.Clamp01((distanceToCamera - distanceFadeNear) / (fadeDistance - distanceFadeNear));
             }
 
-            public bool GetLightData(ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType, VisibleLight light, AdditionalLightData additionalData, int lightIndex)
+            public bool GetLightData(ShadowSettings shadowSettings, Camera camera, GPULightType gpuLightType, VisibleLight light, HDAdditionalLightData additionalLightData, AdditionalShadowData additionalshadowData, int lightIndex)
             {
                 var lightData = new LightData();
 
                 {
                     var spotAngle = light.spotAngle;
 
-                    var innerConePercent = additionalData.GetInnerSpotPercent01();
+                    var innerConePercent = additionalLightData.GetInnerSpotPercent01();
                     var cosSpotOuterHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * Mathf.Deg2Rad), 0.0f, 1.0f);
                     var sinSpotOuterHalfAngle = Mathf.Sqrt(1.0f - cosSpotOuterHalfAngle * cosSpotOuterHalfAngle);
                     var cosSpotInnerHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * innerConePercent * Mathf.Deg2Rad), 0.0f, 1.0f); // inner cone
                 }
 
                 float distanceToCamera = (lightData.positionWS - camera.transform.position).magnitude;
-                float distanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalData.fadeDistance);
-                float lightScale = additionalData.lightDimmer * distanceFade;
+                float distanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalLightData.fadeDistance);
+                float lightScale = additionalLightData.lightDimmer * distanceFade;
-                lightData.diffuseScale = additionalData.affectDiffuse ? lightScale * m_TileSettings.diffuseGlobalDimmer : 0.0f;
-                lightData.specularScale = additionalData.affectSpecular ? lightScale * m_TileSettings.specularGlobalDimmer : 0.0f;
+                lightData.diffuseScale = additionalLightData.affectDiffuse ? lightScale * m_TileSettings.diffuseGlobalDimmer : 0.0f;
+                lightData.specularScale = additionalLightData.affectSpecular ? lightScale * m_TileSettings.specularGlobalDimmer : 0.0f;
 
                 if (lightData.diffuseScale <= 0.0f && lightData.specularScale <= 0.0f)
                     return false;
                             break;
                     }
 
-                    if (additionalData.archetype == LightArchetype.Projector)
+                    if (additionalLightData.archetype == LightArchetype.Projector)
-                float shadowDistanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalData.shadowFadeDistance);
-                lightData.shadowDimmer = additionalData.shadowDimmer * shadowDistanceFade;
+
+                if (additionalshadowData)
+                {
+                    float shadowDistanceFade = ComputeLinearDistanceFade(distanceToCamera, additionalshadowData.shadowFadeDistance);
+                    lightData.shadowDimmer = additionalshadowData.shadowDimmer * shadowDistanceFade;
+                }
+                else
+                {
+                    lightData.shadowDimmer = 1.0f;
+                }
 
                 // fix up shadow information
                 int shadowIdx;
                 }
-                if (additionalData.archetype != LightArchetype.Punctual)
+                if (additionalLightData.archetype != LightArchetype.Punctual)
-                    lightData.size = new Vector2(additionalData.lightLength, additionalData.lightWidth);
+                    lightData.size = new Vector2(additionalLightData.lightLength, additionalLightData.lightWidth);
                 }
 
                 m_lightList.lights.Add(lightData);
             {
                 m_lightList.Clear();
 
-                if (cullResults.visibleLights.Length != 0 || cullResults.visibleReflectionProbes.Length != 0)
+                if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
                 {
                     // 0. deal with shadows
                     {
-                        m_ShadowRequests.Capacity = cullResults.visibleLights.Length;
-                        int lcnt = cullResults.visibleLights.Length;
+                        m_ShadowRequests.Capacity = cullResults.visibleLights.Count;
+                        int lcnt = cullResults.visibleLights.Count;
-                            AdditionalLightData ald = vl.light.GetComponent<AdditionalLightData>();
-                            if( vl.light.shadows != LightShadows.None && ald != null && ald.shadowDimmer > 0.0f )
+                            AdditionalShadowData asd = vl.light.GetComponent<AdditionalShadowData>();
+                            if( vl.light.shadows != LightShadows.None && asd != null && asd.shadowDimmer > 0.0f )
+                        //TODO: Do not call ToArray here to avoid GC, refactor API
                         int[]   shadowRequests = m_ShadowRequests.ToArray();
                         int[]   shadowDataIndices;
                         m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, cullResults.visibleLights,
                     int areaLightCount = 0;
                     int projectorLightCount = 0;
 
-                    int lightCount = Math.Min(cullResults.visibleLights.Length, k_MaxLightsOnScreen);
+                    int lightCount = Math.Min(cullResults.visibleLights.Count, k_MaxLightsOnScreen);
-                    for (int lightIndex = 0, numLights = cullResults.visibleLights.Length; (lightIndex < numLights) && (sortCount < lightCount); ++lightIndex)
+                    for (int lightIndex = 0, numLights = cullResults.visibleLights.Count; (lightIndex < numLights) && (sortCount < lightCount); ++lightIndex)
-                        var additionalData = light.light.GetComponent<AdditionalLightData>();
+                        var additionalData = light.light.GetComponent<HDAdditionalLightData>();
 
                         if (additionalData == null)
                             additionalData = DefaultAdditionalLightData;
                         sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
                     }
 
+                    //TODO: Replace with custom sort, allocates mem and increases GC pressure.
                     Array.Sort(sortKeys, 0, sortCount);
 
                     // TODO: Refactor shadow management
                         int lightIndex = (int)(sortKey & 0xFFFF);
 
                         var light = cullResults.visibleLights[lightIndex];
-                        var additionalData = light.light.GetComponent<AdditionalLightData>() ?? DefaultAdditionalLightData;
+                        var additionalLightData = light.light.GetComponent<HDAdditionalLightData>() ?? DefaultAdditionalLightData;
+                        var additionalShadowData = light.light.GetComponent<AdditionalShadowData>(); // Can be null
-                            if (GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalData, lightIndex))
+                            if (GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
-                        if(GetLightData(shadowSettings, camera, gpuLightType, light, additionalData, lightIndex))
+                        if (GetLightData(shadowSettings, camera, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
                         {
                             switch (lightCategory)
                             {
                     // Redo everything but this time with envLights
                     int envLightCount = 0;
 
-                    int probeCount = Math.Min(cullResults.visibleReflectionProbes.Length, k_MaxEnvLightsOnScreen);
+                    int probeCount = Math.Min(cullResults.visibleReflectionProbes.Count, k_MaxEnvLightsOnScreen);
-                    for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Length; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
+                    for (int probeIndex = 0, numProbes = cullResults.visibleReflectionProbes.Count; (probeIndex < numProbes) && (sortCount < probeCount); probeIndex++)
                     {
                         var probe = cullResults.visibleReflectionProbes[probeIndex];
 
                 var projscr = temp * proj;
                 var invProjscr = projscr.inverse;
 
-                var cmd = new CommandBuffer() { name = "" };
+                var cmd = CommandBufferPool.Get("");
                 cmd.SetRenderTarget(new RenderTargetIdentifier((Texture)null));
 
                 // generate screen-space AABBs (used for both fptl and clustered).
                 // enable coarse 2D pass on 64x64 tiles (used for both fptl and clustered).
                 if (m_TileSettings.enableBigTilePrepass)
                 {
-                    cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", new int[2] { w, h });
+                    cmd.SetComputeIntParams(buildPerBigTileLightListShader, "g_viDimensions", w, h);
                     cmd.SetComputeIntParam(buildPerBigTileLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
                     cmd.SetComputeIntParam(buildPerBigTileLightListShader, "g_iNrVisibLights", m_lightCount);
                     Utilities.SetMatrixCS(cmd, buildPerBigTileLightListShader, "g_mScrProjection", projscr);
 
                 if (usingFptl)       // optimized for opaques only
                 {
-                    cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", new int[2] { w, h });
+                    cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", w, h);
                     cmd.SetComputeIntParam(buildPerTileLightListShader, "_EnvLightIndexShift", m_lightList.lights.Count);
                     cmd.SetComputeIntParam(buildPerTileLightListShader, "g_iNrVisibLights", m_lightCount);
 
                         }
 
                         cmd.SetComputeIntParam(buildMaterialFlagsShader, "g_BaseFeatureFlags", (int)baseFeatureFlags);
-                        cmd.SetComputeIntParams(buildMaterialFlagsShader, "g_viDimensions", new int[2] { w, h });
+                        cmd.SetComputeIntParams(buildMaterialFlagsShader, "g_viDimensions", w, h);
                         cmd.SetComputeBufferParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "g_TileFeatureFlags", s_TileFeatureFlags);
 
                         cmd.SetComputeTextureParam(buildMaterialFlagsShader, buildMaterialFlagsKernel, "g_depth_tex", cameraDepthBufferRT);
                 }
 
                 loop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
             // This is a workaround for global properties not being accessible from compute.
 
             private void UpdateDataBuffers()
             {
-                s_DirectionalLightDatas.SetData(m_lightList.directionalLights.ToArray());
-                s_LightDatas.SetData(m_lightList.lights.ToArray());
-                s_EnvLightDatas.SetData(m_lightList.envLights.ToArray());
-                s_shadowDatas.SetData(m_lightList.shadows.ToArray());
+                s_DirectionalLightDatas.SetData(m_lightList.directionalLights);
+                s_LightDatas.SetData(m_lightList.lights);
+                s_EnvLightDatas.SetData(m_lightList.envLights);
+                s_shadowDatas.SetData(m_lightList.shadows);
-                s_ConvexBoundsBuffer.SetData(m_lightList.bounds.ToArray());
-                s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes.ToArray());
+                s_ConvexBoundsBuffer.SetData(m_lightList.bounds);
+                s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes);
             }
 
             private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera, ScriptableRenderContext loop)
 
             private void PushGlobalParams(Camera camera, ScriptableRenderContext loop, ComputeShader computeShader, int kernelIndex)
             {
-                var cmd = new CommandBuffer { name = "Push Global Parameters" };
+                var cmd = CommandBufferPool.Get("Push Global Parameters");
 
                 // Shadows
                 m_ShadowMgr.SyncData();
                 SetGlobalPropertyRedirect(null, 0, null);
 
                 loop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
 #if UNITY_EDITOR
                 if (m_TileSettings.tileDebugByCategory == TileSettings.TileDebug.None)
                     return;
 
-                var cmd = new CommandBuffer();
+                var cmd = CommandBufferPool.Get();
                 cmd.name = "Tiled Lighting Debug";
 
                 bool bUseClusteredForDeferred = !usingFptl;
                     if (GetFeatureVariantsEnabled())
                     {
                         // featureVariants
-                        hdCamera.SetupMaterial(m_DebugViewTilesMaterial);
                         m_DebugViewTilesMaterial.SetInt("_NumTiles", numTiles);
                         m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                         m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                 else if (m_TileSettings.tileDebugByCategory != TileSettings.TileDebug.None)
                 {
                     // lightCategories
-                    hdCamera.SetupMaterial(m_DebugViewTilesMaterial);
                     m_DebugViewTilesMaterial.SetInt("_ViewTilesFlags", (int)m_TileSettings.tileDebugByCategory);
                     m_DebugViewTilesMaterial.SetVector("_MousePixelCoord", mousePixelCoord);
                     m_DebugViewTilesMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
                 SetGlobalPropertyRedirect(null, 0, null);
 
                 renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
             public void RenderDeferredLighting( HDCamera hdCamera, ScriptableRenderContext renderContext,
 
                 using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), renderContext))
                 {
-                    var cmd = new CommandBuffer();
+                    var cmd = CommandBufferPool.Get();
                     cmd.name = bUseClusteredForDeferred ? "Clustered pass" : "Tiled pass";
 
                     var camera = hdCamera.camera;
                         // This is a debug brute force renderer to debug tile/cluster which render all the lights
                         if (outputSplitLighting)
                         {
-                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialMRT, colorBuffers, depthStencilBuffer);
                         }
                         else
                         {
                                 m_SingleDeferredMaterialSRT.SetInt("_StencilCmp", (int)CompareFunction.Equal);
                             }
 
-                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                            Utilities.DrawFullScreen(cmd, m_SingleDeferredMaterialSRT, colorBuffers[0], depthStencilBuffer);
                         }
                     }
                     else
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcDisneyDiffuseMatrix", Shader.GetGlobalTexture("_LtcDisneyDiffuseMatrix"));
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_LtcMultiGGXFresnelDisneyDiffuse", Shader.GetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse"));
 
-                                Matrix4x4 viewToWorld = camera.cameraToWorldMatrix;
-                                Matrix4x4 worldToView = camera.worldToCameraMatrix;
-                                Matrix4x4 viewProjection = hdCamera.viewProjectionMatrix;
-                                Matrix4x4 invViewProjection = hdCamera.invViewProjectionMatrix;
-
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixV", worldToView);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixInvV", viewToWorld);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "unity_MatrixVP", viewProjection);
+                                hdCamera.SetupComputeShader(shadeOpaqueShader, cmd);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_InvViewProjMatrix", invViewProjection);
-                                Utilities.SetMatrixCS(cmd, shadeOpaqueShader, "_ViewProjMatrix", viewProjection);
-                                cmd.SetComputeVectorParam(shadeOpaqueShader, "_ScreenSize", hdCamera.screenSize);
                                 cmd.SetComputeIntParam(shadeOpaqueShader, "_UseTileLightList", Shader.GetGlobalInt("_UseTileLightList"));
 
                                 cmd.SetComputeVectorParam(shadeOpaqueShader, "_Time", Shader.GetGlobalVector("_Time"));
                                 if (outputSplitLighting)
                                 {
                                     Utilities.SelectKeyword(m_DeferredDirectMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialMRT, colorBuffers, depthStencilBuffer);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialMRT, colorBuffers, depthStencilBuffer);
                                 }
                                 else
                                 {
                                     }
 
                                     Utilities.SelectKeyword(m_DeferredDirectMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredDirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredIndirectMaterialSRT, colorBuffers[0], depthStencilBuffer);
                                 }
                             }
                             else
                                     Utilities.SelectKeyword(m_DeferredAllMaterialMRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, hdCamera, colorBuffers, depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialMRT, colorBuffers, depthStencilBuffer);
                                 }
                                 else
                                 {
                                     }
 
                                     Utilities.SelectKeyword(m_DeferredAllMaterialSRT, "USE_CLUSTERED_LIGHTLIST", "USE_FPTL_LIGHTLIST", bUseClusteredForDeferred);
-                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, hdCamera, colorBuffers[0], depthStencilBuffer);
+                                    Utilities.DrawFullScreen(cmd, m_DeferredAllMaterialSRT, colorBuffers[0], depthStencilBuffer);
                                 }
                             }
                         }
 
                     renderContext.ExecuteCommandBuffer(cmd);
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
                 } // TilePass - Deferred Lighting Pass
             }
 
                 bool useFptl = renderOpaque && usingFptl;
 
-                var cmd = new CommandBuffer();
+                var cmd = CommandBufferPool.Get();
 
                 if (!m_TileSettings.enableTileAndCluster)
                 {
                 }
 
                 renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
             public void RenderDebugOverlay(Camera camera, ScriptableRenderContext renderContext, DebugDisplaySettings debugDisplaySettings, ref float x, ref float y, float overlaySize, float width)

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl

 
 #include "TilePass.cs.hlsl"
 
-// For FPTL
-uint _NumTileFtplX;
-uint _NumTileFtplY;
-
+
+CBUFFER_START(UnityTilePass)
+uint _NumTileFtplX;
+uint _NumTileFtplY;
 
 // these uniforms are only needed for when OPAQUES_ONLY is NOT defined
 // but there's a problem with our front-end compilation of compute shaders with multiple kernels causing it to error
 //#ifdef USE_CLUSTERED_LIGHTLIST
 uint _NumTileClusteredX;
 uint _NumTileClusteredY;
+CBUFFER_END
+
 StructuredBuffer<uint> g_vLayeredOffsetsBuffer;     // don't support Buffer yet in unity
 StructuredBuffer<float> g_logBaseBuffer;            // don't support Buffer yet in unity
 //#endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-clustered.compute

 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 #define CONV_HULL_TEST_ENABLED
 
-uniform int g_iNrVisibLights;
-uniform float4x4 g_mInvScrProjection;
-uniform float4x4 g_mScrProjection;
-uniform int _EnvLightIndexShift;
+CBUFFER_START(UnityLightListClustered)
+int g_iNrVisibLights;
+float4x4 g_mInvScrProjection;
+float4x4 g_mScrProjection;
+int _EnvLightIndexShift;
-uniform float g_fClustScale;
-uniform float g_fClustBase;
-uniform float g_fNearPlane;
-uniform float g_fFarPlane;
-uniform int	  g_iLog2NumClusters;		// numClusters = (1<<g_iLog2NumClusters)
+float g_fClustScale;
+float g_fClustBase;
+float g_fNearPlane;
+float g_fFarPlane;
+int	  g_iLog2NumClusters;		// numClusters = (1<<g_iLog2NumClusters)
+CBUFFER_END
 
 #include "ClusteredUtils.hlsl"
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/materialflags.compute

 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64
 
-uniform uint2 g_viDimensions;
+CBUFFER_START(UnityMaterialFlags)
+uint2 g_viDimensions;
+uint g_BaseFeatureFlags;
+CBUFFER_END
-uniform uint g_BaseFeatureFlags;
 
 DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/shadeopaque.compute

     RWTexture2D<float4> combinedLightingUAV;
 #endif
 
+CBUFFER_START(UnityShadeOpaque)
+	uint g_TileListOffset;
+CBUFFER_END
+
-	uint g_TileListOffset;
     StructuredBuffer<uint> g_TileList;
 // Indirect
 [numthreads(16, 16, 1)]

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

 
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+    // #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../ShaderConfig.cs.hlsl"
-    #include "../../ShaderVariables.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 
 
     SubShader
     {
-        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
-        LOD 300
-
        Pass
         {
             Name "GBuffer"  // Name is not used
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_GBUFFER
-
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "../Lit/LitData.hlsl"
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitMetaPass.hlsl"
             #include "../Lit/LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_VELOCITY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitVelocityPass.hlsl"
             #include "../Lit/LitData.hlsl"
 
             Cull[_CullMode]
 
+            ZClip Off
-            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #define SHADERPASS SHADERPASS_SHADOWS
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDepthPass.hlsl"
             #include "../Lit/LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDepthPass.hlsl"
             #include "../Lit/LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_DISTORTION
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDistortionPass.hlsl"
             #include "../Lit/LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include

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

 
     #pragma target 5.0
     #pragma only_renderers d3d11 ps4 // TEMP: until we go further in dev
+    // #pragma enable_d3d11_debug_symbols
 
     #pragma shader_feature _ALPHATEST_ON
     #pragma shader_feature _DISTORTION_ON
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../../ShaderLibrary/tessellation.hlsl"
     #include "../../ShaderConfig.cs.hlsl"
-    #include "../../ShaderVariables.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 
 
     SubShader
     {
-        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
-        LOD 300
-
        Pass
         {
             Name "GBuffer"  // Name is not used
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_GBUFFER
-
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #include "../Lit/LitData.hlsl"
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitSharePass.hlsl"
             #undef TESSELLATION_ON
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitMetaPass.hlsl"
             #include "../Lit/LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_VELOCITY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitVelocityPass.hlsl"
             #include "../Lit/LitData.hlsl"
 
             Cull[_CullMode]
 
+            ZClip Off
             ZWrite On
             ZTest LEqual
 
             #pragma domain Domain
 
-            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #define SHADERPASS SHADERPASS_SHADOWS
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDepthPass.hlsl"
             #include "../Lit/LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDepthPass.hlsl"
             #include "../Lit/LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_DISTORTION
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "../Lit/ShaderPass/LitDistortionPass.hlsl"
             #include "../Lit/LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include

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

             m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap);
         }
 
-        protected void ShaderStandardInputGUI()
+        protected void ShaderAnisoInputGUI()
         {
             if ((NormalMapSpace)normalMapSpace.floatValue == NormalMapSpace.TangentSpace)
             {
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap, baseColor);
 
-            if ((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard)
+            if ((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard || (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitAniso)
             {
                 m_MaterialEditor.ShaderProperty(metallic, Styles.metallicText);
             }
                     ShaderSSSInputGUI(material);
                     break;
                 case Lit.MaterialId.LitStandard:
-                    ShaderStandardInputGUI();
+                    // Nothing
+                    break;
+                case Lit.MaterialId.LitAniso:
+                    ShaderAnisoInputGUI();
                     break;
                 case Lit.MaterialId.LitSpecular:
                     m_MaterialEditor.TexturePropertySingleLine(Styles.specularColorText, specularColorMap, specularColor);
                 material.DisableKeyword("_REQUIRE_UV2");
                 material.DisableKeyword("_REQUIRE_UV3");
             }
+
+            Lit.MaterialId materialId = (Lit.MaterialId)material.GetFloat(kMaterialID);
+
+            SetKeyword(material, "_MATID_SSS", materialId == Lit.MaterialId.LitSSS);
+            //SetKeyword(material, "_MATID_STANDARD", materialId == Lit.MaterialId.LitStandard); // See comment in Lit.shader, it is the default, we don't define it
+            SetKeyword(material, "_MATID_ANISO", materialId == Lit.MaterialId.LitAniso);
+            SetKeyword(material, "_MATID_SPECULAR", materialId == Lit.MaterialId.LitSpecular);
         }
     }
 } // namespace UnityEditor

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         {
             LitSSS      = 0,
             LitStandard = 1,
-            LitSpecular = 2,
-            LitUnused   = 3,
-            LitAniso    = 4 // Should be the last as it is not setup by the users but generated based on anisotropy property
+            LitUnused0  = 2,
+            LitUnused1  = 3,
+            LitAniso    = 4, // Should be the last as it is not setup by the users but generated based on anisotropy property
+            LitSpecular = 5, // Should be the last as it is not setup by the users but generated based on anisotropy property and specular
         };
 
         [GenerateHLSL]
             LitStandard = 1 << 13,
-            LitSpecular = 1 << 14,
-            LitAniso    = 1 << 15
+            LitAniso    = 1 << 14,
+            LitSpecular = 1 << 15
+        }
+
+        [GenerateHLSL]
+        public enum SpecularValue
+        {
+            // Value are defined in the tab name convertSpecularToValue in lit.hlsl
+            Water = 0, // 0.02  Water or ice
+            Regular = 1, // 0.04 regular dieletric
+            Gemstone = 2, // 0.20
+            SpecularColor = 3 // Special case: use specular color
         }
 
         //-----------------------------------------------------------------------------
             [SurfaceDataAttributes("Metallic")]
             public float metallic;
             [SurfaceDataAttributes("Specular")]
-            public float specular; // 0.02, 0.04, 0.16, 0.2
+            public SpecularValue specular;
 
             // SSS
             [SurfaceDataAttributes("Subsurface Radius")]
             if (m_isInit)
                 return;
 
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
-            cmd.Blit(null, new RenderTargetIdentifier(m_PreIntegratedFGD), m_InitPreFGD, 0);
+            Utilities.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
-            cmd.Dispose();
-
+            CommandBufferPool.Release(cmd);
             m_isInit = true;
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 //
 #define MATERIALID_LIT_SSS (0)
 #define MATERIALID_LIT_STANDARD (1)
-#define MATERIALID_LIT_SPECULAR (2)
-#define MATERIALID_LIT_UNUSED (3)
+#define MATERIALID_LIT_UNUSED0 (2)
+#define MATERIALID_LIT_UNUSED1 (3)
+#define MATERIALID_LIT_SPECULAR (5)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+MaterialFeatureFlags:  static fields
-#define MATERIALFEATUREFLAGS_LIT_SPECULAR (16384)
-#define MATERIALFEATUREFLAGS_LIT_ANISO (32768)
+#define MATERIALFEATUREFLAGS_LIT_ANISO (16384)
+#define MATERIALFEATUREFLAGS_LIT_SPECULAR (32768)
+
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.Lit+SpecularValue:  static fields
+//
+#define SPECULARVALUE_WATER (0)
+#define SPECULARVALUE_REGULAR (1)
+#define SPECULARVALUE_GEMSTONE (2)
+#define SPECULARVALUE_SPECULAR_COLOR (3)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SurfaceData:  static fields
     float3 tangentWS;
     float anisotropy;
     float metallic;
-    float specular;
+    int specular;
     float subsurfaceRadius;
     float thickness;
     int subsurfaceProfile;
             result = surfacedata.metallic.xxx;
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
-            result = surfacedata.specular.xxx;
+            result = GetIndexColor(surfacedata.specular);
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
             result = surfacedata.subsurfaceRadius.xxx;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 #define SSS_WRAP_ANGLE (PI/12)              // Used for wrap lighting
 #define SSS_WRAP_LIGHT cos(PI/2 - SSS_WRAP_ANGLE)
 
+CBUFFER_START(UnitySSSParameters)
 uint   _EnableSSSAndTransmission;           // Globally toggles subsurface and transmission scattering on/off
 uint   _TexturingModeFlags;                 // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
 uint   _TransmissionFlags;                  // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
+CBUFFER_END
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
 #endif
 }
 
-void FillMaterialIdStandardData(float3 baseColor, float specular, float metallic, float roughness, float3 normalWS, float3 tangentWS, float anisotropy, inout BSDFData bsdfData)
+static const float3 convertSpecularToValue = float3(0.02, 0.04, 0.20);
+
+void FillMaterialIdStandardData(float3 baseColor, int specular, float metallic, inout BSDFData bsdfData)
-    bsdfData.fresnel0 = lerp(float3(specular.xxx), baseColor, metallic);
+    float val = convertSpecularToValue[specular];
+    bsdfData.fresnel0 = lerp(val.xxx, baseColor, metallic);
+}
-    // TODO: encode specular
-
+void FillMaterialIdAnisoData(float roughness, float3 normalWS, float3 tangentWS, float anisotropy, inout BSDFData bsdfData)
+{
     bsdfData.tangentWS = tangentWS;
     bsdfData.bitangentWS = cross(normalWS, tangentWS);
     ConvertAnisotropyToRoughness(roughness, anisotropy, bsdfData.roughnessT, bsdfData.roughnessB);
     bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
     bsdfData.materialId = surfaceData.materialId;
 
+    // IMPORTANT: In case of foward or gbuffer pass we know what we are, we don't need to check specular or aniso to know the materialId, this is because we have static compile shader feature for it
-        FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.specular, surfaceData.metallic, bsdfData.roughness, surfaceData.normalWS, surfaceData.tangentWS, surfaceData.anisotropy, bsdfData);
-        bsdfData.materialId = surfaceData.anisotropy > 0.0 ? MATERIALID_LIT_ANISO : bsdfData.materialId;
-    }
-    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
-    {
-        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
+        FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.specular, surfaceData.metallic, bsdfData);
     }
     else if (bsdfData.materialId == MATERIALID_LIT_SPECULAR)
     {
+    else if (bsdfData.materialId == MATERIALID_LIT_ANISO)
+    {
+        FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.specular, surfaceData.metallic, bsdfData);
+        FillMaterialIdAnisoData(bsdfData.roughness, surfaceData.normalWS, surfaceData.tangentWS, surfaceData.anisotropy, bsdfData);
+    }
+    else if (bsdfData.materialId == MATERIALID_LIT_SSS)
+    {
+        FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData);
+    }
 
     ApplyDebugToBSDFData(bsdfData);
 
 //-----------------------------------------------------------------------------
 // conversion function for deferred
 //-----------------------------------------------------------------------------
-
-// Tetra encoding 10:10 + 2 seems equivalent to oct 11:11, as oct is cheaper use that. Let here for future testing in reflective scene for comparison
-//#define USE_NORMAL_TETRAHEDRON_ENCODING
 
 // Encode SurfaceData (BSDF parameters) into GBuffer
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
     // RT1 - 10:10:10:2
     // We store perceptualRoughness instead of roughness because it save a sqrt ALU when decoding
     // (as we want both perceptualRoughness and roughness for the lighting due to Disney Diffuse model)
-#ifdef USE_NORMAL_TETRAHEDRON_ENCODING
-    // Encode normal on 20bit + 2bit (faceIndex) with tetrahedal compression
-    uint faceIndex;
-    float2 tetraNormalWS = PackNormalTetraEncode(surfaceData.normalWS, faceIndex);
-    // Store faceIndex on two bits with perceptualRoughness
-    outGBuffer1 = float4(tetraNormalWS * 0.5 + 0.5, PackFloatInt10bit(PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), faceIndex, 4.0), PackMaterialId(surfaceData.materialId));
-#else
     // Encode normal on 20bit with oct compression + 2bit of sign
     float2 octNormalWS = PackNormalOctEncode(surfaceData.normalWS);
     // To have more precision encode the sign of xy in a separate uint
-#endif
+        // Encode specular on two bit for the enum
+        outGBuffer2 = float4(0.0, 0.0, 0.0, PackFloatInt8bit(surfaceData.metallic, surfaceData.specular, 4.0));
+    }
+    else if (surfaceData.materialId == MATERIALID_LIT_SPECULAR)
+    {
+        outGBuffer1.a = PackMaterialId(MATERIALID_LIT_STANDARD); // We save 1bit in gbuffer1 to store it in gbuffer2 instead
+        // Encode specular on two bit for the enum, must match encoding of MATERIALID_LIT_STANDARD
+        // TODO: encoding here could be optimize as we know what is the value of surfaceData.specular => (0.75294)
+        outGBuffer2 = float4(surfaceData.specularColor, PackFloatInt8bit(0.0, surfaceData.specular, 4.0));
+    }
+    else if (surfaceData.materialId == MATERIALID_LIT_ANISO)
+    {
+        outGBuffer1.a = PackMaterialId(MATERIALID_LIT_STANDARD); // We save 1bit in gbuffer1 and use aniso value instead to detect we are aniso
-        // TODO: store metal and specular together, specular should be an enum (fixed value)
-        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, surfaceData.metallic);
+        outGBuffer2 = float4(octTangentWS * 0.5 + 0.5, surfaceData.anisotropy, PackFloatInt8bit(surfaceData.metallic, surfaceData.specular, 4.0));
-    }
-    else if (surfaceData.materialId == MATERIALID_LIT_SPECULAR)
-    {
-        outGBuffer2 = float4(surfaceData.specularColor, 0.0);
     }
 
     // Lighting
     float3 baseColor = inGBuffer0.rgb;
     bsdfData.specularOcclusion = inGBuffer0.a;
 
-#ifdef USE_NORMAL_TETRAHEDRON_ENCODING
-    int faceIndex;
-    UnpackFloatInt10bit(inGBuffer1.b, 4.0, bsdfData.perceptualRoughness, faceIndex);
-    bsdfData.normalWS = UnpackNormalTetraEncode(inGBuffer1.xy * 2.0 - 1.0, faceIndex);
-#else
-#endif
-    int supportsStandard = (featureFlags & (MATERIALFEATUREFLAGS_LIT_STANDARD | MATERIALFEATUREFLAGS_LIT_ANISO)) != 0;
+    int supportsStandard = (featureFlags & (MATERIALFEATUREFLAGS_LIT_STANDARD | MATERIALFEATUREFLAGS_LIT_ANISO | MATERIALFEATUREFLAGS_LIT_SPECULAR)) != 0;
-    int supportsSpecular = (featureFlags & (MATERIALFEATUREFLAGS_LIT_SPECULAR)) != 0;
-    if(supportsStandard + supportsSSS + supportsSpecular > 1)
+    if (supportsStandard + supportsSSS > 1)
     {
         bsdfData.materialId = UnpackMaterialId(inGBuffer1.a);   // only fetch materialid if it is not statically known from feature flags
     }
-        if(supportsStandard) bsdfData.materialId = MATERIALID_LIT_STANDARD;
-        else if(supportsSSS) bsdfData.materialId = MATERIALID_LIT_SSS;
-        else bsdfData.materialId = MATERIALID_LIT_SPECULAR;
+        if (supportsStandard)
+            bsdfData.materialId = MATERIALID_LIT_STANDARD;
+        else // if (supportsSSS)
+            bsdfData.materialId = MATERIALID_LIT_SSS;
-        float metallic = inGBuffer2.a;
-        float specular = 0.04; // TODO extract spec
+        float metallic;
+        int specular;
+        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, specular);
-        float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
-        FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
-        if ((featureFlags & MATERIALFEATUREFLAGS_LIT_ANISO) && (featureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) == 0 || anisotropy > 0)
+        if (((featureFlags & MATERIALFEATUREFLAGS_LIT_SPECULAR) && (featureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) == 0)
+            || specular == SPECULARVALUE_SPECULAR_COLOR)
+        {
+            bsdfData.materialId = MATERIALID_LIT_SPECULAR;
+            bsdfData.diffuseColor = baseColor;
+            bsdfData.fresnel0 = inGBuffer2.rgb;
+        }
+        else if ( ((featureFlags & MATERIALFEATUREFLAGS_LIT_ANISO) && (featureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) == 0)
+                || anisotropy > 0)
+            FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData);
+            float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
+            FillMaterialIdAnisoData(bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
+        else
+        {
+            FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData);
+        }
+
-    else if (supportsSSS && bsdfData.materialId == MATERIALID_LIT_SSS)
+    else // if (supportsSSS && bsdfData.materialId == MATERIALID_LIT_SSS)
     {
         float subsurfaceRadius  = inGBuffer2.x;
         float thickness         = inGBuffer2.y;
-    }
-    else if (supportsSpecular && bsdfData.materialId == MATERIALID_LIT_SPECULAR)
-    {
-        bsdfData.diffuseColor = baseColor;
-        bsdfData.fresnel0 = inGBuffer2.rgb;
     }
 
     bakeDiffuseLighting = inGBuffer3.rgb;
 #endif
 
     int materialId = UnpackMaterialId(inGBuffer1.a);
-    float anisotropy = inGBuffer2.b;
-        featureFlags |= (anisotropy > 0) ? MATERIALFEATUREFLAGS_LIT_ANISO : MATERIALFEATUREFLAGS_LIT_STANDARD;
+        float metallic;
+        int specular;
+        UnpackFloatInt8bit(inGBuffer2.a, 4.0, metallic, specular);
+        float anisotropy = inGBuffer2.b;
+
+        if (specular == SPECULARVALUE_SPECULAR_COLOR)
+        {
+            featureFlags |= MATERIALFEATUREFLAGS_LIT_SPECULAR;
+        }
+        else if (anisotropy > 0.0)
+        {
+            featureFlags |= MATERIALFEATUREFLAGS_LIT_ANISO;
+        }
+        else
+        {
+            featureFlags |= MATERIALFEATUREFLAGS_LIT_STANDARD;
+        }
-    else if (materialId == MATERIALID_LIT_SPECULAR)
-    {
-        featureFlags |= MATERIALFEATUREFLAGS_LIT_SPECULAR;
-    }
+
     return featureFlags;
 }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader

         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Subsurface Scattering, 0, Standard, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
+        // Note: 2 and 3 are currently unused
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 4, Specular Color, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
+    // MaterialId are used as shader feature to allow compiler to optimize properly
+    // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
+    #pragma shader_feature _ _MATID_SSS _MATID_ANISO _MATID_SPECULAR
+
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
     #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     #include "../../../ShaderLibrary/common.hlsl"
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../ShaderConfig.cs.hlsl"
-    #include "../../ShaderVariables.hlsl"
+
 
     //-------------------------------------------------------------------------------------
     // variable declaration
 
     SubShader
     {
-        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
-        LOD 300
-
         Pass
         {
             Name "GBuffer"  // Name is not used
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitMetaPass.hlsl"
             #include "LitData.hlsl"
 
             HLSLPROGRAM
 
-            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #define SHADERPASS SHADERPASS_SHADOWS
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_VELOCITY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitVelocityPass.hlsl"
             #include "LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_DISTORTION
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDistortionPass.hlsl"
             #include "LitData.hlsl"
             HLSLPROGRAM
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

     // This part of the code is not used in case of layered shader but we keep the same macro system for simplicity
 #if !defined(LAYERED_LIT_SHADER)
 
-    // TODO: In order to let the compiler optimize in case of forward rendering this need to be a variant (shader feature) and not a parameter!
-    surfaceData.materialId = _MaterialID;
+    // Having individual shader features for each materialID like this allow the compiler to optimize
+#ifdef _MATID_SSS
+    surfaceData.materialId = MATERIALID_LIT_SSS;
+#elif defined(_MATID_ANISO)
+    surfaceData.materialId = MATERIALID_LIT_ANISO;
+#elif defined(_MATID_SPECULAR)
+    surfaceData.materialId = MATERIALID_LIT_SPECULAR;
+#else // Default
+    surfaceData.materialId = MATERIALID_LIT_STANDARD;
+#endif
 
 #ifdef _TANGENTMAP
     #ifdef _NORMALMAP_TANGENT_SPACE_IDX // Normal and tangent use same space
 #endif
     surfaceData.anisotropy *= ADD_IDX(_Anisotropy);
 
-    surfaceData.specular = 0.04;
+#ifdef _MATID_SPECULAR
+    // To save 1bit space in GBuffer we don't store specular as materialID but in the enum of the specular value
+    surfaceData.specular = SPECULARVALUE_SPECULAR_COLOR;
+#else
+    surfaceData.specular = SPECULARVALUE_REGULAR;
+#endif
 
     surfaceData.subsurfaceProfile = _SubsurfaceProfile;
     surfaceData.subsurfaceRadius  = _SubsurfaceRadius;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitProperties.hlsl

 
 float _Anisotropy;
 
-int   _MaterialID;
 int   _SubsurfaceProfile;
 float _SubsurfaceRadius;
 float _Thickness;

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

         [HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0)
         [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
 
-        [Enum(Subsurface Scattering, 0, Standard, 1, Specular Color, 2)] _MaterialID("MaterialId", Int) = 1 // MaterialId.LitStandard
+        // Note: 2 and 3 are currently unused
+        [Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 4, Specular Color, 5)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting
 
         [ToggleOff]  _EnablePerPixelDisplacement("Enable per pixel displacement", Float) = 0.0
         _PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _VERTEX_WIND
 
+    // MaterialId are used as shader feature to allow compiler to optimize properly
+    // Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD
+    #pragma shader_feature _ _MATID_SSS _MATID_ANISO _MATID_SPECULAR
+
     #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
     #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
     #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
     #include "../../../ShaderLibrary/Wind.hlsl"
     #include "../../../ShaderLibrary/tessellation.hlsl"
     #include "../../ShaderConfig.cs.hlsl"
-    #include "../../ShaderVariables.hlsl"
     #include "../../ShaderPass/FragInputs.hlsl"
     #include "../../ShaderPass/ShaderPass.cs.hlsl"
 
 
     SubShader
     {
-        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
-        LOD 300
-
         Pass
         {
             Name "GBuffer"  // Name is not used
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #include "LitData.hlsl"
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitSharePass.hlsl"
             #undef TESSELLATION_ON
 
             #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitMetaPass.hlsl"
             #include "LitData.hlsl"
 
             Cull[_CullMode]
 
+            ZClip Off
             ZWrite On
             ZTest LEqual
 
             #pragma domain Domain
 
-            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #define SHADERPASS SHADERPASS_SHADOWS
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDepthPass.hlsl"
             #include "LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_VELOCITY
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitVelocityPass.hlsl"
             #include "LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_DISTORTION
+            #include "../../ShaderVariables.hlsl"
             #include "../../Material/Material.hlsl"
             #include "ShaderPass/LitDistortionPass.hlsl"
             #include "LitData.hlsl"
             #pragma domain Domain
 
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
 
             #define DEBUG_DISPLAY
             #define SHADERPASS SHADERPASS_FORWARD
+            #include "../../ShaderVariables.hlsl"
             #include "../../Debug/DebugDisplay.hlsl"
             #include "../../Lighting/Forward.hlsl"
             // TEMP until pragma work in include

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader

 
             float  _WorldScales[SSS_N_PROFILES];                                         // Size of the world unit in meters
         #ifdef SSS_MODEL_DISNEY
-            float4x4 _ViewMatrix, _ProjMatrix;                                           // TEMP: make these global
             float  _FilterKernelsNearField[SSS_N_PROFILES][SSS_N_SAMPLES_NEAR_FIELD][2]; // 0 = radius, 1 = reciprocal of the PDF
             float  _FilterKernelsFarField[SSS_N_PROFILES][SSS_N_SAMPLES_FAR_FIELD][2];   // 0 = radius, 1 = reciprocal of the PDF
         #else
                     /* 'vec' is given relative to the tangent frame. */                         \
                     float3 relPosVS   = vec.x * tangentX + vec.y * tangentY;                    \
                     float3 positionVS = centerPosVS + relPosVS;                                 \
-                    float4 positionCS = mul(_ProjMatrix, float4(positionVS, 1));                \
-                    float2 positionSS = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;        \
+                    float4 positionCS = mul(projMatrix, float4(positionVS, 1));                 \
+                    float2 positionSS = ComputeScreenSpacePosition(positionCS);                 \
                                                                                                 \
                     position   = positionSS * _ScreenSize.xy;                                   \
                     irradiance = LOAD_TEXTURE2D(_IrradianceSource, position).rgb;               \
 
                 float3 unused;
 
+                // 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).
+                uint featureFlags = MATERIALFEATUREFLAGS_LIT_SSS;
+
-                DECODE_FROM_GBUFFER(gbuffer, 0xFFFFFFFF, bsdfData, unused);
+                DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, unused);
 
                 int    profileID   = bsdfData.subsurfaceProfile;
                 float  distScale   = bsdfData.subsurfaceRadius;
 
                 const bool useTangentPlane = SSS_USE_TANGENT_PLANE != 0;
 
+                float4x4 viewMatrix, projMatrix;
+                GetLeftHandedViewSpaceMatrices(viewMatrix, projMatrix);
+
-                float3 normalVS = mul((float3x3)_ViewMatrix, bsdfData.normalWS);
+                float3 normalVS = mul((float3x3)viewMatrix, bsdfData.normalWS);
                 float3 tangentX = GetLocalFrame(normalVS)[0] * unitsPerMm;
                 float3 tangentY = GetLocalFrame(normalVS)[1] * unitsPerMm;
 
                 [branch]
                 if (distScale == 0 || maxDistInPixels < 1)
                 {
-                    return float4(bsdfData.diffuseColor * sampleIrradiance, 1);
+                    #if SSS_DEBUG_LOD
+                        return float4(0, 0, 1, 1);
+                    #else
+                        return float4(bsdfData.diffuseColor * sampleIrradiance, 1);
+                    #endif
+                
+                #if SSS_DEBUG_LOD
+                    return float4(0.5, 0.5, 0, 1);
+                #endif
 
                 // Accumulate filtered irradiance and bilateral weights (for renormalization).
                 float3 totalIrradiance = sampleWeight * sampleIrradiance;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/PreIntegratedFGD.shader

             #include "../../../../ShaderLibrary/ImageBasedLighting.hlsl"
             #include "../../../ShaderVariables.hlsl"
 
-
-                float3 vertex : POSITION;
-                float2 texcoord : TEXCOORD0;
+                uint vertexID : SV_VertexID;
-                float4 vertex : SV_POSITION;
-                float2 texcoord : TEXCOORD0;
+                float4 positionCS : SV_POSITION;
+                float2 texCoord   : TEXCOORD0;
-                output.vertex = TransformWorldToHClip(input.vertex);
-                output.texcoord = input.texcoord.xy;
+
+                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+                output.texCoord   = GetFullScreenTriangleTexCoord(input.vertexID);
+
                 return output;
             }
 
-                float NdotV                 = input.texcoord.x;
-                float perceptualRoughness   = input.texcoord.y;
+                float NdotV                 = input.texCoord.x;
+                float perceptualRoughness   = input.texCoord.y;
                 float3 V                    = float3(sqrt(1 - NdotV * NdotV), 0, NdotV);
                 float3 N                    = float3(0.0, 0.0, 1.0);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

             }
             // <<< Old SSS Model
 
-            for (int i = 0; i < numProfiles; i++)
+            for (int i = 0; i < SssConstants.SSS_N_PROFILES - 1; i++)
-                // Skip unassigned profiles.
-                if (profiles[i] == null) continue;
+                // If a profile is null, it means that it was never set in the HDRenderPipeline Asset or that the profile asset has been deleted.
+                // In this case we want the users to be warned if a material uses one of those. This is why we fill the profile with pink transmission values.
+                if (i >= numProfiles || profiles[i] == null)
+                {
+                    // Pink transmission
+                    transmissionFlags |= (uint)1 << i * 2;
+                    transmissionTints[i] = new Vector4(100.0f, 0.0f, 100.0f, 1.0f);
+
+                    // Default neutral values for the rest
+                    worldScales[i] = 1.0f;
+                    shapeParams[i] = Vector4.zero;
+
+                    for (int j = 0, n = SssConstants.SSS_N_SAMPLES_NEAR_FIELD; j < n; j++)
+                    {
+                        filterKernelsNearField[2 * (n * i + j) + 0] = 0.0f;
+                        filterKernelsNearField[2 * (n * i + j) + 1] = 1.0f;
+                    }
+
+                    for (int j = 0, n = SssConstants.SSS_N_SAMPLES_FAR_FIELD; j < n; j++)
+                    {
+                        filterKernelsFarField[2 * (n * i + j) + 0] = 0.0f;
+                        filterKernelsFarField[2 * (n * i + j) + 1] = 1.0f;
+                    }
+
+                    // Old SSS Model >>>
+                    halfRcpWeightedVariances[i] = Vector4.one;
+
+                    for (int j = 0, n = SssConstants.SSS_BASIC_N_SAMPLES; j < n; j++)
+                    {
+                        filterKernelsBasic[n * i + j] = Vector4.one;
+                        filterKernelsBasic[n * i + j].w = 0.0f;
+                    }
+
+                    continue;
+                }
 
                 Debug.Assert(numProfiles < 16, "Transmission flags (32-bit integer) cannot support more than 16 profiles.");
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader

 
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 metal  // TEMP: until we go further in dev
+    // #pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
     // Variant
 
     SubShader
     {
-        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
-        LOD 300
-
         // Extracts information for lightmapping, GI (emission, albedo, ...)
         // This pass it not used during regular rendering.
         Pass

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawSssProfile.shader

             //-------------------------------------------------------------------------------------
 
             #include "../../../ShaderLibrary/Common.hlsl"
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
         #ifdef SSS_MODEL_BASIC
             #include "../../Material/Lit/SubsurfaceScatteringProfile.cs.hlsl"

Assets/ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Resources/DrawTransmittanceGraph.shader

 
             #include "../../../ShaderLibrary/CommonMaterial.hlsl"
             #include "../../../ShaderLibrary/Common.hlsl"
+            #define USE_LEGACY_UNITY_MATRIX_VARIABLES
             #include "../../ShaderVariables.hlsl"
 
             //-------------------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPass.cs

         DepthOnly,
         Velocity,
         Distortion,
-        LightTransport
+        LightTransport,
+        Shadows
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl

 #define SHADERPASS_VELOCITY (4)
 #define SHADERPASS_DISTORTION (5)
 #define SHADERPASS_LIGHT_TRANSPORT (6)
+#define SHADERPASS_SHADOWS (7)
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassDepthOnly.hlsl

-#if SHADERPASS != SHADERPASS_DEPTH_ONLY
+#if (SHADERPASS != SHADERPASS_DEPTH_ONLY && SHADERPASS != SHADERPASS_SHADOWS)
 #error SHADERPASS_is_not_correctly_define
 #endif
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 // As I haven't change the variables name yet, I simply don't define anything, and I put the transform function at the end of the file outside the guard header.
 // This need to be fixed.
 
-#define UNITY_MATRIX_M unity_ObjectToWorld
+#if defined (DIRECTIONAL_COOKIE) || defined (DIRECTIONAL)
+    #define USING_DIRECTIONAL_LIGHT
+#endif
-// These are updated per eye in VR
-#define UNITY_MATRIX_V unity_MatrixV
-#define UNITY_MATRIX_P glstate_matrix_projection
-#define UNITY_MATRIX_VP unity_MatrixVP
+#if defined(UNITY_SINGLE_PASS_STEREO) || defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+    #define USING_STEREO_MATRICES
+#endif
-#ifdef UNITY_SINGLE_PASS_STEREO
-    #define UNITY_MATRIX_MVP mul(unity_MatrixVP, unity_ObjectToWorld)
-#else
-    #define UNITY_MATRIX_MVP glstate_matrix_mvp
+#if defined(USING_STEREO_MATRICES)
+    #define glstate_matrix_projection unity_StereoMatrixP[unity_StereoEyeIndex]
+    #define unity_MatrixV unity_StereoMatrixV[unity_StereoEyeIndex]
+    #define unity_MatrixInvV unity_StereoMatrixInvV[unity_StereoEyeIndex]
+    #define unity_MatrixVP unity_StereoMatrixVP[unity_StereoEyeIndex]
+
+    #define unity_CameraProjection unity_StereoCameraProjection[unity_StereoEyeIndex]
+    #define unity_CameraInvProjection unity_StereoCameraInvProjection[unity_StereoEyeIndex]
+    #define unity_WorldToCamera unity_StereoWorldToCamera[unity_StereoEyeIndex]
+    #define unity_CameraToWorld unity_StereoCameraToWorld[unity_StereoEyeIndex]
+    #define _WorldSpaceCameraPos unity_StereoWorldSpaceCameraPos[unity_StereoEyeIndex]
-// These use the camera center position in VR
-#define UNITY_MATRIX_MV glstate_matrix_modelview0
-#define UNITY_MATRIX_T_MV glstate_matrix_transpose_modelview0
-#define UNITY_MATRIX_IT_MV glstate_matrix_invtrans_modelview0
-
+#define UNITY_LIGHTMODEL_AMBIENT (glstate_lightmodel_ambient * 2)
-
-// Time (t = time since current level load) values from Unity
-float4 _Time; // (t/20, t, t*2, t*3)
-float4 _SinTime; // sin(t/8), sin(t/4), sin(t/2), sin(t)
-float4 _CosTime; // cos(t/8), cos(t/4), cos(t/2), cos(t)
-float4 unity_DeltaTime; // dt, 1/dt, smoothdt, 1/smoothdt
+    // Time (t = time since current level load) values from Unity
+    float4 _Time; // (t/20, t, t*2, t*3)
+    float4 _SinTime; // sin(t/8), sin(t/4), sin(t/2), sin(t)
+    float4 _CosTime; // cos(t/8), cos(t/4), cos(t/2), cos(t)
+    float4 unity_DeltaTime; // dt, 1/dt, smoothdt, 1/smoothdt
-float3 _WorldSpaceCameraPos;
+    float3 _WorldSpaceCameraPos;
-// x = 1 or -1 (-1 if projection is flipped)
-// y = near plane
-// z = far plane
-// w = 1/far plane
-float4 _ProjectionParams;
+    // x = 1 or -1 (-1 if projection is flipped)
+    // y = near plane
+    // z = far plane
+    // w = 1/far plane
+    float4 _ProjectionParams;
-// x = width
-// y = height
-// z = 1 + 1.0/width
-// w = 1 + 1.0/height
-float4 _ScreenParams;
+    // x = width
+    // y = height
+    // z = 1 + 1.0/width
+    // w = 1 + 1.0/height
+    float4 _ScreenParams;
-// Values used to linearize the Z buffer (http://www.humus.name/temp/Linearize%20depth.txt)
-// x = 1-far/near
-// y = far/near
-// z = x/far
-// w = y/far
-float4 _ZBufferParams;
+    // Values used to linearize the Z buffer (http://www.humus.name/temp/Linearize%20depth.txt)
+    // x = 1-far/near
+    // y = far/near
+    // z = x/far
+    // w = y/far
+    // or in case of a reversed depth buffer (UNITY_REVERSED_Z is 1)
+    // x = -1+far/near
+    // y = 1
+    // z = x/far
+    // w = 1/far
+    float4 _ZBufferParams;
-// x = orthographic camera's width
-// y = orthographic camera's height
-// z = unused
-// w = 1.0 if camera is ortho, 0.0 if perspective
-float4 unity_OrthoParams;
+    // x = orthographic camera's width
+    // y = orthographic camera's height
+    // z = unused
+    // w = 1.0 if camera is ortho, 0.0 if perspective
+    float4 unity_OrthoParams;
-float4 unity_CameraWorldClipPlanes[6];
+    float4 unity_CameraWorldClipPlanes[6];
-// Projection matrices of the camera. Note that this might be different from projection matrix
-// that is set right now, e.g. while rendering shadows the matrices below are still the projection
-// of original camera.
-float4x4 unity_CameraProjection;
-float4x4 unity_CameraInvProjection;
-float4x4 unity_WorldToCamera;
-float4x4 unity_CameraToWorld;
+    // Projection matrices of the camera. Note that this might be different from projection matrix
+    // that is set right now, e.g. while rendering shadows the matrices below are still the projection
+    // of original camera.
+    float4x4 unity_CameraProjection;
+    float4x4 unity_CameraInvProjection;
+    float4x4 unity_WorldToCamera;
+    float4x4 unity_CameraToWorld;
 #endif
 CBUFFER_END
 
 
 #if defined(USING_STEREO_MATRICES)
 CBUFFER_START(UnityStereoGlobals)
-float4x4 unity_StereoMatrixP[2];
-float4x4 unity_StereoMatrixV[2];
-float4x4 unity_StereoMatrixInvV[2];
-float4x4 unity_StereoMatrixVP[2];
+    float4x4 unity_StereoMatrixP[2];
+    float4x4 unity_StereoMatrixV[2];
+    float4x4 unity_StereoMatrixInvV[2];
+    float4x4 unity_StereoMatrixVP[2];
-float4x4 unity_StereoCameraProjection[2];
-float4x4 unity_StereoCameraInvProjection[2];
-float4x4 unity_StereoWorldToCamera[2];
-float4x4 unity_StereoCameraToWorld[2];
+    float4x4 unity_StereoCameraProjection[2];
+    float4x4 unity_StereoCameraInvProjection[2];
+    float4x4 unity_StereoWorldToCamera[2];
+    float4x4 unity_StereoCameraToWorld[2];
-float3 unity_StereoWorldSpaceCameraPos[2];
-float4 unity_StereoScaleOffset[2];
+    float3 unity_StereoWorldSpaceCameraPos[2];
+    float4 unity_StereoScaleOffset[2];
+#endif
-#ifdef UNITY_SUPPORT_MULTIVIEW
-#define unity_StereoEyeIndex UNITY_VIEWID
-UNITY_DECLARE_MULTIVIEW(2);
-#else
-CBUFFER_START(UnityStereoEyeIndex)
-int unity_StereoEyeIndex;
+#if defined(USING_STEREO_MATRICES) && defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+CBUFFER_START(UnityStereoEyeIndices)
+    float4 unity_StereoEyeIndices[2];
+#if defined(UNITY_STEREO_MULTIVIEW_ENABLED) && defined(SHADER_STAGE_VERTEX)
+    #define unity_StereoEyeIndex UNITY_VIEWID
+    UNITY_DECLARE_MULTIVIEW(2);
+#elif defined(UNITY_STEREO_INSTANCING_ENABLED) || defined(UNITY_STEREO_MULTIVIEW_ENABLED)
+    static uint unity_StereoEyeIndex;
+#elif defined(UNITY_SINGLE_PASS_STEREO)
+    CBUFFER_START(UnityStereoEyeIndex)
+        int unity_StereoEyeIndex;
+    CBUFFER_END
-float4x4 glstate_matrix_transpose_modelview0;
+    float4x4 glstate_matrix_transpose_modelview0;
-
-
-float4 glstate_lightmodel_ambient;
-float4 unity_AmbientSky;
-float4 unity_AmbientEquator;
-float4 unity_AmbientGround;
-float4 unity_IndirectSpecColor;
+    float4 glstate_lightmodel_ambient;
+    float4 unity_AmbientSky;
+    float4 unity_AmbientEquator;
+    float4 unity_AmbientGround;
+    float4 unity_IndirectSpecColor;
-float4x4 glstate_matrix_projection;
-float4x4 unity_MatrixV;
-float4x4 unity_MatrixInvV;
-float4x4 unity_MatrixVP;
-int unity_StereoEyeIndex;
+    float4x4 glstate_matrix_projection;
+    float4x4 unity_MatrixV;
+    float4x4 unity_MatrixInvV;
+    float4x4 unity_MatrixVP;
+    float4 unity_StereoScaleOffset;
+    int unity_StereoEyeIndex;
-float4 unity_ShadowColor;
-
+    float4 unity_ShadowColor;
+
+// ----------------------------------------------------------------------------
 
 TEXTURE2D_FLOAT(_MainDepthTexture);
 SAMPLER2D(sampler_MainDepthTexture);
 // ----------------------------------------------------------------------------
 
 CBUFFER_START(UnityPerPass)
-float4   _ScreenSize;
-float4x4 _ViewProjMatrix; // Looks like using UNITY_MATRIX_VP in pixel shader doesn't work ??? need to setup my own...
+float4x4 _ViewProjMatrix;
+float4x4 _ViewMatrix;
+float4x4 _ProjMatrix;
+float4x4 _InvViewMatrix;
+float4   _ScreenSize;
-float4x4 GetWorldToViewMatrix()
-{
-    return UNITY_MATRIX_V;
-}
-
-float4x4 GetObjectToWorldMatrix()
-{
-    return unity_ObjectToWorld;
-}
-
-float4x4 GetWorldToObjectMatrix()
-{
-    return unity_WorldToObject;
-}
-
-// Transform to homogenous clip space
-float4x4 GetWorldToHClipMatrix()
-{
-    return UNITY_MATRIX_VP;
-}
-
-float GetOddNegativeScale()
-{
-    return unity_WorldTransformParams.w;
-}
-
-float3 TransformWorldToView(float3 positionWS)
-{
-    return mul(GetWorldToViewMatrix(), float4(positionWS, 1.0)).xyz;
-}
-
-float3 TransformObjectToWorld(float3 positionOS)
-{
-    return mul(GetObjectToWorldMatrix(), float4(positionOS, 1.0)).xyz;
-}
-
-float3 TransformWorldToObject(float3 positionWS)
-{
-    return mul(GetWorldToObjectMatrix(), float4(positionWS, 1.0)).xyz;
-}
-
-float3 TransformObjectToWorldDir(float3 dirOS)
-{
-    // Normalize to support uniform scaling
-    return normalize(mul((float3x3)GetObjectToWorldMatrix(), dirOS));
-}
-
-float3 TransformWorldToObjectDir(float3 dirWS)
-{
-    // Normalize to support uniform scaling
-    return normalize(mul((float3x3)GetWorldToObjectMatrix(), dirWS));
-}
-
-// Transforms normal from object to world space
-float3 TransformObjectToWorldNormal(float3 normalOS)
-{
-#ifdef UNITY_ASSUME_UNIFORM_SCALING
-    return UnityObjectToWorldDir(normalOS);
+#ifdef USE_LEGACY_UNITY_MATRIX_VARIABLES
+    #include "ShaderVariablesMatrixDefsLegacyUnity.hlsl"
-    // Normal need to be multiply by inverse transpose
-    // mul(IT_M, norm) => mul(norm, I_M) => {dot(norm, I_M.col0), dot(norm, I_M.col1), dot(norm, I_M.col2)}
-    return normalize(mul(normalOS, (float3x3)GetWorldToObjectMatrix()));
+    #include "ShaderVariablesMatrixDefsHDCamera.hlsl"
-}
-// Tranforms position from world space to homogenous space
-float4 TransformWorldToHClip(float3 positionWS)
-{
-    return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
-}
+#include "ShaderVariablesFunctions.hlsl"
-float3 GetCurrentCameraPosition()
-{
-#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_DEPTH_ONLY)
-    return _WorldSpaceCameraPos;
-#else
-    // TEMP: this is rather expensive. Then again, we need '_WorldSpaceCameraPos'
-    // to represent the position of the primary (scene view) camera in order to
-    // have identical tessellation levels for both the scene view and shadow views.
-    // Otherwise, depth comparisons become meaningless!
-    float4x4 trViewMat = transpose(GetWorldToViewMatrix());
-    float3   rotCamPos = trViewMat[3].xyz;
-   return mul((float3x3)trViewMat, -rotCamPos);
-#endif
-}
-
-// Returns the forward direction of the current camera in the world space.
-float3 GetCameraForwardDir()
-{
-    float4x4 viewMat = GetWorldToViewMatrix();
-    return -viewMat[2].xyz;
-}
-
-// Returns 'true' if the current camera performs a perspective projection.
-bool IsPerspectiveCamera()
-{
-#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_DEPTH_ONLY)
-    return (unity_OrthoParams.w == 0);
-#else
-    // TODO: set 'unity_OrthoParams' during the shadow pass.
-    return (GetWorldToHClipMatrix()[3].x != 0 ||
-            GetWorldToHClipMatrix()[3].y != 0 ||
-            GetWorldToHClipMatrix()[3].z != 0 ||
-            GetWorldToHClipMatrix()[3].w != 1);
-#endif
-}
-
-// Computes the world space view direction (pointing towards the camera).
-float3 GetWorldSpaceNormalizeViewDir(float3 positionWS)
-{
-    if (IsPerspectiveCamera())
-    {
-        // Perspective
-        float3 V = GetCurrentCameraPosition() - positionWS;
-        return normalize(V);
-    }
-    else
-    {
-        // Orthographic
-        return -GetCameraForwardDir();
-    }
-}
-
-float3x3 CreateWorldToTangent(float3 normal, float3 tangent, float flipSign)
-{
-    // For odd-negative scale transforms we need to flip the sign
-    float sgn = flipSign * GetOddNegativeScale();
-    float3 bitangent = cross(normal, tangent) * sgn;
-
-    return float3x3(tangent, bitangent, normal);
-}
-
-float3 TransformTangentToWorld(float3 dirTS, float3x3 worldToTangent)
-{
-    // Use transpose transformation to go from tangent to world as the matrix is orthogonal
-    return mul(dirTS, worldToTangent);
-}
-
-float3 TransformWorldToTangent(float3 dirWS, float3x3 worldToTangent)
-{
-    return mul(worldToTangent, dirWS);
-}
-
-float3 TransformTangentToObject(float3 dirTS, float3x3 worldToTangent)
-{
-    // Use transpose transformation to go from tangent to world as the matrix is orthogonal
-    float3 normalWS = mul(dirTS, worldToTangent);
-    return mul((float3x3)unity_WorldToObject, normalWS);
-}
-
-float3 TransformObjectToTangent(float3 dirOS, float3x3 worldToTangent)
-{
-    return mul(worldToTangent, TransformObjectToWorldDir(dirOS));
-}
 #endif // UNITY_SHADER_VARIABLES_INCLUDED

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/BlitCubemap.shader

                 v2f o;
 
                 o.vertex = GetFullScreenTriangleVertexPosition(v.vertexID);
-                float2 uv = GetFullScreenTriangleTexcoord(v.vertexID) * 2.0 - 1.0;
+                float2 uv = GetFullScreenTriangleTexCoord(v.vertexID) * 2.0 - 1.0;
 
                 int idx = (int)_faceIndex;
                 float3 transformU = faceU[idx];

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/GGXConvolve.shader

             ZWrite Off
             ZTest Always
             Blend One Zero
+            Cull Off
 
             HLSLPROGRAM
             #pragma target 4.5
             Varyings Vert(Attributes input)
             {
                 Varyings output;
-                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                // Unity renders upside down, so the clip space coordinates have to be flipped.
+                output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
                 output.eyeVector = input.eyeVector;
                 return output;
             }
             float _LastLevel;
             float _InvOmegaP;
 
-            half4 Frag(Varyings input) : SV_Target
+            float4 Frag(Varyings input) : SV_Target
             {
                 // Vector interpolation is not magnitude-preserving.
                 float3 N = normalize(input.eyeVector);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

             m_SkyHDRIMaterial.SetTexture("_Cubemap", m_HdriSkyParams.skyHDRI);
             m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));
 
-            var cmd = new CommandBuffer { name = "" };
+            var cmd = CommandBufferPool.Get("");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         public override bool IsSkyValid()

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

     {
         // TODO: implement SV_vertexID full screen quad
         Varyings output;
-        output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+        // Unity renders upside down, so the clip space coordinates have to be flipped.
+        output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
         output.eyeVector = input.eyeVector;
 
         return output;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

             // Since we use the material for rendering the sky both into the cubemap, and
             // during the fullscreen pass, setting the 'PERFORM_SKY_OCCLUSION_TEST' keyword has no effect.
             properties.SetFloat("_DisableSkyOcclusionTest", renderForCubemap ? 1.0f : 0.0f);
-            // We flip the screens-space Y axis in case we follow the D3D convention.
-            properties.SetFloat("_FlipY",                   renderForCubemap ? 1.0f : 0.0f);
             // We do not render the height fog into the sky IBL cubemap.
             properties.SetFloat("_HeightRayleighDensity",   renderForCubemap ? -0.0f : -param.heightRayleighDensity / 100000f);
             properties.SetFloat("_HeightMieDensity",        renderForCubemap ? -0.0f : -param.heightMieDensity / 100000f);
             // Set shader constants.
             SetUniforms(builtinParams, m_ProceduralSkySettings, renderForCubemap, ref properties);
 
-            var cmd = new CommandBuffer { name = "" };
-
+            var cmd = CommandBufferPool.Get("");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
+
         }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

 
             float _DisableSkyOcclusionTest;
 
-            float _FlipY;
-
             #define IS_RENDERING_SKY
             #include "AtmosphericScattering.hlsl"
 
             {
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
-                output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
+                // Unity renders upside down, so the clip space coordinates have to be flipped.
+                output.positionCS = float4(input.positionCS.x, -input.positionCS.y, UNITY_RAW_FAR_CLIP_VALUE, 1.0);
                 output.eyeVector  = input.eyeVector;
 
                 return output;
                 }
 
                 // Since we only need the world space position, so we don't pass the view-projection matrix.
-                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput, _FlipY != 0);
+                UpdatePositionInput(depthRaw, _InvViewProjMatrix, k_identity4x4, posInput);
 
                 float4 c1, c2, c3;
                 VolundTransferScatter(posInput.positionWS, c1, c2, c3);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/RuntimeFilterIBL.cs

 
                 m_ComputeGgxIblSampleDataCS.SetTexture(m_ComputeGgxIblSampleDataKernel, "output", m_GgxIblSampleData);
 
-                var cmd = new CommandBuffer() { name = "Compute GGX IBL Sample Data" };
+                var cmd = CommandBufferPool.Get("Compute GGX IBL Sample Data");
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
         }
 
                 {
                     Utilities.SetRenderTarget(context, target, ClearFlag.ClearNone, mip, (CubemapFace)face);
 
-                    var cmd = new CommandBuffer { name = "" };
+                    var cmd = CommandBufferPool.Get();
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
                 }
             }
         }
 
             int numRows = conditionalCdf.height;
 
-            var cmd = new CommandBuffer() { name = "Build Probability Tables" };
+            var cmd = CommandBufferPool.Get("Build Probability Tables");
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
 
             m_GgxConvolveMaterial.EnableKeyword("USE_MIS");
             m_GgxConvolveMaterial.SetTexture("_ConditionalDensities", conditionalCdf);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

 
         public Texture skyReflection { get { return m_SkyboxGGXCubemapRT; } }
 
-        protected Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix, bool forceUVBottom)
+        protected Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix)
-            Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 1.0f, 1.0f);
-            Vector4 vertData1 = new Vector4(1.0f, -1.0f, 1.0f, 1.0f);
-            Vector4 vertData2 = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
-            Vector4 vertData3 = new Vector4(-1.0f, 1.0f, 1.0f, 1.0f);
+            // These are clip space coords.
+            Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 0.0f, 1.0f);
+            Vector4 vertData1 = new Vector4( 1.0f, -1.0f, 0.0f, 1.0f);
+            Vector4 vertData2 = new Vector4( 1.0f,  1.0f, 0.0f, 1.0f);
+            Vector4 vertData3 = new Vector4(-1.0f,  1.0f, 0.0f, 1.0f);
 
             Vector3[] vertData = new Vector3[4];
             vertData[0] = new Vector3(vertData0.x, vertData0.y, vertData0.z);
             Vector4 direction2 = (posWorldSpace2 / posWorldSpace2.w - cameraPos);
             Vector4 direction3 = (posWorldSpace3 / posWorldSpace3.w - cameraPos);
 
-            if (SystemInfo.graphicsUVStartsAtTop && !forceUVBottom)
+            if (SystemInfo.graphicsUVStartsAtTop)
             {
                 eyeVectorData[3] = new Vector3(direction0.x, direction0.y, direction0.z).normalized;
                 eyeVectorData[2] = new Vector3(direction1.x, direction1.y, direction1.z).normalized;
                     m_faceCameraViewProjectionMatrix[i] = Utilities.GetViewProjectionMatrix(lookAt, cubeProj);
                     m_faceCameraInvViewProjectionMatrix[i] = m_faceCameraViewProjectionMatrix[i].inverse;
 
-                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i], true);
+                    m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i]);
                 }
             }
         }
             for (int i = 0; i < 6; ++i)
             {
                 Utilities.SetRenderTarget(renderContext, dest, ClearFlag.ClearNone, 0, (CubemapFace)i);
-                var cmd = new CommandBuffer { name = "" };
+                var cmd = CommandBufferPool.Get();
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
             }
 
         }
                 }
 
                 // Copy the first mip
-                var cmd = new CommandBuffer { name = "" };
+                var cmd = CommandBufferPool.Get();
-                cmd.Dispose();
+                
 
                 if (m_useMIS && m_iblFilterGgx.SupportMIS)
                 {
                 {
                     m_iblFilterGgx.FilterCubemap(renderContext, input, target, mipCount, m_CubemapFaceMesh);
                 }
+                CommandBufferPool.Release(cmd);
             }
         }
 
                 {
                     m_BuiltinParameters.renderContext = renderContext;
                     m_BuiltinParameters.sunLight = sunLight;
-                    m_BuiltinParameters.invViewProjMatrix = camera.invViewProjectionMatrix;
+                    m_BuiltinParameters.invViewProjMatrix = camera.viewProjMatrix.inverse;
-                    m_BuiltinParameters.skyMesh = BuildSkyMesh(camera.camera.GetComponent<Transform>().position, m_BuiltinParameters.invViewProjMatrix, false);
+                    m_BuiltinParameters.skyMesh = BuildSkyMesh(camera.camera.GetComponent<Transform>().position, m_BuiltinParameters.invViewProjMatrix);
                     m_BuiltinParameters.colorBuffer = colorBuffer;
                     m_BuiltinParameters.depthBuffer = depthBuffer;
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkySettingsSingleton.cs

-#if UNITY_EDITOR
-using UnityEditor;
-#endif
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class SkySettingsSingleton : Singleton<SkySettingsSingleton>

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

 
         public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier buffer, ClearFlag clearFlag = ClearFlag.ClearNone, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
 
         public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
         {
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer)
 
         public static void SetRenderTarget(ScriptableRenderContext renderContext, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor)
         {
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
-            cmd.Dispose();
+            
-            var cmd = new CommandBuffer();
+            var cmd = CommandBufferPool.Get();
             cmd.name = "";
 
             for(int i = 0 ; i < 6 ; ++i)
 
             renderContext.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            CommandBufferPool.Release(cmd);
         }
 
         // Miscellanous
             return sb.ToString();
         }
 
-        public class ProfilingSample
+        public struct ProfilingSample
-            bool        disposed = false;
+            bool        disposed;
             ScriptableRenderContext  renderContext;
             string      name;
 
+                disposed = false;
-                CommandBuffer cmd = new CommandBuffer();
+                CommandBuffer cmd = CommandBufferPool.Get();
-                cmd.Dispose();
-            }
-
-            ~ProfilingSample()
-            {
-                Dispose(false);
+                CommandBufferPool.Release(cmd);
-
+            
             public void Dispose()
             {
                 Dispose(true);
-            protected virtual void Dispose(bool disposing)
+            void Dispose(bool disposing)
             {
                 if (disposed)
                     return;
-                    CommandBuffer cmd = new CommandBuffer();
+                    CommandBuffer cmd = CommandBufferPool.Get();
-                    cmd.Dispose();
+                    CommandBufferPool.Release(cmd);
                 }
 
                 disposed = true;
         }
 
         // TEMP: These functions should be implemented C++ side, for now do it in C#
+        static List<float> m_FloatListdata = new List<float>();
-            var data = new float[16];
+            m_FloatListdata.Clear();
-                    data[4 * c + r] = mat[r, c];
+                    m_FloatListdata.Add(mat[r, c]);
-            cmd.SetComputeFloatParams(shadercs, name, data);
+            cmd.SetComputeFloatParams(shadercs, name, m_FloatListdata);
-            var data = new float[numMatrices * 16];
+            m_FloatListdata.Clear();
+            
-                        data[16 * n + 4 * c + r] = matArray[n][r, c];
+                        m_FloatListdata.Add(matArray[n][r, c]);
-            cmd.SetComputeFloatParams(shadercs, name, data);
+            cmd.SetComputeFloatParams(shadercs, name, m_FloatListdata);
-            var data = new float[numVectors * 4];
+            m_FloatListdata.Clear();
-                    data[4 * n + i] = vecArray[n][i];
+                    m_FloatListdata.Add(vecArray[n][i]);
-            cmd.SetComputeFloatParams(shadercs, name, data);
+            cmd.SetComputeFloatParams(shadercs, name, m_FloatListdata);
         }
 
         public static void SetKeyword(Material m, string keyword, bool state)
         }
 
         // Draws a full screen triangle as a faster alternative to drawing a full screen quad.
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            camera.SetupMaterial(material);
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            camera.SetupMaterial(material);
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
-            camera.SetupMaterial(material);
             commandBuffer.SetRenderTarget(colorBuffers, depthStencilBuffer);
             commandBuffer.DrawProcedural(Matrix4x4.identity, material, shaderPassID, MeshTopology.Triangles, 3, 1, properties);
         }
-        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material, HDCamera camera,
+        public static void DrawFullScreen(CommandBuffer commandBuffer, Material material,
             RenderTargetIdentifier[] colorBuffers,
             MaterialPropertyBlock properties = null, int shaderPassID = 0)
         {
             // no depth target ends up being bound.
-            DrawFullScreen(commandBuffer, material, camera, colorBuffers, colorBuffers[0], properties, shaderPassID);
+            DrawFullScreen(commandBuffer, material, colorBuffers, colorBuffers[0], properties, shaderPassID);
         }
 
         // Helper to help to display debug info on screen

Assets/ScriptableRenderPipeline/LightweightPipeline.meta

 fileFormatVersion: 2
-guid: 7a2706b41ea31e54d9e4ca93be22278a
+guid: 4923a4700d4d643a9a862a74e04870b3
 folderAsset: yes
 timeCreated: 1481548458
 licenseType: Pro

Assets/ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

 
             public static GUIContent shadowDistante = new GUIContent("Shadow Distance", "Max shadow drawing distance");
 
-            public static GUIContent shadowMinBias = new GUIContent("Shadow Min Normal Bias Offset", "Minimum value of normal bias offset applied");
-            public static GUIContent shadowBias = new GUIContent("Shadow Normal Bias", "Normal bias offset value.");
-
             public static GUIContent shadowAtlasResolution = new GUIContent("Shadow Map Resolution",
                     "Resolution of shadow map texture. If cascades are enabled all cascades will be packed into this texture resolution.");
 
             EditorGUILayout.PropertyField(m_ShadowTypeProp, Styles.shadowType);
             EditorGUILayout.PropertyField(m_ShadowAtlasResolutionProp, Styles.shadowAtlasResolution);
             EditorGUILayout.PropertyField(m_ShadowNearPlaneOffsetProp, Styles.shadowNearPlaneOffset);
-            EditorGUILayout.PropertyField(m_ShadowMinNormalBiasProperty, Styles.shadowMinBias);
-            EditorGUILayout.PropertyField(m_ShadowNormalBiasProperty, Styles.shadowBias);
             EditorGUILayout.PropertyField(m_ShadowDistanceProp, Styles.shadowDistante);
             EditorGUILayout.PropertyField(m_ShadowCascadesProp, Styles.shadowCascades);
 

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

     {
         public int pixelLightsCount;
         public int vertexLightsCount;
+        public int shadowLightIndex;
+        public bool shadowsRendered;
     }
 
     public class LightweightPipeline : RenderPipeline
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
         private int m_ShadowMapProperty;
-        private int m_ShadowLightIndex = -1;
-        private int m_DepthBufferBits = 24;
+        private int m_DepthBufferBits = 16;
         private Vector4[] m_DirectionalShadowSplitDistances = new Vector4[kMaxCascades];
 
         private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
             }
         }
 
+        CullResults m_CullResults;
         public override void Render(ScriptableRenderContext context, Camera[] cameras)
         {
             base.Render(context, cameras);
                 if (!CullResults.GetCullingParameters(camera, out cullingParameters))
                     continue;
 
-                cullingParameters.shadowDistance = m_ShadowSettings.maxShadowDistance;
-                CullResults cullResults = CullResults.Cull(ref cullingParameters, context);
+                cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance, camera.farClipPlane);
+                CullResults.Cull(ref cullingParameters, context,ref m_CullResults);
-                VisibleLight[] visibleLights = cullResults.visibleLights;
+                VisibleLight[] visibleLights = m_CullResults.visibleLights.ToArray();
-                bool shadowsRendered = false;
-                InitializeMainShadowLightIndex(visibleLights);
-                if (m_ShadowLightIndex > -1)
-                    shadowsRendered = RenderShadows(ref cullResults, ref visibleLights[m_ShadowLightIndex], ref context);
+                if (lightData.shadowLightIndex > -1) 
+                    lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
 
                 // Setup camera matrices and RT
                 context.SetupCameraProperties(camera);
-                var cmd = new CommandBuffer() { name = "Clear" };
+                var cmd = CommandBufferPool.Get("Clear");
-                cmd.Dispose();
+                CommandBufferPool.Release(cmd);
-                SetupLightShaderVariables(visibleLights, ref cullResults, ref context, ref lightData);
-                if (shadowsRendered)
-                    SetupShadowShaderVariables(ref context, m_ShadowCasterCascadesCount);
+                SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
+                if (lightData.shadowsRendered)
+                    SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
+                SetShaderKeywords(ref lightData, ref context);
 
                 RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes;
                 if (m_Asset.EnableLightmap)
                     configuration |= RendererConfiguration.ProvideLightIndices;
 
                 // Render Opaques
-                var litSettings = new DrawRendererSettings(cullResults, camera, m_LitPassName);
+                var litSettings = new DrawRendererSettings(m_CullResults, camera, m_LitPassName);
-                var unlitSettings = new DrawRendererSettings(cullResults, camera, m_UnlitPassName);
+                var unlitSettings = new DrawRendererSettings(m_CullResults, camera, m_UnlitPassName);
                 unlitSettings.sorting.flags = SortFlags.CommonOpaque;
                 unlitSettings.inputFilter.SetQueuesOpaque();
 
-                var discardRT = new CommandBuffer();
+                var discardRT = CommandBufferPool.Get();
-                discardRT.Dispose();
+                CommandBufferPool.Release(cmd);
 
                 context.DrawRenderers(ref unlitSettings);
 
             lightData.pixelLightsCount = Mathf.Min(lightsCount, m_Asset.MaxSupportedPixelLights);
             lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Mathf.Min(lightsCount - lightData.pixelLightsCount, kMaxVertexLights) : 0;
             lightData.isSingleDirectionalLight = lightData.pixelLightsCount == 1 && lightData.vertexLightsCount == 0 && lights[0].lightType == LightType.Directional;
+
+            // Directional light path can handle unlit.
+            if (lightsCount == 0)
+                lightData.isSingleDirectionalLight = true;
+            
+            lightData.shadowsRendered = false;
+
+            InitializeMainShadowLightIndex(lights, out lightData.shadowLightIndex);
         }
 
         private void FillLightIndices(ref CullResults cullResults, int visibleLightsCount)
             cullResults.FillLightIndices(m_LightIndexListBuffer);
         }
 
-        private void SetupLightShaderVariables(VisibleLight[] lights, ref CullResults cullResults, ref ScriptableRenderContext context, ref LightData lightData)
+        private void SetupShaderLightConstants(VisibleLight[] lights, ref LightData lightData, ref CullResults cullResults, ref ScriptableRenderContext context)
+        {
+            if (lights.Length == 0)
+                return;
+
+            if (lightData.isSingleDirectionalLight) 
+                SetupShaderSingleDirectionalLightConstants(ref lights [0], ref context);
+            else
+                SetupShaderLightListConstants(lights, lightData.pixelLightsCount, ref cullResults, ref context);
+        }
+
+        private void SetupShaderSingleDirectionalLightConstants(ref VisibleLight light, ref ScriptableRenderContext context)
-            int maxLights = 1;
-            if (!lightData.isSingleDirectionalLight)
-            {
-                FillLightIndices(ref cullResults, lights.Length);
-                maxLights = Math.Min(kMaxVisibleLights, lights.Length);
-            }
+            Vector4 lightDir = -light.localToWorld.GetColumn(2);
+             
+            CommandBuffer cmd = new CommandBuffer() { name = "SetupLightConstants" };
+            cmd.SetGlobalVector("_LightPosition0", new Vector4(lightDir.x, lightDir.y, lightDir.z, 0.0f));
+            cmd.SetGlobalColor("_LightColor0", light.finalColor);
+            context.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        // TODO: Perform tests on light lights memory pattern access (SOA vs AOS vs Swizzling)
+        private void SetupShaderLightListConstants(VisibleLight[] lights, int pixelLightsCount, ref CullResults cullResults, ref ScriptableRenderContext context)
+        {
+            FillLightIndices(ref cullResults, lights.Length);
+            int maxLights = Math.Min(kMaxVisibleLights, lights.Length);
-            for (int i = 0; i < maxLights; ++i)
+            for (int i = 0; i < maxLights; ++i) 
-                VisibleLight currLight = lights[i];
-                if (currLight.lightType == LightType.Directional)
+                VisibleLight currLight = lights [i];
+                if (currLight.lightType == LightType.Directional) 
-                    Vector4 dir = -currLight.localToWorld.GetColumn(2);
-                    m_LightPositions[i] = new Vector4(dir.x, dir.y, dir.z, 0.0f);
-                }
-                else
+                    Vector4 dir = -currLight.localToWorld.GetColumn (2);
+                    m_LightPositions [i] = new Vector4 (dir.x, dir.y, dir.z, 0.0f);
+                } 
+                else 
-                    Vector4 pos = currLight.localToWorld.GetColumn(3);
-                    m_LightPositions[i] = new Vector4(pos.x, pos.y, pos.z, 1.0f);
+                    Vector4 pos = currLight.localToWorld.GetColumn (3);
+                    m_LightPositions [i] = new Vector4 (pos.x, pos.y, pos.z, 1.0f);
                 }
 
                 m_LightColors[i] = currLight.finalColor;
 
-                if (currLight.lightType == LightType.Spot)
+                if (currLight.lightType == LightType.Spot) 
-                    Vector4 dir = currLight.localToWorld.GetColumn(2);
-                    m_LightSpotDirections[i] = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f);
+                    Vector4 dir = currLight.localToWorld.GetColumn (2);
+                    m_LightSpotDirections [i] = new Vector4 (-dir.x, -dir.y, -dir.z, 0.0f);
-                    float cosOuterAngle = Mathf.Cos(spotAngle * 0.5f);
-                    float cosInneAngle = Mathf.Cos(spotAngle * 0.25f);
+                    float cosOuterAngle = Mathf.Cos (spotAngle * 0.5f);
+                    float cosInneAngle = Mathf.Cos (spotAngle * 0.25f);
-                    m_LightAttenuations[i] = new Vector4(cosOuterAngle,
-                            Mathf.Approximately(angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
-                }
+                    m_LightAttenuations [i] = new Vector4 (cosOuterAngle,
+                        Mathf.Approximately (angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
+                } 
-                    m_LightSpotDirections[i] = new Vector4(0.0f, 0.0f, 1.0f, 0.0f) ;
-                    m_LightAttenuations[i] = new Vector4(-1.0f, 1.0f, quadAtten, rangeSq);
+                    m_LightSpotDirections [i] = new Vector4 (0.0f, 0.0f, 1.0f, 0.0f);
+                    m_LightAttenuations [i] = new Vector4 (-1.0f, 1.0f, quadAtten, rangeSq);
-            CommandBuffer cmd = new CommandBuffer() {name = "SetupShadowShaderConstants"};
-            cmd.SetGlobalVectorArray("globalLightPos", m_LightPositions);
-            cmd.SetGlobalVectorArray("globalLightColor", m_LightColors);
-            cmd.SetGlobalVectorArray("globalLightAtten", m_LightAttenuations);
-            cmd.SetGlobalVectorArray("globalLightSpotDir", m_LightSpotDirections);
-            if (!lightData.isSingleDirectionalLight)
-                cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
-            cmd.SetGlobalVector("globalLightData", new Vector4(lightData.pixelLightsCount, m_ShadowLightIndex, m_Asset.ShadowMinNormalBias, m_Asset.ShadowNormalBias));
-            SetShaderKeywords(cmd, lightData.isSingleDirectionalLight, lightData.vertexLightsCount > 0);
+            CommandBuffer cmd = CommandBufferPool.Get("SetupShadowShaderConstants");
+            cmd.SetGlobalVector("globalLightCount", new Vector4 (pixelLightsCount, 0.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVectorArray ("globalLightPos", m_LightPositions);
+            cmd.SetGlobalVectorArray ("globalLightColor", m_LightColors);
+            cmd.SetGlobalVectorArray ("globalLightAtten", m_LightAttenuations);
+            cmd.SetGlobalVectorArray ("globalLightSpotDir", m_LightSpotDirections);
+            cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        private void SetShaderKeywords(ref LightData lightData, ref ScriptableRenderContext context)
+        {
+            CommandBuffer cmd = new CommandBuffer() { name = "SetShaderKeywords" };
+            SetShaderKeywords(cmd, lightData.shadowsRendered, lightData.isSingleDirectionalLight, lightData.vertexLightsCount > 0);
-        private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, ref ScriptableRenderContext context)
+        private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
         {
             m_ShadowCasterCascadesCount = m_ShadowSettings.directionalLightCascadeCount;
 
             int shadowResolution = GetMaxTileResolutionInAtlas(m_ShadowSettings.shadowAtlasWidth, m_ShadowSettings.shadowAtlasHeight, m_ShadowCasterCascadesCount);
 
             Bounds bounds;
-            if (!cullResults.GetShadowCasterBounds(m_ShadowLightIndex, out bounds))
+            if (!cullResults.GetShadowCasterBounds(shadowLightIndex, out bounds))
-            var setRenderTargetCommandBuffer = new CommandBuffer();
+            var setRenderTargetCommandBuffer = CommandBufferPool.Get();
             setRenderTargetCommandBuffer.name = "Render packed shadows";
             setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapProperty, m_ShadowSettings.shadowAtlasWidth,
                 m_ShadowSettings.shadowAtlasHeight, m_DepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth,
             context.ExecuteCommandBuffer(setRenderTargetCommandBuffer);
-            setRenderTargetCommandBuffer.Dispose();
+            CommandBufferPool.Release(setRenderTargetCommandBuffer);
-            Vector3 lightDir = Vector3.Normalize(shadowLight.light.transform.forward);
-            var settings = new DrawShadowsSettings(cullResults, m_ShadowLightIndex);
+            var settings = new DrawShadowsSettings(cullResults, shadowLightIndex);
-                needRendering = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(m_ShadowLightIndex, out view, out proj,
+                needRendering = cullResults.ComputeSpotShadowMatricesAndCullingPrimitives(shadowLightIndex, out view, out proj,
                         out settings.splitData);
 
                 if (!needRendering)
-                RenderShadowSlice(ref context, lightDir, 0, proj, view, settings);
+                RenderShadowSlice(ref context, 0, proj, view, settings);
-                    needRendering = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(m_ShadowLightIndex,
+                    needRendering = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
                             cascadeIdx, m_ShadowCasterCascadesCount, splitRatio, shadowResolution, shadowNearPlane, out view, out proj,
                             out settings.splitData);
 
                         return false;
 
                     SetupShadowSliceTransform(cascadeIdx, shadowResolution, proj, view);
-                    RenderShadowSlice(ref context, lightDir, cascadeIdx, proj, view, settings);
+                    RenderShadowSlice(ref context, cascadeIdx, proj, view, settings);
                 }
             }
             else
             m_ShadowSlices[cascadeIndex].shadowTransform = matTile * matScaleBias * proj * view;
         }
 
-        private void RenderShadowSlice(ref ScriptableRenderContext context, Vector3 lightDir, int cascadeIndex,
+        private void RenderShadowSlice(ref ScriptableRenderContext context, int cascadeIndex,
-            var buffer = new CommandBuffer() {name = "Prepare Shadowmap Slice"};
+            var buffer = CommandBufferPool.Get("Prepare Shadowmap Slice");
-            buffer.Dispose();
+            CommandBufferPool.Release(buffer);
         }
 
         private int GetMaxTileResolutionInAtlas(int atlasWidth, int atlasHeight, int tileCount)
             return resolution;
         }
 
-        private void SetupShadowShaderVariables(ref ScriptableRenderContext context, int cascadeCount)
+        private void SetupShadowShaderConstants(ref ScriptableRenderContext context, ref VisibleLight shadowLight, int shadowLightIndex, int cascadeCount)
+            Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
+
+            // TODO: multiplying by 0.1 to get similar results to Unity vanilla shadow bias
+            float bias = shadowLight.light.shadowBias * 0.1f;
+            float normalBias = shadowLight.light.shadowNormalBias;
             float shadowResolution = m_ShadowSlices[0].shadowResolution;
 
             const int maxShadowCascades = 4;
                 0.5f * invShadowResolution, -0.5f * invShadowResolution
             };
 
-            var setupShadow = new CommandBuffer() {name = "SetupShadowShaderConstants"};
+            var setupShadow = CommandBufferPool.Get("SetupShadowShaderConstants");
+            setupShadow.SetGlobalVector("_ShadowLightDirection", new Vector4(-shadowLightDir.x, -shadowLightDir.y, -shadowLightDir.z, 0.0f));
+            setupShadow.SetGlobalVector("_ShadowData", new Vector4(shadowLightIndex, bias, normalBias, 0.0f));
-            setupShadow.Dispose();
+            CommandBufferPool.Release(setupShadow);
-        private void SetShaderKeywords(CommandBuffer cmd, bool singleDirecitonal, bool vertexLightSupport)
+        private void SetShaderKeywords(CommandBuffer cmd, bool renderShadows, bool singleDirecitonal, bool vertexLightSupport)
         {
             if (vertexLightSupport)
                 cmd.EnableShaderKeyword("_VERTEX_LIGHTS");
             for (int i = 0; i < shadowKeywords.Length; ++i)
                 cmd.DisableShaderKeyword(shadowKeywords[i]);
 
-            if (m_ShadowLightIndex != -1 && m_Asset.CurrShadowType != ShadowType.NO_SHADOW)
+            if (renderShadows && m_Asset.CurrShadowType != ShadowType.NO_SHADOW)
             {
                 int keywordIndex = (int)m_Asset.CurrShadowType - 1;
                 if (m_Asset.CascadeCount > 1)
                 cmd.DisableShaderKeyword("_LIGHT_PROBES_ON");
         }
 
-        private void InitializeMainShadowLightIndex(VisibleLight[] lights)
+        private void InitializeMainShadowLightIndex(VisibleLight[] lights, out int shadowIndex)
-            m_ShadowLightIndex = -1;
+            shadowIndex = -1;
             float maxIntensity = -1;
             for (int i = 0; i < lights.Length; ++i)
             {
-                    m_ShadowLightIndex = i;
+                    shadowIndex = i;
                     maxIntensity = light.intensity;
                 }
             }
         {
             return (type == LightType.Directional || type == LightType.Spot);
         }
-
     }
 }

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_ShadowAtlasResolution: 1024
   m_ShadowNearPlaneOffset: 2
   m_ShadowDistance: 50
-  m_MinShadowNormalBias: 0.0005
-  m_ShadowNormalBias: 0.05
   m_ShadowCascades: 1
   m_Cascade2Split: 0.25
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         private static readonly string m_AssetName = "LightweightPipelineAsset.asset";
 
 #if UNITY_EDITOR
-        [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset")]
+        [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset", false, 15)]
         static void CreateLightweightPipeline()
         {
             var instance = ScriptableObject.CreateInstance<LightweightPipelineAsset>();
         [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
         [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
         [SerializeField] private float m_ShadowDistance = 50.0f;
-        [SerializeField] private float m_MinShadowNormalBias = 0.0005f;
-        [SerializeField] private float m_ShadowNormalBias = 0.05f;
         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.NO_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
             private set { m_ShadowDistance = value; }
         }
 
-		public float ShadowMinNormalBias
-        {
-            get { return m_MinShadowNormalBias; }
-            private set { m_MinShadowNormalBias = value; }
-        }
-
-        public float ShadowNormalBias
-        {
-            get { return m_ShadowNormalBias; }
-            private set { m_ShadowNormalBias = value; }
-        }
-
-
+       
         public float Cascade2Split
         {
             get { return m_Cascade2Split; }

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader

 
 #if defined(_VERTEX_LIGHTS) && !defined(_SINGLE_DIRECTIONAL_LIGHT)
                 half4 diffuseAndSpecular = half4(1.0, 1.0, 1.0, 1.0);
-                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightData.x;
-                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightData.x);
+                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightCount.x;
+                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightCount.x);
-                    half NdotL;
-                    o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz, NdotL);
+                    o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz);
                 }
 #endif
 
 
                 half3 viewDir = i.viewDir.xyz;
 
-                half3 color = half3(0, 0, 0);
-                LightInput lightData;
-                INITIALIZE_LIGHT(lightData, 0);
-                half  NdotL;
-                color = EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL);
+                half3 color = EvaluateDirectionalLight(diffuse, specularGloss, normal, _LightPosition0, viewDir) * _LightColor0;
-                float bias = max(globalLightData.z, (1.0 - NdotL) * globalLightData.w);
-                color *= ComputeShadowAttenuation(i, bias);
+                color *= ComputeShadowAttenuation(i, _LightPosition0.xyz);
-                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightData.x, unity_LightIndicesOffsetAndCount.y);
+                half3 color = half3(0, 0, 0);
+#ifdef _SHADOWS
+                half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
+#endif
+                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                    half NdotL;
-                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir, NdotL);
-                    if (lightIndex == globalLightData.y)
-                    {
-                        float bias = max(globalLightData.z, (1.0 - NdotL) * globalLightData.w);
-                        color *= ComputeShadowAttenuation(i, bias);
-                    }
+                    // multiplies shadowAttenuation to avoid branching.
+                    // step will only evaluate to 1 when lightIndex == _ShadowData.x (shadowLightIndex)
+                    half currLightAttenuation = shadowAttenuation * step(abs(lightIndex - _ShadowData.x), 0);
+                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir) * currLightAttenuation;
+#else
+                    color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir);
 #endif
                 }
 
 
             float4 vert(float4 pos : POSITION) : SV_POSITION
             {
-            	float4 clipPos = UnityObjectToClipPos(pos);
+                float4 clipPos = UnityObjectToClipPos(pos);
 #if defined(UNITY_REVERSED_Z)
                 clipPos.z = min(clipPos.z, UNITY_NEAR_CLIP_VALUE);
 #else

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc

     float4 hpos : SV_POSITION;
 };
 
+// Per object light list data
+#ifndef _SINGLE_DIRECTIONAL_LIGHT
+half4 unity_LightIndicesOffsetAndCount;
+StructuredBuffer<uint> globalLightIndexList;
+
+half4 globalLightCount;
-float4  globalLightData; // x: pixelLightCount, y = shadowLightIndex, z = minShadowNormalBiasOffset, w = shadowNormalBiasOffset
-
-// Per object light list data
-#ifndef _SINGLE_DIRECTIONAL_LIGHT
-half4 unity_LightIndicesOffsetAndCount;
-StructuredBuffer<uint> globalLightIndexList;
+#else
+float4 _LightPosition0;
 #endif
 
 half _Shininess;
 #endif
 }
 
-inline half3 EvaluateOneLight(LightInput lightInput, half3 diffuseColor, half4 specularGloss, half3 normal, float3 posWorld, half3 viewDir, out half NdotL)
+inline half3 EvaluateDirectionalLight(half3 diffuseColor, half4 specularGloss, half3 normal, half3 lightDir, half3 viewDir)
+{
+    half NdotL = saturate(dot(normal, lightDir));
+    half3 diffuse = diffuseColor * NdotL;
+
+#if defined(_SPECGLOSSMAP_BASE_ALPHA) || defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR) 
+    half3 halfVec = normalize(lightDir + viewDir);
+    half NdotH = saturate(dot(normal, halfVec));
+    half3 specular = specularGloss.rgb * pow(NdotH, _Shininess * 128.0) * specularGloss.a;
+    return diffuse + specular;
+#else
+    return diffuse;
+#endif
+}
+
+inline half3 EvaluateOneLight(LightInput lightInput, half3 diffuseColor, half4 specularGloss, half3 normal, float3 posWorld, half3 viewDir)
 {
     float3 posToLight = lightInput.pos.xyz;
     posToLight -= posWorld * lightInput.pos.w;
     half cutoff = step(distanceSqr, lightInput.atten.w);
     lightAtten *= cutoff;
 
-    NdotL = saturate(dot(normal, lightDir));
-
-    half3 halfVec = normalize(lightDir + viewDir);
-    half NdotH = saturate(dot(normal, halfVec));
+    half NdotL = saturate(dot(normal, lightDir));
+    half3 halfVec = normalize(lightDir + viewDir);
+    half NdotH = saturate(dot(normal, halfVec));
     half3 specular = specularGloss.rgb * lightColor * pow(NdotH, _Shininess * 128.0) * specularGloss.a;
     return diffuse + specular;
 #else

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineShadows.cginc

 float _PCFKernel[8];
 float4x4 _WorldToShadow[MAX_SHADOW_CASCADES];
 float4 _DirShadowSplitSpheres[MAX_SHADOW_CASCADES];
+half4 _ShadowData;
+
+// In case of single directional light, shadow light dir is the same of light dir
+#ifndef _SINGLE_DIRECTIONAL_LIGHT
+half4 _ShadowLightDirection;
+#endif
 
 inline half ShadowAttenuation(float3 shadowCoord)
 {
     float depth = tex2D(_ShadowMap, shadowCoord).r;
+
-    return step(depth, shadowCoord.z);
+    return step(depth - _ShadowData.y, shadowCoord.z);
-    return step(shadowCoord.z, depth);
+    return step(shadowCoord.z, depth + _ShadowData.y);
 #endif
 }
 
     return attenuation * 0.25;
 }
 
-inline half ComputeShadowAttenuation(v2f i, float bias)
+inline half ComputeShadowAttenuation(v2f i, half3 shadowDir)
-    float3 vertexNormal = float3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
+    half3 vertexNormal = half3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
-    float3 vertexNormal = i.normal;
+    half3 vertexNormal = i.normal;
-    float3 offset = vertexNormal * bias;
+
+    half NdotL = dot(vertexNormal, shadowDir);
+    half bias = saturate(1.0 - NdotL) * _ShadowData.z;
+
+    float3 posWorldOffsetNormal = i.posWS + vertexNormal * bias;
-    float3 posWorldOffsetNormal = i.posWS + offset;
-
-    cascadeIndex = ComputeCascadeIndex(i.posWS);
+    cascadeIndex = ComputeCascadeIndex(posWorldOffsetNormal);
     if (cascadeIndex >= MAX_SHADOW_CASCADES)
         return 1.0;
 #endif

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

     return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
 }
 
+// Ref: https://twitter.com/SebAaltonen/status/878250919879639040
+// 2 mads (mad_sat and mad), faster than regular sign
+float3 FastSign(float x)
+{
+    return  saturate(x * FLT_MAX) * 2.0 - 1.0;
+}
+
 // ----------------------------------------------------------------------------
 // Texture utilities
 // ----------------------------------------------------------------------------
     posInput.positionWS = positionWS;
 }
 
+float4 ComputeClipSpacePosition(float2 positionSS, float depthRaw)
+{
+#if UNITY_UV_STARTS_AT_TOP
+    positionSS.y = 1.0 - positionSS.y;
+#endif
+    return float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
+}
+
+float2 ComputeScreenSpacePosition(float4 positionCS)
+{
+    float2 positionSS = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;
+#if UNITY_UV_STARTS_AT_TOP
+    positionSS.y = 1.0 - positionSS.y;
+#endif
+    return positionSS;
+}
+
-void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix,
-                         inout PositionInputs posInput, bool flipY = false)
+void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
-    float2 screenSpacePos;
-    screenSpacePos.x = posInput.positionSS.x;
-    screenSpacePos.y = flipY ? 1.0 - posInput.positionSS.y : posInput.positionSS.y;
-
-    float4 positionCS   = float4(screenSpacePos * 2.0 - 1.0, depthRaw, 1.0);
+    float4 positionCS   = ComputeClipSpacePosition(posInput.positionSS, depthRaw);
     float4 hpositionWS  = mul(invViewProjMatrix, positionCS);
     posInput.positionWS = hpositionWS.xyz / hpositionWS.w;
 
 
 // It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
 // of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix, bool flipY = false)
+float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
-    float2 screenSpacePos;
-    screenSpacePos.x = positionSS.x;
-    screenSpacePos.y = flipY ? 1.0 - positionSS.y : positionSS.y;
-
-    float4 positionCS = float4(screenSpacePos * 2.0 - 1.0, depthRaw, 1.0);
+    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
     float4 positionVS = mul(invProjMatrix, positionCS);
     // The view space uses a right-handed coordinate system.
     positionVS.z = -positionVS.z;
 
 // Generates a triangle in homogeneous clip space, s.t.
 // v0 = (-1, -1, 1), v1 = (3, -1, 1), v2 = (-1, 3, 1).
-float2 GetFullScreenTriangleTexcoord(uint vertexID)
+float2 GetFullScreenTriangleTexCoord(uint vertexID)
 {
 #if UNITY_UV_STARTS_AT_TOP
     return float2((vertexID << 1) & 2, 1.0 - (vertexID & 2));

Assets/ScriptableRenderPipeline/ShaderLibrary/Packing.hlsl

     if (index == 2) quat = quat.xywz;
 
     float4 packedQuat;
-    packedQuat.xyz = quat.xyz * sign(quat.w) * sqrt(0.5) + 0.5;
+    packedQuat.xyz = quat.xyz * FastSign(quat.w) * sqrt(0.5) + 0.5;
     packedQuat.w = index / 3.0;
 
     return packedQuat;
     float t2 = (precision / maxi) / precisionMinusOne;
 
     // extract integer part
-    i = int(val / t2);
+    i = int((val / t2) + rcp(precisionMinusOne)); // + rcp(precisionMinusOne) to deal with precision issue (can't use round() as val contain the floating number
-    f = (-t2 * float(i) + val) / t1;
+    f = saturate((-t2 * float(i) + val) / t1); // Saturate in case of precision issue
-    return PackFloatInt(f, i, maxi, 255.0);
+    return PackFloatInt(f, i, maxi, 256.0);
-    UnpackFloatInt(val, maxi, 255.0, f, i);
+    UnpackFloatInt(val, maxi, 256.0, f, i);
 }
 
 float PackFloatInt10bit(float f, int i, float maxi)

Assets/TestScenes/FPTL/FPTL.unity

 %YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
 --- !u!29 &1
-SceneSettings:
+OcclusionCullingSettings:
-  m_PVSData: 
-  m_PVSObjectsArray: []
-  m_PVSPortalsArray: []
+  serializedVersion: 2
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
-  serializedVersion: 7
+  serializedVersion: 8
   m_Fog: 0
   m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
   m_FogMode: 3
   m_AmbientSkyColor: {r: 0, g: 0, b: 0, a: 1}
   m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
   m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
-  m_AmbientIntensity: 0
+  m_AmbientIntensity: 1
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
   m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
   m_HaloStrength: 0.5
   m_FlareStrength: 1
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 7
+  serializedVersion: 11
   m_GIWorkflowMode: 1
   m_GISettings:
     serializedVersion: 2
     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 4
+    serializedVersion: 9
     m_Resolution: 2
     m_BakeResolution: 40
     m_TextureWidth: 1024
     m_LightmapParameters: {fileID: 0}
     m_LightmapsBakeMode: 1
     m_TextureCompression: 1
-    m_DirectLightInLightProbes: 1
+    m_MixedBakeMode: 1
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 0
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
-  m_RuntimeCPUUsage: 25
+  m_UseShadowmask: 0
 --- !u!196 &4
 NavMeshSettings:
   serializedVersion: 2
     minRegionArea: 2
     manualCellSize: 0
     cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    debug:
+      m_Flags: 0
   m_NavMeshData: {fileID: 0}
 --- !u!1 &344719374
 GameObject:
   m_GameObject: {fileID: 550164696}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
-  shadowResolution: 976
-  innerSpotPercent: 77
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.2
+  - 0.3
+  shadowAlgorithm: 0
+  shadowVariant: 1
+  shadowPrecision: 0
+  shadowData:
+    format: 1
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 0
+    data: 0bd7a33b0000803f
+  - format: 1
+    data: 0bd7a33b0000803f
 --- !u!108 &550164698
 Light:
   m_ObjectHideFlags: 0
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 0
   m_Color: {r: 0.8455882, g: 0.42901167, b: 0.42901167, a: 1}
   m_Intensity: 1.5
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 0
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &550164699
   m_GameObject: {fileID: 756999128}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
-  shadowResolution: 955
-  innerSpotPercent: 66.4
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.2
+  - 0.3
+  shadowAlgorithm: 0
+  shadowVariant: 1
+  shadowPrecision: 0
+  shadowData:
+    format: 1
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 0
+    data: 0bd7a33b0000803f
+  - format: 1
+    data: 0bd7a33b0000803f
 --- !u!108 &756999130
 Light:
   m_ObjectHideFlags: 0
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 2
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 2.41
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 0
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &756999131
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &942239536
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1064871614
 MeshCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1090653690
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1100543301
 SphereCollider:
   m_GameObject: {fileID: 1403765353}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
-  shadowResolution: 955
-  innerSpotPercent: 66.4
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.2
+  - 0.3
+  shadowAlgorithm: 0
+  shadowVariant: 1
+  shadowPrecision: 0
+  shadowData:
+    format: 1
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 0
+    data: 0bd7a33b0000803f
+  - format: 1
+    data: 0bd7a33b0000803f
 --- !u!108 &1403765355
 Light:
   m_ObjectHideFlags: 0
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 0
   m_Color: {r: 1, g: 1, b: 1, a: 1}
   m_Intensity: 1.94
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 0
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1403765356
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1409545157
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1469174315
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1506796424
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1597621868
 SphereCollider:
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1713034008}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &1713034010
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetDisplay: 0
   m_TargetEye: 3
   m_HDR: 0
+  m_AllowMSAA: 1
+  m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1758207074
 SphereCollider:
   m_GameObject: {fileID: 1810843056}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
-  shadowResolution: 955
-  innerSpotPercent: 66.4
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.2
+  - 0.3
+  shadowAlgorithm: 0
+  shadowVariant: 1
+  shadowPrecision: 0
+  shadowData:
+    format: 1
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 0
+    data: 0bd7a33b0000803f
+  - format: 1
+    data: 0bd7a33b0000803f
 --- !u!108 &1810843058
 Light:
   m_ObjectHideFlags: 0
   m_Enabled: 1
-  serializedVersion: 7
+  serializedVersion: 8
   m_Type: 1
   m_Color: {r: 1, g: 0.98096883, b: 0.8382353, a: 1}
   m_Intensity: 0.65
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 0
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1810843059
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1818419757
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1946201411
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &2054101902
 SphereCollider:
   m_Enabled: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_SelectedWireframeHidden: 0
+  m_StitchSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &2136471013
 SphereCollider:

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonNormalOS.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: DragonNormalOS
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _DOUBLESIDEDENABLE_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
-    _ENABLEWIND_OFF _NORMALMAP
+  m_ShaderKeywords: _NORMALMAP
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonNormalTS.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: DragonNormalTS
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DISTORTIONDEPTHTEST_OFF
-    _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _DOUBLESIDEDENABLE_OFF _ENABLEPERPIXELDISPLACEMENT_OFF
-    _ENABLEWIND_OFF _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_ShaderKeywords: _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatue.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: DragonStatue
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
-    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _EMISSION _ENABLEPERPIXELDISPLACEMENT_OFF
-    _HEIGHTMAP _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _TESSELLATION_DISPLACEMENT
-    _TESSELLATION_OBJECT_SCALE
+  m_ShaderKeywords: _HEIGHTMAP _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 2800000, guid: ad9cb02bddceb1340bc1fcb19d5f35bd, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Dragon/DragonStatueSpecular.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: DragonStatueSpecular
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DEPTHOFFSETENABLE_OFF _DETAIL_MAP_WITH_NORMAL
-    _DISTORTIONDEPTHTEST_OFF _DISTORTIONENABLE_OFF _DISTORTIONONLY_OFF _EMISSION _ENABLEPERPIXELDISPLACEMENT_OFF
-    _HEIGHTMAP _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _SPECULARCOLORMAP _TESSELLATION_DISPLACEMENT
-    _TESSELLATION_OBJECT_SCALE
+  m_ShaderKeywords: _HEIGHTMAP _MASKMAP _MATID_SPECULAR _NORMALMAP _NORMALMAP_TANGENT_SPACE
+    _SPECULARCOLORMAP
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _HeightCenter: 0
     - _HorizonFade: 1
     - _InitialBend: 1
-    - _MaterialID: 2
+    - _MaterialID: 5
     - _Metallic: 0
     - _Mode: 0
     - _NormalDetailMul: 0.347

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Blue.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Green.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_Red.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE _SPECULAROCCLUSIONMAP
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Lit_White.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_0.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_1.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_2.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_3.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_4.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_5.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_6.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_7.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_8.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth0_9.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smooth1_1.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_0.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_1.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_2.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_3.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_4.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_5.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_6.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_7.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_8.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric0_9.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1

Assets/TestScenes/HDTest/GraphicTest/Common/Material/Mat_smoothdielectric1_0.mat

   m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _OcclusionMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - _ThicknessMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
     - _DoubleSidedEnable: 0
     - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1