HDRenderPipeline: Minor reformat

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

                     LayeredLitGUI.SynchronizeAllLayers(mat);
                     EditorUtility.SetDirty(mat);
                 }
-                }
+        }
 
         static void RemoveMaterialKeywords(Material material)
         {

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             }
             else
             {
-            using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
-            {
-                m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
-            }
+                using (new Utilities.ProfilingSample("Shadow Pass", renderContext))
+                {
+                    m_ShadowPass.Render(renderContext, cullResults, out m_ShadowsResult);
+                }
-            renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
+                renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
-            if (m_LightLoop != null)
-            {
-                using (new Utilities.ProfilingSample("Build Light list", renderContext))
+                if (m_LightLoop != null)
-                    m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
-                    m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
+                    using (new Utilities.ProfilingSample("Build Light list", renderContext))
+                    {
+                        m_LightLoop.PrepareLightsForGPU(m_Owner.shadowSettings, cullResults, camera, ref m_ShadowsResult);
+                        m_LightLoop.BuildGPULightLists(camera, renderContext, m_CameraDepthStencilBufferRT); // TODO: Use async compute here to run light culling during shadow
+                    }
-            }
-            PushGlobalParams(hdCamera, renderContext, m_Owner.sssParameters);
+                PushGlobalParams(hdCamera, renderContext, m_Owner.sssParameters);
-            // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
-            // must be call after BuildGPULightLists.
-            // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
-            UpdateSkyEnvironment(hdCamera, renderContext);
+                // Caution: We require sun light here as some sky use the sun light to render, mean UpdateSkyEnvironment
+                // must be call after BuildGPULightLists.
+                // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
+                UpdateSkyEnvironment(hdCamera, renderContext);
-            RenderDeferredLighting(hdCamera, renderContext, m_Owner.sssParameters.enableSSS);
+                RenderDeferredLighting(hdCamera, renderContext, m_Owner.sssParameters.enableSSS);
-            // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
-            // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
-            // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
-            CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssParameters);
+                // We compute subsurface scattering here. Therefore, no objects rendered afterwards will exhibit SSS.
+                // Currently, there is no efficient way to switch between SRT and MRT for the forward pass;
+                // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
+                CombineSubsurfaceScattering(hdCamera, renderContext, m_Owner.sssParameters);
-            // 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);
+                // 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);
-            // 'm_CameraDepthStencilBufferCopyRT' is a temporary copy of the depth textureand should be removed
-            // once we are able to read from the depth buffer during transparent pass.
-            using (new Utilities.ProfilingSample("Copy depth-stencil buffer after all opaque", renderContext))
-            {
-                var cmd = new CommandBuffer();
-                cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
-                renderContext.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
-            }
+                // 'm_CameraDepthStencilBufferCopyRT' is a temporary copy of the depth texture and should be removed
+                // once we are able to read from the depth buffer during transparent pass.
+                using (new Utilities.ProfilingSample("Copy depth-stencil buffer after all opaque", renderContext))
+                {
+                    var cmd = new CommandBuffer();
+                    cmd.CopyTexture(m_CameraDepthStencilBufferRT, m_CameraDepthStencilBufferCopyRT);
+                    renderContext.ExecuteCommandBuffer(cmd);
+                    cmd.Dispose();
+                }
-            RenderSky(hdCamera, renderContext);
+                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);
+                // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
+                RenderForward(cullResults, camera, renderContext, false);
-            RenderVelocity(cullResults, camera, 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(cullResults, camera, 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 ?
-            // TODO: Check with VFX team.
-            // Rendering distortion here have off course lot of artifact.
-            // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
-            // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness. This
-            RenderDistortion(cullResults, camera, renderContext);
+                // TODO: Check with VFX team.
+                // Rendering distortion here have off course lot of artifact.
+                // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
+                // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness. This
+                RenderDistortion(cullResults, camera, renderContext);
-            FinalPass(camera, renderContext);
+                FinalPass(camera, renderContext);
             }
 
             RenderDebugOverlay(camera, renderContext);

Assets/TestScenes/HDTest/CascadedShadowsTest.unity

     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 6
+    serializedVersion: 8
     m_Resolution: 2
     m_BakeResolution: 40
     m_TextureWidth: 1024
     m_FinalGatherFiltering: 1
     m_FinalGatherRayCount: 256
     m_ReflectionCompression: 2
-    m_StationaryBakeMode: 3
+    m_MixedBakeMode: 3
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFiltering: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousColorSigma: 1
+    m_PVRFilteringAtrousNormalSigma: 1
+    m_PVRFilteringAtrousPositionSigma: 1
-  m_RuntimeCPUUsage: 25
   m_ShadowMaskMode: 2
 --- !u!196 &4
 NavMeshSettings:
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  m_CCT: 6500
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &1612942797
   m_Name: 
   m_EditorClassIdentifier: 
   shadowResolution: 1024
+  m_innerSpotPercent: 0
   shadowDimmer: 1
   affectDiffuse: 1
   affectSpecular: 1
   m_Script: {fileID: 11500000, guid: bc357c46587fc9d4cb8f311794d7d2f3, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_SkyRendererTypeName: UnityEngine.Experimental.ScriptableRenderLoop.HDRISkyRenderer
-  m_ShadowMaxDistance: 1000
-  m_ShadowCascadeCount: 4
-  m_ShadowCascadeSplit0: 0.015
-  m_ShadowCascadeSplit1: 0.05
-  m_ShadowCascadeSplit2: 0.15
+  m_Settings:
+    m_ShadowMaxDistance: 1000
+    m_ShadowCascadeCount: 4
+    m_ShadowCascadeSplit0: 0.05
+    m_ShadowCascadeSplit1: 0.2
+    m_ShadowCascadeSplit2: 0.3
+    m_ShadowNearPlaneOffset: 5
 --- !u!4 &2100643540
 Transform:
   m_ObjectHideFlags: 0

Assets/TestScenes/HDTest/CascadedShadowsTest/Lit_Gray.mat

         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+        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}
         m_Offset: {x: 0, y: 0}
     - _DistortionDepthTest: 0
     - _DistortionEnable: 0
     - _DistortionOnly: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
     - _DoubleSidedMode: 0
     - _DstBlend: 0
     - _EmissiveColorMode: 1
     - _GlossyReflections: 1
     - _HeightAmplitude: 0.01
     - _HeightCenter: 0.5
+    - _HorizonFade: 1
-    - _StencilRef: 1
+    - _PPDLodThreshold: 5
     - _PPDMaxSamples: 15
     - _PPDMinSamples: 5
     - _Parallax: 0.02
     - _SrcBlend: 1
+    - _StencilRef: 2
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _Thickness: 1
     - _UVBase: 0
     - _UVDetail: 0
     - _UVMappingPlanar: 0
     m_Colors:
     - _BaseColor: {r: 0.49803922, g: 0.49803922, b: 0.49803922, a: 1}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}