Merged with master

ImageTemplates/HDRenderPipeline/Scenes/0002-Subsurface scattering.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/010_MultiplePointLights.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/001_SimpleCube.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

SampleScenes/HDTest/HDRenderLoopTest.meta

 fileFormatVersion: 2
-guid: 030c34355b9969e4e9185afe200a7b9c
+guid: 20e3062ec69d14f509c2a7cbed456672
-timeCreated: 1504524294
+timeCreated: 1504605821
 licenseType: Pro
 DefaultImporter:
   externalObjects: {}

SampleScenes/HDTest/HDRenderLoopTest/ReflectionProbe-0.exr.meta

 fileFormatVersion: 2
-guid: 8a71c17fe204c99479b1bae8ef21b003
-timeCreated: 1504524398
+guid: fd5ff1bb67a644142931db2be2b44571
+timeCreated: 1504606082
 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Rendering Settings
             public readonly GUIContent renderingSettingsLabel = new GUIContent("Rendering Settings");
             public readonly GUIContent useForwardRenderingOnly = new GUIContent("Use Forward Rendering Only");
-            public readonly GUIContent useDepthPrepass = new GUIContent("Use Depth Prepass");
+            public readonly GUIContent useDepthPrepassWithDeferredRendering = new GUIContent("Use Depth Prepass with Deferred rendering");
 
             // Texture Settings
             public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
 
             // Rendering settings
             m_RenderingUseForwardOnly = FindProperty(x => x.renderingSettings.useForwardRenderingOnly);
-            m_RenderingUseDepthPrepass = FindProperty(x => x.renderingSettings.useDepthPrepass);
+            m_RenderingUseDepthPrepass = FindProperty(x => x.renderingSettings.useDepthPrepassWithDeferredRendering);
 
             // Subsurface Scattering Settings
             // Old SSS Model >>>
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(styles.renderingSettingsLabel);
             EditorGUI.indentLevel++;
-            EditorGUI.BeginChangeCheck();
-            EditorGUILayout.PropertyField(m_RenderingUseDepthPrepass, styles.useDepthPrepass);
-
-            if (EditorGUI.EndChangeCheck())
+            if (!m_RenderingUseForwardOnly.boolValue) // If we are deferred
-                if (m_RenderingUseForwardOnly.boolValue && !m_RenderingUseDepthPrepass.boolValue)
-                {
-                    // Force depth prepass for forward-only rendering (for FPTL, etc).
-                    m_RenderingUseDepthPrepass.boolValue = true;
-                    HackSetDirty(renderContext); // Repaint
-                }
+                EditorGUILayout.PropertyField(m_RenderingUseDepthPrepass, styles.useDepthPrepassWithDeferredRendering);
+
             EditorGUI.indentLevel--;
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 using System;
 using System.Linq;
     public class RenderingSettings
     {
         public bool useForwardRenderingOnly = false; // TODO: Currently there is no way to strip the extra forward shaders generated by the shaders compiler, so we can switch dynamically.
-        public bool useDepthPrepass = false;
+        public bool useDepthPrepassWithDeferredRendering = false;
 
         // We have to fall back to forward-only rendering when scene view is using wireframe rendering mode --
         // as rendering everything in wireframe + deferred do not play well together
 
         Material m_CameraMotionVectorsMaterial;
 
+        // Debug material
+#if UNITY_EDITOR
+        Material m_ErrorMaterial;
+#endif
 
         // Various buffer
         readonly int m_CameraColorBuffer;
             m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugViewMaterialGBufferShader);
             m_DebugDisplayLatlong = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugDisplayLatlongShader);
             m_DebugFullScreen = Utilities.CreateEngineMaterial(m_Asset.renderPipelineResources.debugFullScreenShader);
+#if UNITY_EDITOR
+            m_ErrorMaterial = Utilities.CreateEngineMaterial("Hidden/InternalErrorShader");
+#endif
         }
 
         public void CreateSssMaterials(bool useDisneySSS)
 
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
             Utilities.Destroy(m_DebugDisplayLatlong);
+            Utilities.Destroy(m_DebugFullScreen);
+#if UNITY_EDITOR
+            Utilities.Destroy(m_ErrorMaterial);
+#endif
 
             m_SkyManager.Cleanup();
 
 #if UNITY_EDITOR
             SupportedRenderingFeatures.active = s_NeededFeatures;
 #endif
+            // HD use specific GraphicsSettings. This is init here.
+            // TODO: This should not be set at each Frame but is there another place for these config setup ?
+            GraphicsSettings.lightsUseLinearIntensity = true;
+            GraphicsSettings.lightsUseColorTemperature = true;
 
             if (m_FrameCount != Time.frameCount)
             {
-
-            GraphicsSettings.lightsUseLinearIntensity = true;
-            GraphicsSettings.lightsUseColorTemperature = true;
 
             // This is the main command buffer used for the frame.
             CommandBuffer cmd = CommandBufferPool.Get("");
             ApplyDebugDisplaySettings();
             UpdateCommonSettings();
 
-            // Set Frame constant buffer
-            // TODO...
-
             // we only want to render one camera for now
             // select the most main camera!
 
                 return;
             }
 
-            // Set camera constant buffer
-            // TODO...
-
             ScriptableCullingParameters cullingParams;
             if (!CullResults.GetCullingParameters(camera, out cullingParams))
             {
 
             m_LightLoop.UpdateCullingParameters( ref cullingParams );
-          
-            // emit scene view UI
+                      
+            // emit scene view UI
+            {
+            }
 #endif
 
             CullResults.Cull(ref cullingParams, renderContext,ref m_CullResults);
             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
+                // It is up to the users to only send unlit object for this camera path
-                using (new Utilities.ProfilingSample(passName, cmd))
+                using (new Utilities.ProfilingSample("Forward", cmd))
-                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, passName);
-                    RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, passName);
+                    ShaderPassName[] arrayShaderPassName = { HDShaderPassNames.m_ForwardName };
+                    RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, arrayShaderPassName);
+                    RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, arrayShaderPassName);
                 }
 
                 renderContext.ExecuteCommandBuffer(cmd);
 
             RenderDepthPrepass(m_CullResults, camera, renderContext, cmd);
 
-            // Forward opaque with deferred/cluster tile require that we fill the depth buffer
-            // correctly to build the light list.
-            RenderForwardOnlyOpaqueDepthPrepass(m_CullResults, camera, renderContext, cmd);
             RenderGBuffer(m_CullResults, camera, renderContext, cmd);
 
             // If full forward rendering, we did not do any rendering yet, so don't need to copy the buffer.
             {
                 using (new Utilities.ProfilingSample("Build Light list and render shadows", cmd))
                 {
-                    // TODO: Everything here (SSAO, Shadow, Build light list, material and light classification can be parallelize with Async compute)
+                    // TODO: Everything here (SSAO, Shadow, Build light list, deffered shadow, material and light classification can be parallelize with Async compute)
                     m_SsaoEffect.Render(ssaoSettingsToUse, this, hdCamera, renderContext, cmd, m_Asset.renderingSettings.useForwardRenderingOnly);
                     m_LightLoop.PrepareLightsForGPU(m_ShadowSettings, m_CullResults, camera);
                     m_LightLoop.RenderShadows(renderContext, cmd, m_CullResults);
                 // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
                 SubsurfaceScatteringPass(hdCamera, cmd, m_Asset.sssSettings);
 
-                // 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(m_CullResults, camera, renderContext, cmd, true); // Render deferred or forward opaque
-                RenderForwardOnlyOpaque(m_CullResults, camera, renderContext, cmd);
+                RenderForward(m_CullResults, camera, renderContext, cmd, true);
+#if UNITY_EDITOR
+                RenderForwardError(m_CullResults, camera, renderContext, cmd, true);
+#endif
 
                 RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT, m_DebugDisplaySettings);
 
 
                 // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                 RenderForward(m_CullResults, camera, renderContext, cmd, false);
-
+#if UNITY_EDITOR
+                RenderForwardError(m_CullResults, camera, renderContext, cmd, false);
+#endif
-
-                // Render fog.
-                VolumetricLightingPass(cmd, hdCamera);
+		//
+                // Render volumetric lighting
+                VolumetricLightingPass(hdCamera, cmd);
 
                 PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, camera, renderContext, FullScreenDebugMode.NanTracker);
 
             DebugOverlay.Render(hdCamera, cmd);
             /// SampleGame Change END
 
+#if UNITY_EDITOR
+#endif
 
             renderContext.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
-        private static Material m_ErrorMaterial;
-        private static Material errorMaterial
+        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
-            get
-            {
-                if (m_ErrorMaterial == null)
-                    m_ErrorMaterial = new Material(Shader.Find("Hidden/InternalErrorShader"));
-                return m_ErrorMaterial;
-            }
+            RenderOpaqueRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, overrideMaterial);
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderOpaqueRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName[] passNames, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
         {
             if (!m_DebugDisplaySettings.renderingDebugSettings.displayOpaqueObjects)
                 return;
             cmd.Clear();
 
-            var drawSettings = new DrawRendererSettings(camera, new ShaderPassName(passName))
+            var drawSettings = new DrawRendererSettings(camera, HDShaderPassNames.s_EmptyName)
-            drawSettings.SetShaderPassName(1, new ShaderPassName("SRPDefaultUnlit"));
+
+            for (int i = 0; i < passNames.Length; ++i)
+            {
+                drawSettings.SetShaderPassName(i, passNames[i]);
+            }
+            
+            if (overrideMaterial != null)
+            {
+                drawSettings.SetOverrideMaterial(overrideMaterial, 0);
+            }
+
-
-#if UNITY_EDITOR
-            // in editor draw invalid things with error material
-            ConfigureErrorDraw(ref drawSettings);
-            renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
-#endif
+        }
+        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName passName, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
+        {
+            RenderTransparentRenderList(cull, camera, renderContext, cmd, new ShaderPassName[] { passName }, rendererConfiguration, overrideMaterial);
-        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, string passName, RendererConfiguration rendererConfiguration = 0)
+        void RenderTransparentRenderList(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ShaderPassName[] passNames, RendererConfiguration rendererConfiguration = 0, Material overrideMaterial = null)
         {
             if (!m_DebugDisplaySettings.renderingDebugSettings.displayTransparentObjects)
                 return;
             cmd.Clear();
 
-            var drawSettings = new DrawRendererSettings(camera, new ShaderPassName(passName))
+            var drawSettings = new DrawRendererSettings(camera, HDShaderPassNames.s_EmptyName)
+            
+            for (int i = 0; i < passNames.Length; ++i)
+            {
+                drawSettings.SetShaderPassName(i, passNames[i]);
+            }
+
+            if (overrideMaterial != null)
+            {
+                drawSettings.SetOverrideMaterial(overrideMaterial, 0);
+            }
+
-
-#if UNITY_EDITOR
-            // in editor draw invalid things with error material
-            ConfigureErrorDraw(ref drawSettings);
-            renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
-#endif
-        }
-
-        private static void ConfigureErrorDraw(ref DrawRendererSettings drawSettings)
-        {
-            drawSettings.SetShaderPassName(0, new ShaderPassName("Always"));
-            drawSettings.SetShaderPassName(1, new ShaderPassName("ForwardBase"));
-            drawSettings.SetShaderPassName(2, new ShaderPassName("Deferred"));
-            drawSettings.SetShaderPassName(3, new ShaderPassName("PrepassBase"));
-            drawSettings.SetShaderPassName(4, new ShaderPassName("Vertex"));
-            drawSettings.SetShaderPassName(5, new ShaderPassName("VertexLMRGBM"));
-            drawSettings.SetShaderPassName(6, new ShaderPassName("VertexLM"));
-            drawSettings.SetOverrideMaterial(errorMaterial, 0);
-           if (!m_Asset.renderingSettings.useDepthPrepass)
+            // Guidelines: To be able to switch from deferred to forward renderer we need to have forward opaque material with both DepthOnly and ForwardOnlyOpaqueDepthOnly pass.
+            // This is also required if we want to support optional depth prepass dynamically.
+            // This is what is assume here. But users may want to reduce number of shader combination once they have made their choice.
+
+            // In case of forward only renderer we have a depth prepass. In case of deferred renderer, it is optional
+            bool addDepthPrepass = m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() || m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering;
+            // In case of deferred renderer, we can have forward opaque material. These materials need to be render in the depth buffer to correctly build the light list. And they will tag the stencil to not be lit during the deferred lighting pass.
+            // Caution: If a DepthPrepass is enabled for deferred then the object will be rendered with the pass DepthPrepass. See guidelines. This allow to switch dynamically between both mode.
+            // So we don't need to render the ForwardOnlyOpaqueDepthOnly pass
+            // Note that an object can't be in both list
+            bool addForwardOnlyOpaqueDepthPrepass = !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Asset.renderingSettings.useDepthPrepassWithDeferredRendering;
+
+            if (addDepthPrepass == false && addForwardOnlyOpaqueDepthPrepass == false)
-            using (new Utilities.ProfilingSample("Depth Prepass", cmd))
+            using (new Utilities.ProfilingSample(addDepthPrepass ? "Depth Prepass" : "Depth Prepass forward opaque ", cmd))
-                // TODO: Must do opaque then alpha masked for performance!
-                // TODO: front to back for opaque and by material for opaque tested when we split in two
+                // TODO: We should sort the Material by opaque then alpha masked Must do opaque then alpha masked for performance
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, "DepthOnly");
+                // Note: addDepthPrepass and addForwardOnlyOpaqueDepthPrepass can't be both true at the same time. And if we are here both are not false
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, addDepthPrepass ? HDShaderPassNames.m_DepthOnlyName : HDShaderPassNames.m_ForwardOnlyOpaqueDepthOnlyName);
             }
         }
 
                 return;
 
-            string passName = m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "GBufferDebugDisplay" : "GBuffer";
-
-            using (new Utilities.ProfilingSample(passName, cmd))
+            using (new Utilities.ProfilingSample(m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "GBufferDebugDisplay" : "GBuffer", cmd))
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
-            }
-        }
-
-        // This pass is use in case of forward opaque and deferred rendering. We need to render forward objects before tile lighting pass
-        void RenderForwardOnlyOpaqueDepthPrepass(CullResults cull, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-        {
-            // If we are forward only we don't need to render ForwardOnlyOpaqueDepthOnly object
-            // But in case we request a prepass we render it
-            if (m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && !m_Asset.renderingSettings.useDepthPrepass)
-                return;
-
-            using (new Utilities.ProfilingSample("Forward opaque depth", cmd))
-            {
-                Utilities.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, "ForwardOnlyOpaqueDepthOnly");
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DebugDisplaySettings.IsDebugDisplayEnabled() ? HDShaderPassNames.m_GBufferDebugDisplayName : HDShaderPassNames.m_GBufferName, Utilities.kRendererConfigurationBakedLighting);
             }
         }
 
                 {
                     Utilities.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, Utilities.kClearAll, Color.black);
                     // Render Opaque forward
-                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.m_ForwardDisplayDebugName, Utilities.kRendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, "ForwardDisplayDebug", Utilities.kRendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.m_ForwardDisplayDebugName, Utilities.kRendererConfigurationBakedLighting);
                 }
             }
 
             m_LightLoop.RenderLightingDebug(camera, cmd, colorBuffer, debugDisplaySettings);
         }
 
+        // Render forward is use for both transparent and opaque objects. In case of deferred we can still render opaque object in forward.
-            if (!m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() && renderOpaque)
-                return;
+            // Guidelines: To be able to switch from deferred to forward renderer we need to have forward opaque material with both Forward and ForwardOnlyOpaque pass.
+            // This is what is assume here. But users may want to reduce number of shader combination once they have made their choice.
+
+            // If we are transparent, we add the forward pass. Else (Render Opaque) we add it only if we are forward rendering
+            bool addForwardPass = !renderOpaque || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly();
+
+            // In case of deferred we can still have forward opaque object
+            // It mean that addForwardOnlyOpaquePass = !addForwardPass which is a simplification of: renderOpaque && !m_Asset.renderingSettings.ShouldUseForwardRenderingOnly()
+            // There is no need to store this case as we don't need to test for it
-            string passName = m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardDisplayDebug" : "Forward";
+            ShaderPassName passName;
+            string profileName;
+            if (m_DebugDisplaySettings.IsDebugDisplayEnabled())
+            {
+                passName = addForwardPass ? HDShaderPassNames.m_ForwardDisplayDebugName :  HDShaderPassNames.m_ForwardOnlyOpaqueDisplayDebugName;
+                profileName = addForwardPass ? (renderOpaque ? "Forward Opaque Display Debug" : "Forward Transparent Display Debug") :  "ForwardOnlyOpaqueDisplayDebug";
+            }
+            else
+            {
+                passName = addForwardPass ? HDShaderPassNames.m_ForwardName : HDShaderPassNames.m_ForwardOnlyOpaqueName;
+                profileName = addForwardPass ? (renderOpaque ? "Forward Opaque" : "Forward Transparent") :  "Forward Only Opaque";
+            }
-            using (new Utilities.ProfilingSample(passName, cmd))
+            using (new Utilities.ProfilingSample(profileName, cmd))
+                // The pass "SRPDefaultUnlit" is a fallback to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
+                ShaderPassName[] arrayNames = { passName, HDShaderPassNames.m_SRPDefaultUnlitName};
+
-                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, Utilities.kRendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, arrayNames, Utilities.kRendererConfigurationBakedLighting);
-        // Render material that are forward opaque only (like eye), this include unlit material
-        void RenderForwardOnlyOpaque(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd)
+#if UNITY_EDITOR
+        // This is use to Display legacy shader with an error shader
+        void RenderForwardError(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
-            string passName = m_DebugDisplaySettings.IsDebugDisplayEnabled() ? "ForwardOnlyOpaqueDisplayDebug" : "ForwardOnlyOpaque";
-
-            using (new Utilities.ProfilingSample(passName, cmd))
+            using (new Utilities.ProfilingSample("Render Forward Error", cmd))
-                m_LightLoop.RenderForward(camera, cmd, true);
+                ShaderPassName[] arrayNames = { HDShaderPassNames.m_AlwaysName, HDShaderPassNames.m_ForwardBaseName, HDShaderPassNames.m_DeferredName, HDShaderPassNames.m_PrepassBaseName, HDShaderPassNames.m_VertexName, HDShaderPassNames.m_VertexLMRGBMName, HDShaderPassNames.m_VertexLMName };
-                RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, passName, Utilities.kRendererConfigurationBakedLighting);
+                if (renderOpaque)
+                {
+                    RenderOpaqueRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, m_ErrorMaterial);
+                }
+                else
+                {
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, arrayNames, 0, m_ErrorMaterial);
+                }
+#endif
 
         void RenderVelocity(CullResults cullResults, HDCamera hdcam, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
-                if ((ShaderConfig.s_VelocityInGbuffer == 1) || m_Asset.renderingSettings.ShouldUseForwardRenderingOnly())
+                // TODO: Currently we can't render velocity vector into GBuffer, neither during forward pass (in case of forward opaque), so it is always a separate pass
+                // Note that we if we have forward only opaque with deferred rendering, it must also support the rendering of velocity vector to be correct with following test.
+                if ((ShaderConfig.s_VelocityInGbuffer == 1))
+                {
+                    Debug.LogWarning("Velocity in Gbuffer is currently not supported");
+                }
 
                 // These flags are still required in SRP or the engine won't compute previous model matrices...
                 // If the flag hasn't been set yet on this camera, motion vectors will skip a frame.
                 Utilities.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, null, 0);
                 cmd.SetRenderTarget(m_VelocityBufferRT, m_CameraDepthStencilBufferRT);
 
-                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, cmd, "MotionVectors", RendererConfiguration.PerObjectMotionVectors);
+                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, cmd, HDShaderPassNames.m_MotionVectorsName, RendererConfiguration.PerObjectMotionVectors);
 
                 PushFullScreenDebugTexture(cmd, m_VelocityBuffer, hdcam.camera, renderContext, FullScreenDebugMode.MotionVectors);
             }
                 cmd.ClearRenderTarget(false, true, Color.black); // TODO: can we avoid this clear for performance ?
 
                 // Only transparent object can render distortion vectors
-                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, "DistortionVectors");
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.m_DistortionVectorsName);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

     type: 2}
   renderingSettings:
     useForwardRenderingOnly: 0
-    useDepthPrepass: 0
+    useDepthPrepassWithDeferredRendering: 0
   sssSettings:
     numProfiles: 2
     profiles:

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/LightingConvexHullUtils.hlsl

     vE0 = p1-p0;
 }
 
-void GetQuad(out float3 p0, out float3 p1, out float3 p2, out float3 p3, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+void GetHullQuad(out float3 p0, out float3 p1, out float3 p2, out float3 p3, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
 {
     //const int iAbsSide = (sideIndex == 0 || sideIndex == 1) ? 0 : ((sideIndex == 2 || sideIndex == 3) ? 1 : 2);
     const int iAbsSide = min(sideIndex>>1, 2);
     p3 = center + (vA2 + vB2 + vC);
 }
 
-void GetPlane(out float3 p0, out float3 vN, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+void GetHullPlane(out float3 p0, out float3 n0, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
 {
     //const int iAbsSide = (sideIndex == 0 || sideIndex == 1) ? 0 : ((sideIndex == 2 || sideIndex == 3) ? 1 : 2);
     const int iAbsSide = min(sideIndex>>1, 2);
 
     if (bIsSideQuad) { vA2 *= (iAbsSide == 0 ? scaleXY.x : scaleXY.y); vB2 *= (iAbsSide == 0 ? scaleXY.y : scaleXY.x); }
 
-    p0 = center + (vA + vB - vC);       // center + vA is center of face when scaleXY is 1.0
-    float3 vNout = cross( vB2, 0.5*(vA-vA2) - vC );
-
-#if USE_LEFT_HAND_CAMERA_SPACE
-    vNout = -vNout;
-#endif
-
-    vN = vNout;
+	float3 vN = cross(vB2, 0.5 * (vA - vA2) - vC);	// +/- normal
+    float3 v0 = vA + vB - vC;   // vector from center to p0
+    p0 = center + v0;           // center + vA is center of face when scaleXY is 1.0
+    n0 = dot(vN,v0) < 0.0 ? (-vN) : vN;
-float4 GetPlaneEq(const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+float4 GetHullPlaneEq(const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
-    GetPlane(p0, vN, boxX, boxY, boxZ, center, scaleXY, sideIndex);
+    GetHullPlane(p0, vN, boxX, boxY, boxZ, center, scaleXY, sideIndex);
 
     return float4(vN, -dot(vN,p0));
 }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                 }
                 else if (gpuLightType == GPULightType.Point)
                 {
-                    bool isNegDeterminant = Vector3.Dot(worldToView.GetColumn(0), Vector3.Cross(worldToView.GetColumn(1), worldToView.GetColumn(2))) < 0.0f; // 3x3 Determinant.
+                    Vector3 vx = xAxisVS;
+                    Vector3 vy = yAxisVS;
+                    Vector3 vz = zAxisVS;
-                    bound.center = positionVS;
-                    bound.boxAxisX.Set(range, 0, 0);
-                    bound.boxAxisY.Set(0, range, 0);
-                    bound.boxAxisZ.Set(0, 0, isNegDeterminant ? (-range) : range);    // transform to camera space (becomes a left hand coordinate frame in Unity since Determinant(worldToView)<0)
+                    bound.center   = positionVS;
+                    bound.boxAxisX = vx * range;
+                    bound.boxAxisY = vy * range;
+                    bound.boxAxisZ = vz * range;
-
-                    // represents a left hand coordinate system in world space since det(worldToView)<0
-                    Vector3 vx = xAxisVS;
-                    Vector3 vy = yAxisVS;
-                    Vector3 vz = zAxisVS;
 
                     // fill up ldata
                     lightVolumeData.lightAxisX = vx;

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

 	const float radius = lgtDat.radius;
 	const float2 scaleXY = lgtDat.scaleXY;
 
-	return GetPlaneEq(boxX, boxY, boxZ, center, scaleXY, p);
+	return GetHullPlaneEq(boxX, boxY, boxZ, center, scaleXY, p);
 }
 
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/scrbound.compute

 		if(sideIndex<6 && lgtIndex<(int) g_iNrVisibLights)		// mask 2 out of 8 threads
 		{
 			float3 q0, q1, q2, q3;
-			GetQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, sideIndex);
+			GetHullQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, sideIndex);
 
 
 			const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 				for(f=0; f<6; f++)
 				{
 					float3 q0, q1, q2, q3;
-					GetQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, f);
+					GetHullQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, f);
 
 					// 4 vertices to a quad of the convex hull in post projection space
 					const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 				for(f=0; f<6; f++)
 				{
 					float3 vP0, vN;
-					GetPlane(vP0, vN, boxX, boxY, boxZ, center, scaleXY, f);
+					GetHullPlane(vP0, vN, boxX, boxY, boxZ, center, scaleXY, f);
 
 					for(i=0; i<8; i++)
 					{

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/VolumetricLighting.cs

         return (globalFogComponent != null);
     }
 
-    void VolumetricLightingPass(CommandBuffer cmd, HDCamera hdCamera)
+    void VolumetricLightingPass(HDCamera hdCamera, CommandBuffer cmd)
     {
         if (!SetGlobalVolumeProperties(m_VolumetricLightingEnabled, cmd, m_VolumetricLightingCS)) { return; }
 

ScriptableRenderPipeline/LightweightPipeline/Editor/LegacyShadersToLightweightPipelineUpgrader.cs

             materialUpgraders.Add(new LegacyBlinnPhongUpgrader("Mobile/Bumped Diffuse", SupportedUpgradeParams.diffuseOpaque));
             materialUpgraders.Add(new LegacyBlinnPhongUpgrader("Mobile/Unlit (Supports Lightmap)", SupportedUpgradeParams.diffuseOpaque));
             materialUpgraders.Add(new LegacyBlinnPhongUpgrader("Mobile/VertexLit", SupportedUpgradeParams.specularOpaque));
-
-            /////////////////////////////////////
-            // Particles                        /
-            /////////////////////////////////////
-            materialUpgraders.Add(new ParticlesAdditiveUpgrader("Particles/Additive"));
-            materialUpgraders.Add(new ParticlesAdditiveUpgrader("Mobile/Particles/Additive"));
-            materialUpgraders.Add(new ParticlesMultiplyUpgrader("Particles/Multiply"));
-            materialUpgraders.Add(new ParticlesMultiplyUpgrader("Mobile/Particles/Multiply"));
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent renderingLabel = new GUIContent("Rendering");
             public static GUIContent shadowLabel = new GUIContent("Shadows");
             public static GUIContent defaults = new GUIContent("Defaults");
-            public static GUIContent linearRenderingLabel = new GUIContent("Linear Colorspace", "When enabled Lightweight shader will perform gamma to linear conversion when linear rendering is not supported or disabled");
+            public static GUIContent linearRenderingLabel = new GUIContent("Force Linear Colorspace", "When enabled Lightweight shader will perform gamma to linear conversion in the shader when linear rendering is not supported or disabled");
+
+            public static GUIContent renderScaleLabel = new GUIContent("Render Scale", "Allows game to render at a resolution different than native resolution. UI is always rendered at native resolution.");
 
             public static GUIContent maxPixelLights = new GUIContent("Per-Object Pixel Lights",
                     "Max amount of dynamic per-object pixel lights.");
-
-            public static GUIContent enableLightmap = new GUIContent("Enable Lightmap",
-                    "Enabled/Disable support for non-directional lightmaps.");
-
-            public static GUIContent enableAmbientProbe = new GUIContent("Enable Light Probes",
-                    "Enables/Disable light probe support.");
 
             public static GUIContent shadowType = new GUIContent("Shadow Type",
                     "Single directional shadow supported. SOFT_SHADOWS applies shadow filtering.");
             public static GUIContent defaultShader = new GUIContent("Default Shader",
                 "Shader to use when creating materials");
 
-            public static GUIContent msaaContent = new GUIContent("Anti Aliasing", "Controls the global anti aliasing quality. When set to disabled, MSAA will not be performed even if the camera allows it.");
+            public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing quality. When set to disabled, MSAA will not be performed even if the camera allows it.");
+        private SerializedProperty m_RenderScale;
-        private SerializedProperty m_EnableLightmapsProp;
-        private SerializedProperty m_EnableAmbientProbeProp;
         private SerializedProperty m_ShadowTypeProp;
         private SerializedProperty m_ShadowNearPlaneOffsetProp;
         private SerializedProperty m_ShadowDistanceProp;
         void OnEnable()
         {
             m_LinearRenderingProperty = serializedObject.FindProperty("m_LinearRendering");
+            m_RenderScale = serializedObject.FindProperty("m_RenderScale");
-            m_EnableLightmapsProp = serializedObject.FindProperty("m_EnableLightmaps");
-            m_EnableAmbientProbeProp = serializedObject.FindProperty("m_EnableAmbientProbe");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
             m_ShadowNearPlaneOffsetProp = serializedObject.FindProperty("m_ShadowNearPlaneOffset");
             m_ShadowDistanceProp = serializedObject.FindProperty("m_ShadowDistance");
             EditorGUI.indentLevel++;
             EditorGUILayout.PropertyField(m_LinearRenderingProperty, Styles.linearRenderingLabel);
             EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(Styles.renderScaleLabel);
+            m_RenderScale.floatValue = EditorGUILayout.Slider(m_RenderScale.floatValue, 0.1f, 1.0f);
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.BeginHorizontal();
-            EditorGUILayout.PropertyField(m_EnableLightmapsProp, Styles.enableLightmap);
-            EditorGUILayout.PropertyField(m_EnableAmbientProbeProp, Styles.enableAmbientProbe);
             EditorGUILayout.PropertyField(m_MSAA, Styles.msaaContent);
             EditorGUILayout.PropertyField(m_AttenuationTexture, Styles.attenuationTextureLabel);
             EditorGUI.indentLevel--;

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightPipelineUpgraders.cs

         }
     }
 
-    public class ParticlesMultiplyUpgrader : MaterialUpgrader
-    {
-        public ParticlesMultiplyUpgrader(string oldShaderName)
-        {
-            RenameShader(oldShaderName, "ScriptableRenderPipeline/LightweightPipeline/Particles/Multiply");
-        }
-    }
-
-    public class ParticlesAdditiveUpgrader : MaterialUpgrader
-    {
-        public ParticlesAdditiveUpgrader(string oldShaderName)
-        {
-            RenameShader(oldShaderName, "ScriptableRenderPipeline/LightweightPipeline/Particles/Additive");
-        }
-    }
-
     public class StandardUpgrader : MaterialUpgrader
     {
         public StandardUpgrader(string oldShaderName)

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
-        private int m_ShadowMapProperty;
-        private int m_CameraRTProperty;
-        private RenderTargetIdentifier m_ShadowMapRTID;
-        private RenderTargetIdentifier m_CameraRTID;
+        private int m_ShadowMapTexture;
+        private int m_CameraColorTexture;
+        private int m_CameraDepthTexture;
+        private RenderTargetIdentifier m_ShadowMapRT;
+        private RenderTargetIdentifier m_CameraColorRT;
+        private RenderTargetIdentifier m_CameraDepthRT;
 
         private bool m_RenderToIntermediateTarget = false;
         private bool m_IntermediateTextureArray = false;
         private RenderTextureFormat m_ColorFormat = RenderTextureFormat.ARGB32;
         private PostProcessRenderContext m_PostProcessRenderContext;
 
+        private CameraComparer m_CameraComparer = new CameraComparer();
+
+        private Mesh m_BlitQuad = null;
+        private Material m_BlitMaterial = null;
+        private int m_BlitTexID = Shader.PropertyToID("_BlitTex");
+
-            m_ShadowMapProperty = Shader.PropertyToID("_ShadowMap");
-            m_CameraRTProperty = Shader.PropertyToID("_CameraRT");
-            m_ShadowMapRTID = new RenderTargetIdentifier(m_ShadowMapProperty);
-            m_CameraRTID = new RenderTargetIdentifier(m_CameraRTProperty);
+            m_ShadowMapTexture = Shader.PropertyToID("_ShadowMap");
+            m_CameraColorTexture = Shader.PropertyToID("_CameraRT");
+            m_CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
+
+            m_ShadowMapRT = new RenderTargetIdentifier(m_ShadowMapTexture);
+            m_CameraColorRT = new RenderTargetIdentifier(m_CameraColorTexture);
+            m_CameraDepthRT = new RenderTargetIdentifier(m_CameraDepthTexture);
             m_PostProcessRenderContext = new PostProcessRenderContext();
 
             // Let engine know we have MSAA on for cases where we support MSAA backbuffer
             Shader.globalRenderPipeline = "LightweightPipeline";
+
+            m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
+            m_BlitMaterial = new Material(m_Asset.BlitShader)
+            {
+                hideFlags = HideFlags.HideAndDontSave
+            };
         }
 
         public override void Dispose()
 
             bool stereoEnabled = XRSettings.isDeviceActive;
 
+            // TODO: This is at the moment required for all pipes. We should not implicitly change user project settings
+            // instead this should be forced when using SRP, since all SRP use linear lighting.
+            GraphicsSettings.lightsUseLinearIntensity = true;
+
+            Array.Sort(cameras, m_CameraComparer);
+                PostProcessLayer postProcessLayer;
+                RenderingConfiguration renderingConfig = SetupRendering(out postProcessLayer);
+                bool postProcessEnabled = LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.PostProcess);
-                cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance, m_CurrCamera.farClipPlane);
-                CullResults.Cull(ref cullingParameters, context,ref m_CullResults);
+                cullingParameters.shadowDistance = Mathf.Min(m_ShadowSettings.maxShadowDistance,
+                    m_CurrCamera.farClipPlane);
+
+                // emit scene view UI
+                if (camera.cameraType == CameraType.SceneView)
+                    ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
+
+                CullResults.Cull(ref cullingParameters, context, ref m_CullResults);
 
                 VisibleLight[] visibleLights = m_CullResults.visibleLights.ToArray();
 
                 // Render Shadow Map
                 if (lightData.shadowLightIndex > -1)
-                    lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
+                    lightData.shadowsRendered = RenderShadows(ref m_CullResults,
+                        ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
-                // Setup camera matrices and RT
+                // Setup camera matrices
-                    SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
+                    SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex],
+                        lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
-                RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes;
-                if (m_Asset.EnableLightmap)
-                    configuration |= RendererConfiguration.PerObjectLightmaps;
-
-                if (m_Asset.EnableAmbientProbe)
-                    configuration |= RendererConfiguration.PerObjectLightProbe;
-
+                RendererConfiguration configuration = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-
-                PostProcessLayer postProcessLayer = GetCurrCameraPostProcessLayer();
-                bool postProcessEnabled = postProcessLayer != null && postProcessLayer.enabled;
-                m_RenderToIntermediateTarget = postProcessEnabled || GetRenderToIntermediateTarget();
-
-                BeginForwardRendering(ref context, stereoEnabled);
+                BeginForwardRendering(ref context, renderingConfig);
 
                 var litDrawSettings = new DrawRendererSettings(m_CurrCamera, m_LitPassName);
                 litDrawSettings.sorting.flags = SortFlags.CommonOpaque;
                 unlitDrawSettings.sorting.flags = SortFlags.CommonTransparent;
 
                 // Render Opaques
-                var opaqueFilterSettings = new FilterRenderersSettings(true) {renderQueueRange = RenderQueueRange.opaque};
+                var opaqueFilterSettings = new FilterRenderersSettings(true)
+                {
+                    renderQueueRange = RenderQueueRange.opaque
+                };
 
                 context.DrawRenderers(m_CullResults.visibleRenderers, ref litDrawSettings, opaqueFilterSettings);
 
+                if (postProcessEnabled)
+                    RenderPostProcess(ref context, postProcessLayer, true);
+
-                var transparentFilterSettings = new FilterRenderersSettings(true) {renderQueueRange = RenderQueueRange.transparent};
+                var transparentFilterSettings = new FilterRenderersSettings(true)
+                {
+                    renderQueueRange = RenderQueueRange.transparent
+                };
 
                 litDrawSettings.sorting.flags = SortFlags.CommonTransparent;
                 context.DrawRenderers(m_CullResults.visibleRenderers, ref litDrawSettings, transparentFilterSettings);
-                    RenderPostProcess(ref context, postProcessLayer);
+                    RenderPostProcess(ref context, postProcessLayer, false);
-                EndForwardRendering(ref context, stereoEnabled, postProcessEnabled);
+                EndForwardRendering(ref context, renderingConfig);
-                discardRT.ReleaseTemporaryRT(m_ShadowMapProperty);
-                discardRT.ReleaseTemporaryRT(m_CameraRTProperty);
+                discardRT.ReleaseTemporaryRT(m_ShadowMapTexture);
+                discardRT.ReleaseTemporaryRT(m_CameraColorTexture);
+                discardRT.ReleaseTemporaryRT(m_CameraDepthTexture);
-            }
-            context.Submit();
+                context.Submit();
+            }
         }
 
         private void BuildShadowSettings()
             }
         }
 
+        private RenderingConfiguration SetupRendering(out PostProcessLayer postProcessLayer)
+        {
+            RenderingConfiguration renderingConfig = (XRSettings.enabled) ? RenderingConfiguration.Stereo : RenderingConfiguration.None;
+            if (XRSettings.eyeTextureDesc.dimension == TextureDimension.Tex2DArray)
+                renderingConfig |= RenderingConfiguration.IntermediateTextureArray;
+
+            postProcessLayer = m_CurrCamera.GetComponent<PostProcessLayer>();
+            bool intermediateTexture = false;
+            if (postProcessLayer != null && postProcessLayer.enabled)
+            {
+                renderingConfig |= RenderingConfiguration.PostProcess;
+                intermediateTexture = true;
+            }
+            // When post process is enabled we disable msaa due to lack of depth resolve
+            // One can still use PostFX AA
+            else if (m_CurrCamera.allowMSAA && m_Asset.MSAASampleCount > 1)
+            {
+                renderingConfig |= RenderingConfiguration.Msaa;
+                intermediateTexture = !LightweightUtils.PlatformSupportsMSAABackBuffer();
+            }
+
+            Rect cameraRect = m_CurrCamera.rect;
+            if (cameraRect.x > 0.0f || cameraRect.y > 0.0f || cameraRect.width < 1.0f || cameraRect.height < 1.0f)
+                intermediateTexture = true;
+            else
+                renderingConfig |= RenderingConfiguration.DefaultViewport;
+
+            intermediateTexture |= (m_CurrCamera.targetTexture != null || m_Asset.RenderScale < 1.0f);
+            if (intermediateTexture && !LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.IntermediateTextureArray))
+                renderingConfig |= RenderingConfiguration.IntermediateTexture;
+
+            return renderingConfig;
+        }
+
         private void InitializeLightData(VisibleLight[] lights, out LightData lightData)
         {
             int lightsCount = lights.Length;
             lightColor = light.finalColor;
 
             float rangeSq = light.range * light.range;
-            float quadAtten = (light.lightType == LightType.Directional) ? 0.0f : 25.0f / rangeSq;
+            float quadAtten = 0.0f;
+            if (light.lightType != LightType.Directional)
+                quadAtten = (m_Asset.AttenuationTexture != null) ? 1.0f : 25.0f / rangeSq;
 
             if (light.lightType == LightType.Spot)
             {
 
             var setRenderTargetCommandBuffer = CommandBufferPool.Get();
             setRenderTargetCommandBuffer.name = "Render packed shadows";
-            setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapProperty, m_ShadowSettings.shadowAtlasWidth,
+            setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapTexture, m_ShadowSettings.shadowAtlasWidth,
-            setRenderTargetCommandBuffer.SetRenderTarget(m_ShadowMapRTID);
+            setRenderTargetCommandBuffer.SetRenderTarget(m_ShadowMapRT);
             setRenderTargetCommandBuffer.ClearRenderTarget(true, true, Color.black);
             context.ExecuteCommandBuffer(setRenderTargetCommandBuffer);
             CommandBufferPool.Release(setRenderTargetCommandBuffer);
             CommandBufferPool.Release(setupShadow);
         }
 
-        private void SetKeyword(CommandBuffer cmd, string keyword, bool enable)
-        {
-            if (enable)
-                cmd.EnableShaderKeyword(keyword);
-            else
-                cmd.DisableShaderKeyword(keyword);
-        }
-
-            SetKeyword(cmd, "LIGHTWEIGHT_LINEAR", m_Asset.ForceLinearRendering);
-            SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightSupport);
-            SetKeyword(cmd, "_ATTENUATION_TEXTURE", m_Asset.AttenuationTexture != null);
-            SetKeyword(cmd, "_LIGHT_PROBES_ON", m_Asset.EnableAmbientProbe);
-            SetKeyword(cmd, "LIGHTWEIGHT_LINEAR", m_Asset.ForceLinearRendering);
+            LightweightUtils.SetKeyword(cmd, "_LIGHTWEIGHT_FORCE_LINEAR", m_Asset.ForceLinearRendering);
+            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightSupport);
+            LightweightUtils.SetKeyword(cmd, "_ATTENUATION_TEXTURE", m_Asset.AttenuationTexture != null);
-                SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
+                LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
+                LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
+                LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
             }
             else
             {
-                        SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", true);
-                        SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", true);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", true);
-                        SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", true);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                        SetKeyword(cmd, "_SINGLE_POINT_LIGHT", true);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
+                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", true);
                         break;
                 }
             }
             return (type == LightType.Directional || type == LightType.Spot);
         }
 
-        private void BeginForwardRendering(ref ScriptableRenderContext context, bool stereoEnabled)
+        private void BeginForwardRendering(ref ScriptableRenderContext context, RenderingConfiguration renderingConfig)
-            if (stereoEnabled)
-                context.StartMultiEye(m_CurrCamera);
+            RenderTargetIdentifier colorRT = BuiltinRenderTextureType.CameraTarget;
+            RenderTargetIdentifier depthRT = BuiltinRenderTextureType.None;
+
+            // When postprocess is enabled, msaa is forced to be disabled due to lack of depth resolve.
+            int msaaSamples = (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.Msaa)) ? m_Asset.MSAASampleCount : 1;
-            if (m_RenderToIntermediateTarget)
+            if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.IntermediateTexture))
-                if (m_CurrCamera.activeTexture == null)
+                int rtWidth = (int)((float)m_CurrCamera.pixelWidth * m_Asset.RenderScale);
+                int rtHeight = (int)((float)m_CurrCamera.pixelHeight * m_Asset.RenderScale);
+
+                if (m_CurrCamera.targetTexture == null)
-                    m_IntermediateTextureArray = false;
-                    if (stereoEnabled)
+                    RenderTextureDescriptor rtDesc = new RenderTextureDescriptor();
+                    if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.Stereo))
-                        RenderTextureDescriptor xrDesc = XRSettings.eyeTextureDesc;
-                        xrDesc.depthBufferBits = kCameraDepthBufferBits;
-                        xrDesc.colorFormat = m_ColorFormat;
-                        xrDesc.msaaSamples = m_Asset.MSAASampleCount;
-
-                        m_IntermediateTextureArray = (xrDesc.dimension == TextureDimension.Tex2DArray);
+                        context.StartMultiEye(m_CurrCamera);
+                        rtDesc = XRSettings.eyeTextureDesc;
+                        rtDesc.colorFormat = m_ColorFormat;
+                        rtDesc.msaaSamples = msaaSamples;
-                        cmd.GetTemporaryRT(m_CameraRTProperty, xrDesc, FilterMode.Bilinear);
+                        cmd.GetTemporaryRT(m_CameraColorTexture, rtDesc, FilterMode.Bilinear);
-                        cmd.GetTemporaryRT(m_CameraRTProperty, Screen.width, Screen.height, kCameraDepthBufferBits,
-                            FilterMode.Bilinear, m_ColorFormat, RenderTextureReadWrite.Default, m_Asset.MSAASampleCount);
+                        cmd.GetTemporaryRT(m_CameraColorTexture, rtWidth, rtHeight, kCameraDepthBufferBits,
+                            FilterMode.Bilinear, m_ColorFormat, RenderTextureReadWrite.Default, msaaSamples);
-                    if (m_IntermediateTextureArray)
-                        cmd.SetRenderTarget(m_CameraRTID, 0, CubemapFace.Unknown, -1);
-                    else
-                        cmd.SetRenderTarget(m_CameraRTID);
+                    colorRT = m_CameraColorRT;
-                else
+
+                if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.PostProcess))
-                    cmd.SetRenderTarget(new RenderTargetIdentifier(m_CurrCamera.activeTexture));
+                    cmd.GetTemporaryRT(m_CameraDepthTexture, rtWidth, rtHeight, kCameraDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
+                    depthRT = m_CameraDepthRT;
-            else
-            {
-                cmd.SetRenderTarget(BuiltinRenderTextureType.CurrentActive);
-            }
+
+            SetupRenderTargets(cmd, colorRT, depthRT);
 
             // Clear RenderTarget to avoid tile initialization on mobile GPUs
             // https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
-                bool clearColor = (m_CurrCamera.clearFlags == CameraClearFlags.Color);
-                cmd.ClearRenderTarget(clearDepth, clearColor, m_CurrCamera.backgroundColor);
+                bool clearColor = (m_CurrCamera.clearFlags == CameraClearFlags.Color || m_CurrCamera.clearFlags == CameraClearFlags.Skybox);
+                cmd.ClearRenderTarget(clearDepth, clearColor, m_CurrCamera.backgroundColor.linear);
             }
 
             context.ExecuteCommandBuffer(cmd);
-        private void EndForwardRendering(ref ScriptableRenderContext context, bool stereoEnabled, bool postProcessing)
+        private void EndForwardRendering(ref ScriptableRenderContext context, RenderingConfiguration renderingConfig)
+            // No additional rendering needs to be done if this is an offscren rendering camera
+            if (m_CurrCamera.targetTexture != null)
+                return;
-            if (m_RenderToIntermediateTarget || postProcessing)
+            var cmd = CommandBufferPool.Get("Blit");
+            if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.IntermediateTextureArray))
-                var cmd = CommandBufferPool.Get("Blit");
-                if (m_IntermediateTextureArray)
-                {
-                    cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1);
-                    cmd.Blit(m_CameraRTID, BuiltinRenderTextureType.CurrentActive);
-                }
+                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, 0, CubemapFace.Unknown, -1);
+                cmd.Blit(m_CameraColorRT, BuiltinRenderTextureType.CurrentActive);
+            }
+            else if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.IntermediateTexture))
+            {
-                else if (!postProcessing)
-                    cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
+                if (!LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.PostProcess))
+                    Blit(cmd, renderingConfig, m_CameraColorRT, BuiltinRenderTextureType.CameraTarget);
+            }
-                    cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
-                context.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-            }
+            cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
-            if (stereoEnabled)
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+
+            if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.Stereo))
             {
                 context.StopMultiEye(m_CurrCamera);
                 context.StereoEndRender(m_CurrCamera);
-        private void RenderPostProcess(ref ScriptableRenderContext renderContext, PostProcessLayer postProcessLayer)
+        private void SetupRenderTargets(CommandBuffer cmd, RenderTargetIdentifier colorRT, RenderTargetIdentifier depthRT)
+        {
+            if (m_IntermediateTextureArray)
+            {
+                if (depthRT != BuiltinRenderTextureType.None)
+                    cmd.SetRenderTarget(colorRT, 0, CubemapFace.Unknown, -1);
+                else
+                    cmd.SetRenderTarget(colorRT, depthRT, 0, CubemapFace.Unknown, -1);
+            }
+            else
+            {
+                if (depthRT != BuiltinRenderTextureType.None)
+                    cmd.SetRenderTarget(colorRT, depthRT);
+                else
+                    cmd.SetRenderTarget(colorRT);
+            }
+        }
+
+        private void RenderPostProcess(ref ScriptableRenderContext renderContext, PostProcessLayer postProcessLayer, bool opaqueOnly)
+            postProcessCommand.SetGlobalTexture("m_CameraDepthTexture", m_CameraDepthRT);
+
             m_PostProcessRenderContext.Reset();
             m_PostProcessRenderContext.camera = m_CurrCamera;
             m_PostProcessRenderContext.source = BuiltinRenderTextureType.CurrentActive;
             m_PostProcessRenderContext.flip = true;
 
-            postProcessLayer.Render(m_PostProcessRenderContext);
+            if (opaqueOnly)
+                postProcessLayer.RenderOpaqueOnly(m_PostProcessRenderContext);
+            else
+                postProcessLayer.Render(m_PostProcessRenderContext);
-        private bool GetRenderToIntermediateTarget()
+        private void Blit(CommandBuffer cmd, RenderingConfiguration renderingConfig, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material material = null)
-            bool allowMSAA = m_CurrCamera.allowMSAA && m_Asset.MSAASampleCount > 1 && !PlatformSupportsMSAABackBuffer();
-            if (m_CurrCamera.cameraType == CameraType.SceneView || allowMSAA || m_CurrCamera.activeTexture != null)
-                return true;
+            if (LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.DefaultViewport))
+            {
+                cmd.Blit(sourceRT, destRT, material);
+            }
+            else
+            {
+                if (m_BlitQuad == null)
+                    m_BlitQuad = LightweightUtils.CreateQuadMesh(false);
-            return false;
-        }
-
-        private PostProcessLayer GetCurrCameraPostProcessLayer()
-        {
-            return m_CurrCamera.GetComponent<PostProcessLayer>();
-        }
-
-        private bool PlatformSupportsMSAABackBuffer()
-        {
-#if UNITY_ANDROID || UNITY_IPHONE || UNITY_TVOS || UNITY_SAMSUNGTV
-            return true;
-#else
-            return false;
-#endif
+                cmd.SetGlobalTexture(m_BlitTexID, sourceRT);
+                cmd.SetRenderTarget(destRT);
+                cmd.SetViewport(m_CurrCamera.pixelRect);
+                cmd.DrawMesh(m_BlitQuad, Matrix4x4.identity, m_BlitMaterial);
+            }
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_EditorClassIdentifier: 
   m_MaxPixelLights: 4
   m_SupportsVertexLight: 1
-  m_EnableLightmaps: 1
-  m_EnableAmbientProbe: 1
+  m_RenderScale: 1
   m_ShadowType: 1
   m_ShadowAtlasResolution: 1024
   m_ShadowNearPlaneOffset: 2
   m_LinearRendering: 1
   m_AttenuationTexture: {fileID: 2800000, guid: ee420ad43ff580149a07f10ad66c49ff,
     type: 3}
-  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 6a1143ee683302f4aa628c052723efc1,
+  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d,
     type: 2}
   m_DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
     type: 2}
     type: 2}
   m_DefaultUIMaterial: {fileID: 2100000, guid: 786cc499ea3906946b10ab7d24c8d0e7, type: 2}
-  m_DefaultShader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_DefaultShader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

             DestroyCreatedInstances();
         }
 
-        #region PipelineAssetSettings
-
-        [SerializeField] private bool m_EnableLightmaps = true;
-        [SerializeField] private bool m_EnableAmbientProbe = true;
+        [SerializeField] private float m_RenderScale = 1.0f;
         [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
         [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
         [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
         [SerializeField] private bool m_LinearRendering = true;
         [SerializeField] private Texture2D m_AttenuationTexture;
-
+        
         [SerializeField] private Material m_DefaultDiffuseMaterial;
         [SerializeField] private Material m_DefaultParticleMaterial;
         [SerializeField] private Material m_DefaultLineMaterial;
             private set { m_SupportsVertexLight = value; }
         }
 
-        public bool EnableLightmap
+        public int MSAASampleCount
-            get { return m_EnableLightmaps; }
-            private set { m_EnableLightmaps = value; }
+            get { return (int)m_MSAA; }
+            set { m_MSAA = (MSAAQuality)value; }
-        public bool EnableAmbientProbe
+        public float RenderScale
-            get { return m_EnableAmbientProbe; }
-            private set { m_EnableAmbientProbe = value; }
-        }
-
-        public int MSAASampleCount
-        {
-            get { return (int)m_MSAA; }
-            set { m_MSAA = (MSAAQuality)value; }
+            get { return m_RenderScale; }
+            set { m_RenderScale = value; }
         }
 
         public ShadowType CurrShadowType
             set { m_AttenuationTexture = value; }
         }
 
-        #endregion
         public override Material GetDefaultMaterial()
         {
             return m_DefaultDiffuseMaterial;
         public override Shader GetDefaultShader()
         {
             return m_DefaultShader;
+        }
+
+        public Shader BlitShader
+        {
+            get { return Shader.Find("Hidden/ScriptableRenderPipeline/LightweightPipeline/Blit"); }
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultParticle.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Lightweight-DefaultParticle
-  m_Shader: {fileID: 207, guid: 0000000000000000f000000000000000, type: 0}
+  m_Shader: {fileID: 202, guid: 0000000000000000f000000000000000, type: 0}
   m_ShaderKeywords: 
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MainTex:
-        m_Texture: {fileID: 0}
+        m_Texture: {fileID: 10300, guid: 0000000000000000f000000000000000, type: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _MetallicGlossMap:

ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-StandardShader.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Lightweight-StandardShader
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _SPECULAR_COLOR
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _DetailNormalMapScale: 1
     - _DstBlend: 0
     - _GlossMapScale: 1
-    - _Glossiness: 1
+    - _Glossiness: 0.5
     - _GlossinessSource: 0
     - _GlossyReflections: 1
     - _Metallic: 0
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkflowMode: 1
     - _ZWrite: 1
     m_Colors:
     - _Color: {r: 1, g: 1, b: 1, a: 1}

ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-StandardSimpleLighting.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: Lightweight-Default
+  m_Name: Lightweight-StandardSimpleLighting
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

 // Shader targeted for low end devices. Single Pass Forward Rendering. Shader Model 2
-Shader "ScriptableRenderPipeline/LightweightPipeline/NonPBR"
+Shader "ScriptableRenderPipeline/LightweightPipeline/Standard (Simple Lighting)"
 {
     // Keep properties of StandardSpecular shader for upgrade reasons.
     Properties
 
         [Enum(UV0,0,UV1,1)] _UVSec("UV Set for secondary textures", Float) = 0
 
-            // Blending state
-            [HideInInspector] _Mode("__mode", Float) = 0.0
-            [HideInInspector] _SrcBlend("__src", Float) = 1.0
-            [HideInInspector] _DstBlend("__dst", Float) = 0.0
-            [HideInInspector] _ZWrite("__zw", Float) = 1.0
+        // Blending state
+        [HideInInspector] _Mode("__mode", Float) = 0.0
+        [HideInInspector] _SrcBlend("__src", Float) = 1.0
+        [HideInInspector] _DstBlend("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite("__zw", Float) = 1.0
     }
 
     SubShader
 
             CGPROGRAM
             #pragma target 3.0
-            #pragma vertex vert
-            #pragma fragment frag
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
             #pragma shader_feature _ _SPECGLOSSMAP _SPECGLOSSMAP_BASE_ALPHA _SPECULAR_COLOR
             #pragma shader_feature _NORMALMAP
-            #pragma multi_compile _ LIGHTWEIGHT_LINEAR
+            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
-            #pragma multi_compile _ _LIGHT_PROBES_ON
             #pragma multi_compile _ _HARD_SHADOWS _SOFT_SHADOWS _HARD_SHADOWS_CASCADES _SOFT_SHADOWS_CASCADES
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _ATTENUATION_TEXTURE
+            #pragma vertex LitPassVertex
+            #pragma fragment LitPassFragmentSimple
-            #include "LightweightPipelineCore.cginc"
-            #include "LightweightPipelineLighting.cginc"
-
-            LightweightVertexOutput vert(LightweightVertexInput v)
-            {
-                LightweightVertexOutput o = (LightweightVertexOutput)0;
-
-                UNITY_SETUP_INSTANCE_ID(v);
-                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-
-                o.uv01.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
-#ifdef LIGHTMAP_ON
-                o.uv01.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
-#endif
-                o.hpos = UnityObjectToClipPos(v.vertex);
-
-                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
-                o.posWS.xyz = worldPos;
-
-                o.viewDir.xyz = normalize(_WorldSpaceCameraPos - worldPos);
-                half3 normal = normalize(UnityObjectToWorldNormal(v.normal));
-
-#if _NORMALMAP
-                half sign = v.tangent.w * unity_WorldTransformParams.w;
-                half3 tangent = normalize(UnityObjectToWorldDir(v.tangent));
-                half3 binormal = cross(normal, tangent) * v.tangent.w;
-
-                // Initialize tangetToWorld in column-major to benefit from better glsl matrix multiplication code
-                o.tangentToWorld0 = half3(tangent.x, binormal.x, normal.x);
-                o.tangentToWorld1 = half3(tangent.y, binormal.y, normal.y);
-                o.tangentToWorld2 = half3(tangent.z, binormal.z, normal.z);
-#else
-                o.normal = normal;
-#endif
-
-                // TODO: change to only support point lights per vertex. This will greatly simplify shader ALU
-#if defined(_VERTEX_LIGHTS) && defined(_MULTIPLE_LIGHTS)
-                half3 diffuse = half3(1.0, 1.0, 1.0);
-                // pixel lights shaded = min(pixelLights, perObjectLights)
-                // vertex lights shaded = min(vertexLights, perObjectLights) - pixel lights shaded
-                // Therefore vertexStartIndex = pixelLightCount;  vertexEndIndex = min(vertexLights, perObjectLights)
-                int vertexLightStart = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                int vertexLightEnd = min(globalLightCount.y, unity_LightIndicesOffsetAndCount.y);
-                for (int lightIter = vertexLightStart; lightIter < vertexLightEnd; ++lightIter)
-                {
-                    int lightIndex = unity_4LightIndices0[lightIter];
-                    LightInput lightInput;
-                    INITIALIZE_LIGHT(lightInput, lightIndex);
-
-                    half3 lightDirection;
-                    half atten = ComputeLightAttenuationVertex(lightInput, normal, worldPos, lightDirection);
-                    o.fogCoord.yzw += LightingLambert(diffuse, lightDirection, normal, atten);
-                }
-#endif
-
-#ifdef _LIGHT_PROBES_ON
-                o.fogCoord.yzw += max(half3(0, 0, 0), ShadeSH9(half4(normal, 1)));
-#endif
-
-                UNITY_TRANSFER_FOG(o, o.hpos);
-                return o;
-            }
-
-            half4 frag(LightweightVertexOutput i) : SV_Target
-            {
-                half4 diffuseAlpha = tex2D(_MainTex, i.uv01.xy);
-                half3 diffuse = LIGHTWEIGHT_GAMMA_TO_LINEAR(diffuseAlpha.rgb) * _Color.rgb;
-                half alpha = diffuseAlpha.a * _Color.a;
-
-                // Keep for compatibility reasons. Shader Inpector throws a warning when using cutoff
-                // due overdraw performance impact.
-#ifdef _ALPHATEST_ON
-                clip(alpha - _Cutoff);
-#endif
-
-                half3 normal;
-                NormalMap(i, normal);
-
-                half4 specularGloss;
-                SpecularGloss(i.uv01.xy, alpha, specularGloss);
+            #include "LightweightPassLit.cginc"
+            ENDCG
+        }
-                half3 viewDir = i.viewDir.xyz;
-                float3 worldPos = i.posWS.xyz;
+        Pass
+        {
+            Tags{"Lightmode" = "ShadowCaster"}
-                half3 lightDirection;
-                
-#ifndef _MULTIPLE_LIGHTS
-                LightInput lightInput;
-                INITIALIZE_MAIN_LIGHT(lightInput);
-                half lightAtten = ComputeLightAttenuation(lightInput, normal, worldPos, lightDirection);
-#ifdef _SHADOWS
-                lightAtten *= ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-#endif
+            ZWrite On ZTest LEqual
-#ifdef LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
-                half3 color = LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightInput.color;
-#else
-                half3 color = LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightInput.color;
-#endif
-    
-#else
-                half3 color = half3(0, 0, 0);
+            CGPROGRAM
+            #pragma target 2.0
+            #pragma vertex ShadowPassVertex
+            #pragma fragment ShadowPassFragment
-#ifdef _SHADOWS
-                half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-#endif
-                int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
-                {
-                    LightInput lightData;
-                    int lightIndex = unity_4LightIndices0[lightIter];
-                    INITIALIZE_LIGHT(lightData, lightIndex);
-                    half lightAtten = ComputeLightAttenuation(lightData, normal, worldPos, lightDirection);
-#ifdef _SHADOWS
-                    lightAtten *= max(shadowAttenuation, half(lightIter != _ShadowData.x));
-#endif
-
-#ifdef LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
-                    color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightData.color;
-#else
-                    color += LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightData.color;
-#endif
-                }
-
-#endif // _MULTIPLE_LIGHTS
-
-#ifdef _EMISSION
-                color += LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, i.uv01.xy).rgb) * _EmissionColor;
-#else
-                color += _EmissionColor;
-#endif
-
-#if defined(LIGHTMAP_ON)
-                color += (DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, i.uv01.zw)) + i.fogCoord.yzw) * diffuse;
-#elif defined(_VERTEX_LIGHTS) || defined(_LIGHT_PROBES_ON)
-                color += i.fogCoord.yzw * diffuse;
-#endif
-
-#if _REFLECTION_CUBEMAP
-                // TODO: we can use reflect vec to compute specular instead of half when computing cubemap reflection
-                half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-                color += texCUBE(_Cube, reflectVec).rgb * specularGloss.rgb;
-#elif defined(_REFLECTION_PROBE)
-                half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-                half4 reflectionProbe = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, reflectVec);
-                color += reflectionProbe.rgb * (reflectionProbe.a * unity_SpecCube0_HDR.x) * specularGloss.rgb;
-#endif
-
-                UNITY_APPLY_FOG(i.fogCoord, color);
-
-                return OutputColor(color, alpha);
-            };
+            #include "UnityCG.cginc"
+            #include "LightweightPassShadow.cginc"
-            Tags { "Lightmode" = "ShadowCaster" }
+            Tags{"Lightmode" = "DepthOnly"}
-            ZWrite On ZTest LEqual
+            ZWrite On
 
             CGPROGRAM
             #pragma target 2.0
 
             float4 vert(float4 pos : POSITION) : SV_POSITION
             {
-                float4 clipPos = UnityObjectToClipPos(pos);
-#if defined(UNITY_REVERSED_Z)
-                clipPos.z = min(clipPos.z, UNITY_NEAR_CLIP_VALUE);
-#else
-                clipPos.z = max(clipPos.z, UNITY_NEAR_CLIP_VALUE);
-#endif
-                return clipPos;
+                return UnityObjectToClipPos(pos);
             }
 
             half4 frag() : SV_TARGET
             #pragma shader_feature EDITOR_VISUALIZATION
 
             #include "UnityStandardMeta.cginc"
-            #include "LightweightPipelineCore.cginc"
+            #include "LightweightCore.cginc"
 
             fixed4 frag_meta_ld(v2f_meta i) : SV_Target
             {

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardShaderPBS.shader

-Shader "ScriptableRenderPipeline/LightweightPipeline/Standard"
+Shader "ScriptableRenderPipeline/LightweightPipeline/Standard (PBS)"
+        // Specular vs Metallic workflow
+        [HideInInspector] _WorkflowMode("WorkflowMode", Float) = 1.0
+
         _Color("Color", Color) = (1,1,1,1)
         _MainTex("Albedo", 2D) = "white" {}
 
         _GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
-        [Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 0
+        _SmoothnessTextureChannel("Smoothness texture channel", Float) = 0
-        _MetallicGlossMap("Metallic", 2D) = "white" {}
+        _SpecColor("Specular", Color) = (0.2, 0.2, 0.2)
+        _MetallicSpecGlossMap("MetallicSpecGlossMap", 2D) = "white" {} // SpecGloss map when _SPECULAR_SETUP, MetallicGloss otherwise
-        [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
-        [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
+        [Toggle] _SpecularHighlights("Specular Highlights", Float) = 1.0
+        [Toggle] _GlossyReflections("Glossy Reflections", Float) = 1.0
 
         _BumpScale("Scale", Float) = 1.0
         _BumpMap("Normal Map", 2D) = "bump" {}
             #pragma target 3.0
 
             // -------------------------------------
+            #pragma shader_feature _METALLIC_SETUP _SPECULAR_SETUP
-            #pragma shader_feature _METALLICGLOSSMAP
+            #pragma shader_feature _METALLICSPECGLOSSMAP
-            #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+            #pragma shader_feature _ _SPECULARHIGHLIGHTS_ON
+            #pragma shader_feature _ _GLOSSYREFLECTIONS_ON
-            #pragma multi_compile _ LIGHTWEIGHT_LINEAR
+            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
-            #pragma multi_compile _ _SINGLE_DIRECTIONAL_LIGHT
-            #pragma multi_compile _ _LIGHT_PROBES_ON
+            #pragma multi_compile _ _ATTENUATION_TEXTURE
+
-            #pragma vertex LightweightVertex
-            #pragma fragment LightweightFragment
+            #pragma vertex LitPassVertex
+            #pragma fragment LitPassFragment
-            #include "LightweightPipelineCore.cginc"
-            #include "LightweightPipelineLighting.cginc"
-            #include "LightweightPipelineBRDF.cginc"
+            #include "LightweightPassLit.cginc"
+            ENDCG
+        }
-            LightweightVertexOutput LightweightVertex(LightweightVertexInput v)
-            {
-                LightweightVertexOutput o = (LightweightVertexOutput)0;
+        Pass
+        {
+            Tags{"Lightmode" = "ShadowCaster"}
-                UNITY_SETUP_INSTANCE_ID(v);
-                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+            ZWrite On ZTest LEqual
-                o.uv01.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
-#ifdef LIGHTMAP_ON
-                o.uv01.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
-#endif
-                o.hpos = UnityObjectToClipPos(v.vertex);
-
-                float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
-                o.posWS.xyz = worldPos;
-                
-                half3 viewDir = normalize(_WorldSpaceCameraPos - worldPos);
-                o.viewDir.xyz = viewDir;
-#ifndef _METALLICGLOSSMAP
-                o.viewDir.w = saturate(_Glossiness + MetallicSetup_Reflectivity()); // grazing term
-#endif
+            CGPROGRAM
+            #pragma target 2.0
+            #pragma vertex ShadowPassVertex
+            #pragma fragment ShadowPassFragment
-                half3 normal = normalize(UnityObjectToWorldNormal(v.normal));
+            #include "UnityCG.cginc"
+            #include "LightweightPassShadow.cginc"
+            ENDCG
+        }
-#if _NORMALMAP
-                half sign = v.tangent.w * unity_WorldTransformParams.w;
-                half3 tangent = normalize(UnityObjectToWorldDir(v.tangent));
-                half3 binormal = cross(normal, tangent) * v.tangent.w;
+        Pass
+        {
+            Tags{"Lightmode" = "DepthOnly"}
-                // Initialize tangetToWorld in column-major to benefit from better glsl matrix multiplication code
-                o.tangentToWorld0 = half3(tangent.x, binormal.x, normal.x);
-                o.tangentToWorld1 = half3(tangent.y, binormal.y, normal.y);
-                o.tangentToWorld2 = half3(tangent.z, binormal.z, normal.z);
-#else
-                o.normal = normal;
-#endif
+            ZWrite On
-                o.posWS.w = Pow4(1 - saturate(dot(normal, viewDir))); // fresnel term
+            CGPROGRAM
+            #pragma target 2.0
+            #pragma vertex vert
+            #pragma fragment frag
-#ifdef _LIGHT_PROBES_ON
-                o.fogCoord.yzw += max(half3(0, 0, 0), ShadeSH9(half4(normal, 1)));
-#endif
+            #include "UnityCG.cginc"
-                UNITY_TRANSFER_FOG(o, o.hpos);
-                return o;
+            float4 vert(float4 pos : POSITION) : SV_POSITION
+            {
+                return UnityObjectToClipPos(pos);
-            half4 LightweightFragment(LightweightVertexOutput i) : SV_Target
+            half4 frag() : SV_TARGET
-                float2 uv = i.uv01.xy;
-                float2 lightmapUV = i.uv01.zw;
-
-                half4 albedoTex = tex2D(_MainTex, i.uv01.xy);
-                half3 albedo = albedoTex.rgb * _Color.rgb;
-
-#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
-                half alpha = _Color.a;
-                half glossiness = albedorTex.a;
-#else
-                half alpha = albedoTex.a * _Color.a;
-                half glossiness = _Glossiness;
-#endif
-
-#if defined(_ALPHATEST_ON)
-                clip(alpha - _Cutoff);
-#endif
-
-                half2 metallicGloss = MetallicGloss(uv, glossiness);
-                half metallic = metallicGloss.x;
-                half smoothness = metallicGloss.y;
-                half oneMinusReflectivity;
-                half3 specColor;
-
-                half3 diffColor = DiffuseAndSpecularFromMetallic(albedo, metallicGloss.x, specColor, oneMinusReflectivity);
-                
-                half3 normal;
-                NormalMap(i, normal);
-
-                // TODO: shader keyword for occlusion
-                // TODO: Reflection Probe blend support.
-                // GI
-                half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-                half occlusion = Occlusion(uv);
-                UnityIndirect indirectLight = LightweightGI(lightmapUV, i.fogCoord.yzw, reflectVec, occlusion, 1.0h - smoothness);
-
-                // PBS
-#ifdef _METALLICGLOSSMAP
-                half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
-#else
-                half grazingTerm = i.viewDir.w;
-#endif
-
-                half perVertexFresnelTerm = i.posWS.w;
-                half3 color = LightweightBRDFIndirect(diffColor, specColor, indirectLight, grazingTerm, perVertexFresnelTerm);
-                half3 lightDirection;
-
-#ifndef _MULTIPLE_LIGHTS
-                LightInput light;
-                INITIALIZE_MAIN_LIGHT(light);
-                half lightAtten = ComputeLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
-
-#ifdef _SHADOWS
-                lightAtten *= ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-#endif
-
-                half NdotL = saturate(dot(normal, lightDirection));
-                half RdotL = saturate(dot(reflectVec, lightDirection));
-                half3 attenuatedLightColor = light.color * (NdotL * lightAtten);
-
-                color += LightweightBRDFDirect(diffColor, specColor, smoothness, RdotL) * attenuatedLightColor;
-#else
-
-#ifdef _SHADOWS
-                half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-#endif
-                int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
-                {
-                    LightInput light;
-                    int lightIndex = unity_4LightIndices0[lightIter];
-                    INITIALIZE_LIGHT(light, lightIndex);
-                    half lightAtten = ComputeLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
-#ifdef _SHADOWS
-                    lightAtten *= max(shadowAttenuation, half(lightIter != _ShadowData.x));
-#endif
-                    half NdotL = saturate(dot(normal, lightDirection));
-                    half RdotL = saturate(dot(reflectVec, lightDirection));
-                    half3 attenuatedLightColor = light.color * (NdotL * lightAtten);
-
-                    color += LightweightBRDFDirect(diffColor, specColor, smoothness, RdotL) * attenuatedLightColor;
-                }
-#endif
-
-                color += Emission(uv);
-                UNITY_APPLY_FOG(i.fogCoord, color);
-                return OutputColor(color, alpha);
+                return 0;
-
-    FallBack "VertexLit"
-    CustomEditor "StandardShaderGUI"
+    FallBack "Standard"
+    CustomEditor "LightweightStandardShaderGUI"
 }
 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightShadows.cginc

+#ifndef LIGHTWEIGHT_SHADOWS_INCLUDED
+#define LIGHTWEIGHT_SHADOWS_INCLUDED
 #define MAX_SHADOW_CASCADES 4
 
 sampler2D_float _ShadowMap;
     return ShadowAttenuation(shadowCoord.xyz);
 #endif
 }
+
+#endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

     o.diffuse = (DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, lightmapUV)));
 #endif
 
-#if defined(_VERTEX_LIGHTS) || defined(_LIGHT_PROBES_ON)
+#if defined(_VERTEX_LIGHTS) || !defined(LIGHTMAP_ON)
+#ifdef _GLOSSYREFLECTIONS_ON
+#else
+    o.specular = half3(0, 0, 0);
+#endif
 
     return o;
 }
     float3 posToLightVec = lightInput.pos.xyz - worldPos * lightInput.pos.w;
     float distanceSqr = max(dot(posToLightVec, posToLightVec), 0.001);
 
+    // TODO: Test separating dir lights into diff loop by sorting on the pipe and setting -1 on LightIndexMap.
-    float lightAtten = tex2D(_AttenuationTexture, float2(distanceSqr / attenuationParams.w, 0.0)).a;
+    float u = (distanceSqr * attenuationParams.z) / attenuationParams.w;
+    float lightAtten = tex2D(_AttenuationTexture, float2(u, 0.0)).a;
 #else
     //// attenuationParams.z = kQuadFallOff = (25.0) / (lightRange * lightRange)
     //// attenuationParams.w = lightRange * lightRange

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc

 #define _MULTIPLE_LIGHTS
 #endif
 
-#if defined(UNITY_COLORSPACE_GAMMA) && defined(LIGHTWEIGHT_LINEAR)
+#if defined(UNITY_COLORSPACE_GAMMA) && defined(_LIGHTWEIGHT_FORCE_LINEAR)
-//#define LIGHTWEIGHT_GAMMA_TO_LINEAR(gammaColor) gammaColor * gammaColor
-//#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linColor) sqrt(color)
-#define LIGHTWEIGHT_GAMMA_TO_LINEAR(sRGB) sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h)
-#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linRGB) max(1.055h * pow(max(linRGB, 0.h), 0.416666667h) - 0.055h, 0.h)
+#define LIGHTWEIGHT_GAMMA_TO_LINEAR(gammaColor) gammaColor * gammaColor
+#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linColor) sqrt(color)
+//#define LIGHTWEIGHT_GAMMA_TO_LINEAR(sRGB) sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h)
+//#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linRGB) max(1.055h * pow(max(linRGB, 0.h), 0.416666667h) - 0.055h, 0.h)
 #else
 #define LIGHTWEIGHT_GAMMA_TO_LINEAR(color) color
 #define LIGHTWEIGHT_LINEAR_TO_GAMMA(color) color
 half4 _LightSpotDir;
 #endif
 
+sampler2D _MetallicSpecGlossMap;
+
+half4 _DieletricSpec;
 half _Shininess;
 samplerCUBE _Cube;
 half4 _ReflectColor;
     // glsl compiler will generate underperforming code by using a row-major pre multiplication matrix: mul(normalmap, i.tangentToWorld)
     // i.tangetToWorld was initialized as column-major in vs and here dot'ing individual for better performance.
     // The code below is similar to post multiply: mul(i.tangentToWorld, normalmap)
-    normal = half3(dot(normalmap, i.tangentToWorld0), dot(normalmap, i.tangentToWorld1), dot(normalmap, i.tangentToWorld2));
+    normal = normalize(half3(dot(normalmap, i.tangentToWorld0), dot(normalmap, i.tangentToWorld1), dot(normalmap, i.tangentToWorld2)));
 #else
     normal = normalize(i.normal);
 #endif
 {
 #ifdef _SPECGLOSSMAP
     specularGloss = tex2D(_SpecGlossMap, uv);
-#if defined(UNITY_COLORSPACE_GAMMA) && defined(LIGHTWEIGHT_LINEAR)
+#if defined(UNITY_COLORSPACE_GAMMA) && defined(_LIGHTWEIGHT_FORCE_LINEAR)
     specularGloss.rgb = LIGHTWEIGHT_GAMMA_TO_LINEAR(specularGloss.rgb);
 #endif
 #elif defined(_SPECGLOSSMAP_BASE_ALPHA)
 #endif
 }
 
-half2 MetallicGloss(float2 uv, half glossiness)
+half4 MetallicSpecGloss(float2 uv, half albedoAlpha)
-    half2 mg;
+    half4 specGloss;
-#ifdef _METALLICGLOSSMAP
+#ifdef _METALLICSPECGLOSSMAP
-    mg.r = tex2D(_MetallicGlossMap, uv).r;
-    mg.g = glossiness;
+    specGloss.rgb = tex2D(_MetallicSpecGlossMap, uv).rgb;
+    specGloss.a = albedoAlpha;
-    mg = tex2D(_MetallicGlossMap, uv).ra;
+    specGloss = tex2D(_MetallicSpecGlossMap, uv).rgba;
-    mg.g *= _GlossMapScale;
+    specGloss.a *= _GlossMapScale;
-#else // _METALLICGLOSSMAP
+#else // _METALLICSPECGLOSSMAP
+
+#if _METALLIC_SETUP
+    specGloss.r = _Metallic;
+#else
+    specGloss.rgb = _SpecColor.rgb;
+#endif
-    mg.r = _Metallic;
-    mg.g = glossiness * _GlossMapScale;
+    specGloss.a = albedoAlpha * _GlossMapScale;
-    mg.g = glossiness;
+    specGloss.a = _Glossiness;
-    return mg;
+    return specGloss;
 }
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightCore.cginc

 #ifndef LIGHTWEIGHT_PIPELINE_CORE_INCLUDED
 #define LIGHTWEIGHT_PIPELINE_CORE_INCLUDED
 
-#include "LightweightPipelineInput.cginc"
+#include "LightweightInput.cginc"
+#include "LightweightLighting.cginc"
+#include "LightweightBRDF.cginc"
 
 #if defined(_HARD_SHADOWS) || defined(_SOFT_SHADOWS) || defined(_HARD_SHADOWS_CASCADES) || defined(_SOFT_SHADOWS_CASCADES)
 #define _SHADOWS
 #endif
 
 #ifdef _SHADOWS
-#include "LightweightPipelineShadows.cginc"
+#include "LightweightShadows.cginc"
 #endif
 
 #if defined(_SPECGLOSSMAP_BASE_ALPHA) || defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
-//  Does not support: _PARALLAXMAP, DIRLIGHTMAP_COMBINED
-#define GLOSSMAP (defined(_SPECGLOSSMAP) || defined(_METALLICGLOSSMAP))
+#define _DieletricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)
-#ifndef SPECULAR_HIGHLIGHTS
-#define SPECULAR_HIGHLIGHTS (!defined(_SPECULAR_HIGHLIGHTS_OFF))
+half SpecularReflectivity(half3 specular)
+{
+#if (SHADER_TARGET < 30)
+    // SM2.0: instruction count limitation
+    // SM2.0: simplified SpecularStrength
+    return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
+#else
+    return max(max(specular.r, specular.g), specular.b);
+}
+
+half3 MetallicSetup(float2 uv, half3 albedo, half albedoAlpha, out half3 specular, out half smoothness, out half oneMinusReflectivity)
+{
+    half2 metallicGloss = MetallicSpecGloss(uv, albedoAlpha).ra;
+    half metallic = metallicGloss.r;
+    smoothness = metallicGloss.g;
+
+    // We'll need oneMinusReflectivity, so
+    //   1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
+    // store (1-dielectricSpec) in unity_ColorSpaceDielectricSpec.a, then
+    //   1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) =
+    //                  = alpha - metallic * alpha
+    half oneMinusDielectricSpec = _DieletricSpec.a;
+    oneMinusReflectivity = oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
+    specular = lerp(_DieletricSpec.rgb, albedo, metallic);
+
+    return albedo * oneMinusReflectivity;
+}
+
+half3 SpecularSetup(float2 uv, half3 albedo, half albedoAlpha, out half3 specular, out half smoothness, out half oneMinusReflectivity)
+{
+    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha);
+    specular = specGloss.rgb;
+    smoothness = specGloss.a;
+    oneMinusReflectivity = 1.0h - SpecularReflectivity(specular);
+    return albedo * (half3(1, 1, 1) - specular);
+}
-#ifdef _ALPHABLEND_ON
+#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
     return LIGHTWEIGHT_LINEAR_TO_GAMMA(half4(color, alpha));
 #else
     return half4(LIGHTWEIGHT_LINEAR_TO_GAMMA(color), 1);

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightBRDF.cginc

-#ifndef LIGHTWEIGHT_BRDF_INCLUDED
+#ifndef LIGHTWEIGHT_BRDF_INCLUDED
+
+#define PI 3.14159265359f
 
 half MetallicSetup_Reflectivity()
 {
-//sampler2D unity_NHxRoughness;
-#if SPECULAR_HIGHLIGHTS
+#ifndef _SPECULARHIGHLIGHTS_OFF
     half RdotLPow4 = Pow4(RdotL);
     half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp
                            // Lookup texture to save instructions
 #endif
 }
 
-half3 LightweightBRDFIndirect(half3 diffColor, half3 specColor, UnityIndirect indirect, half grazingTerm, half fresnelTerm)
+// Based on Minimalist CookTorrance BRDF
+// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
+//
+// * NDF [Modified] GGX
+// * Modified Kelemen and Szirmay-​Kalos for Visibility term
+// * Fresnel approximated with 1/LdotH
+half3 LightweightBDRF(half3 diffColor, half3 specColor, half oneMinusReflectivity, half perceptualRoughness, half3 normal, half3 lightDirection, half3 viewDir)
+{
+#ifdef _SPECULARHIGHLIGHTS_ON
+    half3 halfDir = Unity_SafeNormalize(lightDirection + viewDir);
+
+    half NoH = saturate(dot(normal, halfDir));
+    half LoH = saturate(dot(lightDirection, halfDir));
+
+    // Specular term
+    half roughness = perceptualRoughness * perceptualRoughness;
+
+    // GGX Distribution multiplied by combined approximation of Visibility and Fresnel
+    // See "Optimizing PBR for Mobile" from Siggraph 2015 moving mobile graphics course
+    // https://community.arm.com/events/1155
+    half a2 = roughness * roughness;
+    half d = NoH * NoH * (a2 - 1.h) + 1.00001h;
+
+    half LoH2 = LoH * LoH;
+    half specularTerm = a2 / ((d * d) * max(0.1h, LoH2) * (roughness + 0.5h) * 4);
+
+    // on mobiles (where half actually means something) denominator have risk of overflow
+    // clamp below was added specifically to "fix" that, but dx compiler (we convert bytecode to metal/gles)
+    // sees that specularTerm have only non-negative terms, so it skips max(0,..) in clamp (leaving only min(100,...))
+#if defined (SHADER_API_MOBILE)
+    specularTerm = specularTerm - 1e-4h;
+#endif
+
+#if defined (SHADER_API_MOBILE)
+    specularTerm = clamp(specularTerm, 0.0, 100.0); // Prevent FP16 overflow on mobiles
+#endif
+
+    return diffColor + specularTerm * specColor;
+#else
+    return diffColor;
+#endif
+}
+
+half3 LightweightBRDFIndirect(half3 diffColor, half3 specColor, UnityIndirect indirect, float roughness, half grazingTerm, half fresnelTerm)
-    c += indirect.specular * lerp(specColor, grazingTerm, fresnelTerm);
+    float surfaceReduction = 1.0 / (roughness * roughness + 1.0);
+    c += surfaceReduction * indirect.specular * lerp(specColor, grazingTerm, fresnelTerm);
     return c;
 }
 

TestbedPipelines/Fptl/FptlLighting.cs

                         light.sliceIndex = m_CubeCookieTexArray.FetchSlice(cl.light.cookie);
                     }
 
-                    bound.center = worldToView.MultiplyPoint(lightPos);
-                    bound.boxAxisX.Set(range, 0, 0);
-                    bound.boxAxisY.Set(0, range, 0);
-                    bound.boxAxisZ.Set(0, 0, isNegDeterminant ? (-range) : range);    // transform to camera space (becomes a left hand coordinate frame in Unity since Determinant(worldToView)<0)
-                    bound.scaleXY.Set(1.0f, 1.0f);
-                    bound.radius = range;
-
-                    // represents a left hand coordinate system in world space since det(worldToView)<0
+
+                    bound.center   = worldToView.MultiplyPoint(lightPos);
+                    bound.boxAxisX = vx * range;
+                    bound.boxAxisY = vy * range;
+                    bound.boxAxisZ = vz * range;
+                    bound.scaleXY.Set(1.0f, 1.0f);
+                    bound.radius = range;
 
                     // fill up ldata
                     light.lightType = (uint)LightDefinitions.SPHERE_LIGHT;

TestbedPipelines/Fptl/LightingConvexHullUtils.hlsl

     vE0 = p1-p0;
 }
 
-void GetQuad(out float3 p0, out float3 p1, out float3 p2, out float3 p3, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+void GetHullQuad(out float3 p0, out float3 p1, out float3 p2, out float3 p3, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
 {
     //const int iAbsSide = (sideIndex == 0 || sideIndex == 1) ? 0 : ((sideIndex == 2 || sideIndex == 3) ? 1 : 2);
     const int iAbsSide = min(sideIndex>>1, 2);
     p3 = center + (vA2 + vB2 + vC);
 }
 
-void GetPlane(out float3 p0, out float3 vN, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+void GetHullPlane(out float3 p0, out float3 n0, const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
 {
     //const int iAbsSide = (sideIndex == 0 || sideIndex == 1) ? 0 : ((sideIndex == 2 || sideIndex == 3) ? 1 : 2);
     const int iAbsSide = min(sideIndex>>1, 2);
 
     if (bIsSideQuad) { vA2 *= (iAbsSide == 0 ? scaleXY.x : scaleXY.y); vB2 *= (iAbsSide == 0 ? scaleXY.y : scaleXY.x); }
 
-    p0 = center + (vA + vB - vC);       // center + vA is center of face when scaleXY is 1.0
-    float3 vNout = cross( vB2, 0.5*(vA-vA2) - vC );
-
-#if USE_LEFTHAND_CAMERASPACE
-    vNout = -vNout;
-#endif
-
-    vN = vNout;
+	float3 vN = cross(vB2, 0.5 * (vA - vA2) - vC);	// +/- normal
+    float3 v0 = vA + vB - vC;   // vector from center to p0
+    p0 = center + v0;           // center + vA is center of face when scaleXY is 1.0
+    n0 = dot(vN,v0) < 0.0 ? (-vN) : vN;
-float4 GetPlaneEq(const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
+float4 GetHullPlaneEq(const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int sideIndex)
-    GetPlane(p0, vN, boxX, boxY, boxZ, center, scaleXY, sideIndex);
+    GetHullPlane(p0, vN, boxX, boxY, boxZ, center, scaleXY, sideIndex);
 
     return float4(vN, -dot(vN,p0));
 }

TestbedPipelines/Fptl/lightlistbuild-clustered.compute

 	const float radius = lgtDat.radius;
 	const float2 scaleXY = lgtDat.scaleXY;
 
-	return GetPlaneEq(boxX, boxY, boxZ, center, scaleXY, p);
+	return GetHullPlaneEq(boxX, boxY, boxZ, center, scaleXY, p);
 }
 
 

TestbedPipelines/Fptl/scrbound.compute

 		if(sideIndex<6 && lgtIndex<(int) g_iNrVisibLights)		// mask 2 out of 8 threads
 		{
 			float3 q0, q1, q2, q3;
-			GetQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, sideIndex);
+			GetHullQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, sideIndex);
 
 
 			const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 				for(f=0; f<6; f++)
 				{
 					float3 q0, q1, q2, q3;
-					GetQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, f);
+					GetHullQuad(q0, q1, q2, q3, boxX, boxY, boxZ, center, scaleXY, f);
 
 					// 4 vertices to a quad of the convex hull in post projection space
 					const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 				for(f=0; f<6; f++)
 				{
 					float3 vP0, vN;
-					GetPlane(vP0, vN, boxX, boxY, boxZ, center, scaleXY, f);
+					GetHullPlane(vP0, vN, boxX, boxY, boxZ, center, scaleXY, f);
 
 					for(i=0; i<8; i++)
 					{

Tests/GraphicsTests/Framework/Editor/TestFramework.cs

                 yield return null;
             }
 
+            Camera testCamera = testSetup.cameraToUse;
-				             testSetup.hdr ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32,
+				             (testSetup.hdr && testCamera.allowHDR) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32,
+            rtDesc.msaaSamples = testSetup.msaaSamples;
 
 			// render the scene
 			var tempTarget = RenderTexture.GetTemporary (rtDesc);

Tests/GraphicsTests/Framework/SetupSceneForRenderPipelineTest.cs

 
 namespace UnityEngine.Experimental.Rendering
 {
-	public class SetupSceneForRenderPipelineTest : MonoBehaviour 
+	public class SetupSceneForRenderPipelineTest : MonoBehaviour
+	    public int msaaSamples = 1;
 
 		public int width = 1280;
 		public int height = 720;

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx.meta

 timeCreated: 1493308431
 licenseType: Pro
 ModelImporter:
-  serializedVersion: 21
+  serializedVersion: 22
   fileIDToRecycleName:
     100000: //RootNode
     400000: //RootNode
     4300000: Cornell Box
     7400000: Take 001
     9500000: //RootNode
-  externalObjects: {}
+  externalObjects:
+  - first:
+      type: UnityEngine:Material
+      assembly: UnityEngine.CoreModule
+      name: Cornell Box
+    second: {fileID: 2100000, guid: 654f7c5a4dd5d4d139a072ab9b5c5738, type: 2}
+  - first:
+      type: UnityEngine:Material
+      assembly: UnityEngine.CoreModule
+      name: Cornell Box_green
+    second: {fileID: 2100000, guid: 58bbc5d4f141a4cbc9e0f0cc569fdbca, type: 2}
+  - first:
+      type: UnityEngine:Material
+      assembly: UnityEngine.CoreModule
+      name: Cornell Box_red
+    second: {fileID: 2100000, guid: 9b02cdc6dbf754bf1aa60a08bf1c909d, type: 2}
-    autoMapExternalMaterials: 1
     materialName: 0
     materialSearch: 1
     materialLocation: 0
     importCameras: 1
     importLights: 1
     swapUVChannels: 0
-    generateSecondaryUV: 1
+    generateSecondaryUV: 0
+    indexFormat: 1
-    secondaryUVAreaDistortion: 15.000001
+    secondaryUVAreaDistortion: 15
-    secondaryUVPackMargin: 4
+    secondaryUVPackMargin: 8
     useFileScale: 1
   tangentSpace:
     normalSmoothAngle: 60

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx

-Kaydara FBX Binary  �dFBXHeaderExtension\
FBXHeaderVersionI�x

-FBXVersionI��
EncryptionTypeI�
CreationTimeStamp�
VersionI��
YearI��
MonthI

DayI'

HourI?

MinuteIW

SecondI!t

MillisecondI�

'CreatorS"FBX SDK/FBX Plugins version 2015.1W'	SceneInfoSGlobalInfo
SceneInfoSUserData

TypeSUserData0
VersionIdMetaData^
VersionId�
TitleSCornell Box�
SubjectS�
AuthorS�
KeywordsS�
RevisionS�
CommentSJProperties70��
PSDocumentUrlSKStringSUrlSS|/Users/andremcgrail/Documents/UnityProjects/Testing Projects/Shader_FTP/Assets/Shaders/StandardShader/Meshes/Cornell Box.fbx��
PSSrcDocumentUrlSKStringSUrlSS|/Users/andremcgrail/Documents/UnityProjects/Testing Projects/Shader_FTP/Assets/Shaders/StandardShader/Meshes/Cornell Box.fbx�$
PSOriginalSCompoundSSE
PSOriginal|ApplicationVendorSKStringSSSThe Foundryf<
PSOriginal|ApplicationNameSKStringSSSMODO�;
PSOriginal|ApplicationVersionSKStringSSS
-M
PSOriginal|DateTime_GMTSDateTimeSSS17/11/2016 14:19:33.000��
PSOriginal|FileNameSKStringSSS|/Users/andremcgrail/Documents/UnityProjects/Testing Projects/Shader_FTP/Assets/Shaders/StandardShader/Meshes/Cornell Box.fbx�%
PS	LastSavedSCompoundSSLF
PSLastSaved|ApplicationVendorSKStringSSSThe Foundry�=
PSLastSaved|ApplicationNameSKStringSSSMODO�<
PSLastSaved|ApplicationVersionSKStringSSS=N
PSLastSaved|DateTime_GMTSDateTimeSSS17/11/2016 14:19:33.000�
FileIdR+�+��!���ʱ"�#���
CreationTimeS2016-11-17 14:19:33:000	
6CreatorS1FBX SDK/FBX Plugins version 2015.1 build=20140408pGlobalSettings?	
VersionI�cProperties70�	)
PSUpAxisSintSIntegerSI
�	-
PS
-UpAxisSignSintSIntegerSI

-,
PS	FrontAxisSintSIntegerSIB
-0
PS
FrontAxisSignSintSIntegerSI
|
-,
PS	CoordAxisSintSIntegerSI�
-0
PS
CoordAxisSignSintSIntegerSI
�
-1
PSOriginalUpAxisSintSIntegerSI����<5
PSOriginalUpAxisSignSintSIntegerSI
�8
PSUnitScaleFactorSdoubleSNumberSD�?�@
PSOriginalUnitScaleFactorSdoubleSNumberSD�?&H
PSAmbientColorSColorRGBSColorSDDDuA
PS
DefaultCameraSKStringSSSProducer Perspective�%
PSTimeModeSenumSSI�)
PSTimeProtocolSenumSSI
,
PSSnapOnFrameModeSenumSSIZ
3
PS
TimeSpanStartSKTimeSTimeSL�
2
PSTimeSpanStopSKTimeSTimeSL�
8
PSCustomFrameRateSdoubleSNumberSD&
PS
-TimeMarkerSCompoundSSV4
PSCurrentTimeMarkerSintSIntegerSI�����	Documents�
CountI
�DocumentLsڔ�SSSceneeProperties70&
PSSourceObjectSobjectSSX3
PSActiveAnimStackNameSKStringSSS�
	RootNodeL�
-References"3Definitions�
VersionId	
CountIW

-ObjectTypeSGlobalSettingsJ
CountI
�

-ObjectTypeSGeometry�
CountI
�
PropertyTemplateSFbxMesh�Properties70#A
PSColorSColorRGBSColorSD�������?D�������?D�������?uD
PSBBoxMinSVector3DSVectorSDDD�D
PSBBoxMaxSVector3DSVectorSDDD/
PSPrimary VisibilitySboolSSI
<*
PS
Casts ShadowsSboolSSI
v,
PSReceive ShadowsSboolSSI
@&

+Kaydara FBX Binary  ��FBXHeaderExtension\
FBXHeaderVersionI�x

+FBXVersionI��
EncryptionTypeI�
CreationTimeStamp�
VersionI��
YearI��
MonthI	

DayI'

HourI?

MinuteI2W

SecondI	t

MillisecondI�

'CreatorS"FBX SDK/FBX Plugins version 2015.1�'	SceneInfoSGlobalInfo
SceneInfoSUserData

TypeSUserData0
VersionIdMetaData^
VersionId�
TitleSCornell Box�
SubjectS�
AuthorS�
KeywordsS�
RevisionS�
CommentS�Properties70�
PSDocumentUrlSKStringSUrlSS�/Users/andremcgrail/Documents/UnityProjects/SRP/LightweightPipeline/Assets/Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx��
PSSrcDocumentUrlSKStringSUrlSS�/Users/andremcgrail/Documents/UnityProjects/SRP/LightweightPipeline/Assets/Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbx$
PSOriginalSCompoundSSnE
PSOriginal|ApplicationVendorSKStringSSSThe Foundry�<
PSOriginal|ApplicationNameSKStringSSSMODO
;
PSOriginal|ApplicationVersionSKStringSSS\M
PSOriginal|DateTime_GMTSDateTimeSSS15/09/2017 12:50:09.000@�
PSOriginal|FileNameSKStringSSS�/Users/andremcgrail/Documents/UnityProjects/SRP/LightweightPipeline/Assets/Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/CommonAssets/Cornell Box.fbxs%
PS	LastSavedSCompoundSS�F
PSLastSaved|ApplicationVendorSKStringSSSThe Foundry=
PSLastSaved|ApplicationNameSKStringSSSMODO\<
PSLastSaved|ApplicationVersionSKStringSSS�N
PSLastSaved|DateTime_GMTSDateTimeSSS15/09/2017 12:50:09.000	
FileIdR(�#��'�Ĺε&�&��<	
CreationTimeS2017-09-15 12:50:09:000�	
6CreatorS1FBX SDK/FBX Plugins version 2015.1 build=20140408�GlobalSettings�	
VersionI��Properties70
+
+)
PSUpAxisSintSIntegerSI
E
+-
PS
+UpAxisSignSintSIntegerSI

+,
PS	FrontAxisSintSIntegerSI�
+0
PS
FrontAxisSignSintSIntegerSI
�
+,
PS	CoordAxisSintSIntegerSI50
PS
CoordAxisSignSintSIntegerSI
t1
PSOriginalUpAxisSintSIntegerSI�����5
PSOriginalUpAxisSignSintSIntegerSI
�8
PSUnitScaleFactorSdoubleSNumberSD�?K@
PSOriginalUnitScaleFactorSdoubleSNumberSD�?�H
PSAmbientColorSColorRGBSColorSDDD�A
PS
DefaultCameraSKStringSSSProducer Perspective#
%
PSTimeModeSenumSSIZ
)
PSTimeProtocolSenumSSI�
,
PSSnapOnFrameModeSenumSSI�
3
PS
TimeSpanStartSKTimeSTimeSL2
PSTimeSpanStopSKTimeSTimeSL[8
PSCustomFrameRateSdoubleSNumberSD�&
PS
+TimeMarkerSCompoundSS�4
PSCurrentTimeMarkerSintSIntegerSI����	Documents
CountI
DocumentLa?`SSScene�Properties70�&
PSSourceObjectSobjectSS�3
PSActiveAnimStackNameSKStringSSS�
	RootNodeL<
+References�3Definitionsm
VersionId�
CountI�

+ObjectTypeSGlobalSettings�
CountI


+ObjectTypeSGeometry

CountI

PropertyTemplateSFbxMesh�Properties70�A
PSColorSColorRGBSColorSD�������?D�������?D�������?�D
PSBBoxMinSVector3DSVectorSDDDBD
PSBBoxMaxSVector3DSVectorSDDD/
PSPrimary VisibilitySboolSSI
�*
PS
Casts ShadowsSboolSSI
�,
PSReceive ShadowsSboolSSI
�&

-ObjectTypeSModel�
CountI3&
PropertyTemplateSFbxNode&&Properties70W2
PSQuaternionInterpolateSenumSSI�K
PSRotationOffsetSVector3DSVectorSDDDJ
PS
RotationPivotSVector3DSVectorSDDD`J
PS
ScalingOffsetSVector3DSVectorSDDD�I
PSScalingPivotSVector3DSVectorSDDD�.
PSTranslationActiveSboolSSILK
PSTranslationMinSVector3DSVectorSDDD�K
PSTranslationMaxSVector3DSVectorSDDD�,
PSTranslationMinXSboolSSI,
PSTranslationMinYSboolSSIS,
PSTranslationMinZSboolSSI�,
PSTranslationMaxXSboolSSI�,
PSTranslationMaxYSboolSSI
,
PSTranslationMaxZSboolSSI9*
PS
RotationOrderSenumSSI}6
PSRotationSpaceForLimitOnlySboolSSI�;
PSRotationStiffnessXSdoubleSNumberSD;
PSRotationStiffnessYSdoubleSNumberSDX;
PSRotationStiffnessZSdoubleSNumberSD�0
PSAxisLenSdoubleSNumberSD$@�H
PSPreRotationSVector3DSVectorSDDDCI
PSPostRotationSVector3DSVectorSDDD|+
PSRotationActiveSboolSSI�H
PSRotationMinSVector3DSVectorSDDD(H
PSRotationMaxSVector3DSVectorSDDD_)
PSRotationMinXSboolSSI�)
PSRotationMinYSboolSSI�)
PSRotationMinZSboolSSI)
PSRotationMaxXSboolSSI;)
PSRotationMaxYSboolSSIr)
PSRotationMaxZSboolSSI�(
PSInheritTypeSenumSSI�*
PS
ScalingActiveSboolSSI5G
PS
-ScalingMinSVector3DSVectorSDDD�G
PS
-ScalingMaxSVector3DSVectorSD�?D�?D�?�(
PSScalingMinXSboolSSI�(
PSScalingMinYSboolSSI,(
PSScalingMinZSboolSSIb(
PSScalingMaxXSboolSSI�(
PSScalingMaxYSboolSSI�(
PSScalingMaxZSboolSSI-Q
PSGeometricTranslationSVector3DSVectorSDDD�N
PSGeometricRotationSVector3DSVectorSDDD�M
PSGeometricScalingSVector3DSVectorSD�?D�?D�?(6
PS
MinDampRangeXSdoubleSNumberSDl6
PS
MinDampRangeYSdoubleSNumberSD�6
PS
MinDampRangeZSdoubleSNumberSD�6
PS
MaxDampRangeXSdoubleSNumberSD8 6
PS
MaxDampRangeYSdoubleSNumberSD| 6
PS
MaxDampRangeZSdoubleSNumberSD� 9
PSMinDampStrengthXSdoubleSNumberSD
-!9
PSMinDampStrengthYSdoubleSNumberSDQ!9
PSMinDampStrengthZSdoubleSNumberSD�!9
PSMaxDampStrengthXSdoubleSNumberSD�!9
PSMaxDampStrengthYSdoubleSNumberSD&"9
PSMaxDampStrengthZSdoubleSNumberSDk"7
PSPreferedAngleXSdoubleSNumberSD�"7
PSPreferedAngleYSdoubleSNumberSD�"7
PSPreferedAngleZSdoubleSNumberSD+#(
PSLookAtPropertySobjectSSc#*
PSUpVectorPropertySobjectSS�#!
PSShowSboolSSI
�#8
PSNegativePercentShapeSupportSboolSSI
$8
PSDefaultAttributeIndexSintSIntegerSI����O$#
PSFreezeSboolSSI�$#
PSLODBoxSboolSSI�$N
PSLcl TranslationSLcl TranslationSS
ADDD2%H
PSLcl RotationSLcl RotationSS
ADDD�%F
PSLcl ScalingSLcl ScalingSS
AD�?D�?D�?�%2
PS
+ObjectTypeSModelP
CountI�&
PropertyTemplateSFbxNode�&Properties70�2
PSQuaternionInterpolateSenumSSI+K
PSRotationOffsetSVector3DSVectorSDDD�J
PS
RotationPivotSVector3DSVectorSDDD�J
PS
ScalingOffsetSVector3DSVectorSDDD2I
PSScalingPivotSVector3DSVectorSDDDn.
PSTranslationActiveSboolSSI�K
PSTranslationMinSVector3DSVectorSDDD K
PSTranslationMaxSVector3DSVectorSDDDZ,
PSTranslationMinXSboolSSI�,
PSTranslationMinYSboolSSI�,
PSTranslationMinZSboolSSI,
PSTranslationMaxXSboolSSIB,
PSTranslationMaxYSboolSSI|,
PSTranslationMaxZSboolSSI�*
PS
RotationOrderSenumSSI�6
PSRotationSpaceForLimitOnlySboolSSIA;
PSRotationStiffnessXSdoubleSNumberSD�;
PSRotationStiffnessYSdoubleSNumberSD�;
PSRotationStiffnessZSdoubleSNumberSD0
PSAxisLenSdoubleSNumberSD$@gH
PSPreRotationSVector3DSVectorSDDD�I
PSPostRotationSVector3DSVectorSDDD�+
PSRotationActiveSboolSSIMH
PSRotationMinSVector3DSVectorSDDD�H
PSRotationMaxSVector3DSVectorSDDD�)
PSRotationMinXSboolSSI)
PSRotationMinYSboolSSIH)
PSRotationMinZSboolSSI)
PSRotationMaxXSboolSSI�)
PSRotationMaxYSboolSSI�)
PSRotationMaxZSboolSSI#(
PSInheritTypeSenumSSI[*
PS
ScalingActiveSboolSSI�G
PS
+ScalingMinSVector3DSVectorSDDDG
PS
+ScalingMaxSVector3DSVectorSD�?D�?D�?;(
PSScalingMinXSboolSSIq(
PSScalingMinYSboolSSI�(
PSScalingMinZSboolSSI�(
PSScalingMaxXSboolSSI(
PSScalingMaxYSboolSSII(
PSScalingMaxZSboolSSI�Q
PSGeometricTranslationSVector3DSVectorSDDDN
PSGeometricRotationSVector3DSVectorSDDD_M
PSGeometricScalingSVector3DSVectorSD�?D�?D�?�6
PS
MinDampRangeXSdoubleSNumberSD�6
PS
MinDampRangeYSdoubleSNumberSD+ 6
PS
MinDampRangeZSdoubleSNumberSDo 6
PS
MaxDampRangeXSdoubleSNumberSD� 6
PS
MaxDampRangeYSdoubleSNumberSD� 6
PS
MaxDampRangeZSdoubleSNumberSD>!9
PSMinDampStrengthXSdoubleSNumberSD�!9
PSMinDampStrengthYSdoubleSNumberSD�!9
PSMinDampStrengthZSdoubleSNumberSD"9
PSMaxDampStrengthXSdoubleSNumberSDZ"9
PSMaxDampStrengthYSdoubleSNumberSD�"9
PSMaxDampStrengthZSdoubleSNumberSD�"7
PSPreferedAngleXSdoubleSNumberSD+#7
PSPreferedAngleYSdoubleSNumberSDp#7
PSPreferedAngleZSdoubleSNumberSD�#(
PSLookAtPropertySobjectSS�#*
PSUpVectorPropertySobjectSS
$!
PSShowSboolSSI
S$8
PSNegativePercentShapeSupportSboolSSI
�$8
PSDefaultAttributeIndexSintSIntegerSI�����$#
PSFreezeSboolSSI�$#
PSLODBoxSboolSSIW%N
PSLcl TranslationSLcl TranslationSS
ADDD�%H
PSLcl RotationSLcl RotationSS
ADDD
&F
PSLcl ScalingSLcl ScalingSS
AD�?D�?D�?A&2
PS
-VisibilitySS
AD�?&E
PSVisibility InheritanceSVisibility InheritanceSSI
B-

-ObjectTypeSMaterial{&
CountI5-
PropertyTemplateSFbxSurfacePhong(-Properties70'1
PSShadingModelSKStringSSSPhong9''
PS
-MultiLayerSboolSSI�'B
PS
EmissiveColorSColorSS
ADDD�'2
PSEmissiveFactorSNumberSS
AD�?(A
PSAmbientColorSColorSS
AD�������?D�������?D�������?W(1
PS
AmbientFactorSNumberSS
AD�?�(A
PSDiffuseColorSColorSS
AD�������?D�������?D�������?�(1
PS
DiffuseFactorSNumberSS
AD�?4)A
PSBumpSVector3DSVectorSDDD�)F
PS	NormalMapSVector3DSVectorSDDD�)3
PS
-BumpFactorSdoubleSNumberSD�?*E
PSTransparentColorSColorSS
ADDD`*6
PSTransparencyFactorSNumberSS
AD�*M
PSDisplacementColorSColorRGBSColorSDDD+;
PSDisplacementFactorSdoubleSNumberSD�?e+S
PSVectorDisplacementColorSColorRGBSColorSDDD�+A
PSVectorDisplacementFactorSdoubleSNumberSD�?,B
PS
SpecularColorSColorSS
AD�������?D�������?D�������?D,2
PSSpecularFactorSNumberSS
AD�?�,5
PSShininessExponentSNumberSS
AD4@�,D
PSReflectionColorSColorSS
ADDD-4
PSReflectionFactorSNumberSS
AD�?(/

-ObjectTypeSAnimationStack�-
CountI
/
PropertyTemplateSFbxAnimStack/Properties70.+
PSDescriptionSKStringSSSA.0
PS
-LocalStartSKTimeSTimeSL~./
PS	LocalStopSKTimeSTimeSL�.4
PSReferenceStartSKTimeSTimeSL
/3
PS
ReferenceStopSKTimeSTimeSL�1

-ObjectTypeSAnimationLayeri/
CountI
�1
PropertyTemplateSFbxAnimLayer�1Properties70�/*
PSWeightSNumberSS
ADY@0!
PSMuteSboolSSIF0!
PSSoloSboolSSIu0!
PSLockSboolSSI�0A
PSColorSColorRGBSColorSD�������?D�������?D�������?�0&
PS	BlendModeSenumSSI;15
PSRotationAccumulationModeSenumSSI{12
PSScaleAccumulationModeSenumSSI�15
PSBlendModeBypassS	ULongLongSSL�2

-ObjectTypeSAnimationCurveNode*2
CountI�2
PropertyTemplateSFbxAnimCurveNode�2Properties70�2
PS
dSCompoundSS3

-ObjectTypeSAnimationCurve3
CountI	fObjectsB!GeometryLpx5��S
-
GeometrySMesh�3Properties70�3@
PSPolygonPartNamesS
-stringlistSS
UISDefault�5
�
Verticesd<�
Y�Y�Y@Y�Y@Y@Y�Y@Y�i@Y�Y@i@Y�Y@i@Y@Y�i@Y@��A�i@��A���A@i@��A���A@i@��A@��A�i@��A@��A����j@��A���A@���j@��A���A@���j@��A@��A����j@��A@���]@���j@���]����]����j@���]����]����j@���]@���]@���j@���]@7

PolygonVertexIndexiD
����
����
������������	����
+VisibilitySS
AD�?�&E
PSVisibility InheritanceSVisibility InheritanceSSI
�-

+ObjectTypeSMaterial�&
CountI�-
PropertyTemplateSFbxSurfacePhong�-Properties70'1
PSShadingModelSKStringSSSPhong�''
PS
+MultiLayerSboolSSI(B
PS
EmissiveColorSColorSS
ADDDD(2
PSEmissiveFactorSNumberSS
AD�?�(A
PSAmbientColorSColorSS
AD�������?D�������?D�������?�(1
PS
AmbientFactorSNumberSS
AD�?!)A
PSDiffuseColorSColorSS
AD�������?D�������?D�������?`)1
PS
DiffuseFactorSNumberSS
AD�?�)A
PSBumpSVector3DSVectorSDDD*F
PS	NormalMapSVector3DSVectorSDDDD*3
PS
+BumpFactorSdoubleSNumberSD�?�*E
PSTransparentColorSColorSS
ADDD�*6
PSTransparencyFactorSNumberSS
AD6+M
PSDisplacementColorSColorRGBSColorSDDD+;
PSDisplacementFactorSdoubleSNumberSD�?�+S
PSVectorDisplacementColorSColorRGBSColorSDDD/,A
PSVectorDisplacementFactorSdoubleSNumberSD�?,B
PS
SpecularColorSColorSS
AD�������?D�������?D�������?�,2
PSSpecularFactorSNumberSS
AD�?-5
PSShininessExponentSNumberSS
AD4@T-D
PSReflectionColorSColorSS
ADDD�-4
PSReflectionFactorSNumberSS
AD�?�/

+ObjectTypeSAnimationStack�-
CountI
�/
PropertyTemplateSFbxAnimStack�/Properties70~.+
PSDescriptionSKStringSSS�.0
PS
+LocalStartSKTimeSTimeSL�./
PS	LocalStopSKTimeSTimeSL;/4
PSReferenceStartSKTimeSTimeSL|/3
PS
ReferenceStopSKTimeSTimeSL`2

+ObjectTypeSAnimationLayer�/
CountI
S2
PropertyTemplateSFbxAnimLayerF2Properties70c0*
PSWeightSNumberSS
ADY@�0!
PSMuteSboolSSI�0!
PSSoloSboolSSI�0!
PSLockSboolSSI?1A
PSColorSColorRGBSColorSD�������?D�������?D�������?s1&
PS	BlendModeSenumSSI�15
PSRotationAccumulationModeSenumSSI�12
PSScaleAccumulationModeSenumSSI925
PSBlendModeBypassS	ULongLongSSLB3

+ObjectTypeSAnimationCurveNode�2
CountI53
PropertyTemplateSFbxAnimCurveNode(3Properties703
PS
dSCompoundSS�3

+ObjectTypeSAnimationCurve�3
CountI	�lObjects�H!GeometryL@��X�S
+
GeometrySMesh[4Properties70N4@
PSPolygonPartNamesS
+stringlistSS
UISDefault]6
�
Verticesd<�
Y�Y�Y@Y�Y@Y@Y�Y@Y�i@Y�Y@i@Y�Y@i@Y@Y�i@Y@��A�i@��A���A@i@��A���A@i@��A@��A�i@��A@��A����j@��A���A@���j@��A���A@���j@��A@��A����j@��A@���]@���j@���]����]����j@���]����]����j@���]@���]@���j@���]@�7

PolygonVertexIndexiD
����
����
������������	����
-��������
�����������������7
�Edgesi$�

-"%&')*-.24569:=>A�7
GeometryVersionI|�:
LayerElementNormalI+8
VersionIfH8
NameSNormals8
MappingInformationTypeSByPolygonVertex�8
ReferenceInformationTypeS
IndexToDirectg9
�Normalsd��?�?�����?���9
=NormalsWd0�:

NormalsIndexiD








Z?
LayerElementUVI5;
VersionIeR;
NameSTexture�;
MappingInformationTypeSByPolygonVertex�;
ReferenceInformationTypeS
IndexToDirect>
MUVdH@����?��L�?�?`UU�?�?�?�?�?`UU�?�?���?@D��?�?����?@D��?�?`UU�?����?��L�?���?��L�?�?`UU�?�?�?�?�?�?�?`UU�?`UU�?�?����?@D��?�?�?`UU�?�?�?�?�?`UU�?���?��L�?���?@D��?�?`UU�?�?�?`UU�?�?�?�?M?

UVIndexiD

-


-
-! 	



 		

	"#�@
LayerElementMaterialI�?
VersionIe�?
NameS�?
MappingInformationTypeS	ByPolygon@
ReferenceInformationTypeS
IndexToDirect~@
Q	MaterialsiD
B
LayerI�@
VersionId%ALayerElement�@
TypeSLayerElementNormalA

-TypedIndexI�ALayerElementhA
TypeSLayerElementMaterial�A

-TypedIndexI�ALayerElement�A
TypeSLayerElementUV�A

-TypedIndexI�C)ModelL����SCornell Box
ModelSMesheB
VersionI�_CProperties70�B+
PSRotationActiveSboolSSI
CG
PS
-ScalingMaxSVector3DSVectorSDDDRC8
PSDefaultAttributeIndexSintSIntegerSIuC
ShadingCY�C
CullingS
-CullingOff�E1ModelL2���SMODO_RenderSettings
ModelSNull
D
VersionI�qEProperties70oDG
PS
-ScalingMaxSVector3DSVectorSDDD�D2
PS
+��������
����������������H8
�Edgesi$�

+"%&')*-.24569:=>Ai8
GeometryVersionI|{;
LayerElementNormalI�8
VersionIf�8
NameSFBX_Normals�8
MappingInformationTypeSByPolygonVertex59
ReferenceInformationTypeS
IndexToDirect�9
�Normalsd��?�?�����?��8:
=NormalsWd0n;

NormalsIndexiD








�@
LayerElementUVI�;
VersionIe�;
	NameSUV01<
MappingInformationTypeSByPolygonVertex<<
ReferenceInformationTypeS
IndexToDirect�?
MUVdh@@33�?�z�?@33�?@33�?@33�?�z�?@33�?@33�?@33�? ���?@33�? ���?�� ���?�?���? ���?`f��?���������(���?��(���?��@33�?�z�?@33�?@33�?@33�?�z�?�? ���?���?�� ���?�����`f��?�?��(������(�����?@33�?�z�?@33�?@33�?@33�?�z�?@33�?@33�?@33�? ���?@33�? ���?�� ���?�����? ���?����������@33�?@33�?@33�? ���?@33�? ���?�? ���?�?�?�� ���?`f��?`f��?�?��(������(������@33�?�z�?@33�?@33�?@33�?�z�?@33�?@33�?@33�? ���?@33�? ���?�?�?����(���?��(���@

UVIndexiD
1*
+()$&32.%%!.!0-
+#"/, 		'

' ,QE
LayerElementUVI
A
VersionIe)A
	NameSUV02`A
MappingInformationTypeSByPolygonVertex�A
ReferenceInformationTypeS
IndexToDirectD
mUVdL`���? N�?��?���?����?@W�?����?�>�?`b��?��z�?��z�?����?���?���?`J�?����?��=�?��1�?@���?Y�?@���?���?�^�?�J�?@�z�?�¤?�Q��? :P�?��=�?`A��?����?���?���? ���?l��?b�?��?`�I�?���?�>�?��r�?��z�?`�z�?`�:�?���?`J�?`J�? :P�?@q��?�(�?�q��?@�z�?����?@�z�? �z�? ���? ��?`��?�Q��?`���?`�=�? ��?�q�?�e�?@���?`�I�?��?�(�?����?�z�?���?��7�?@�=�?@�z�? q��?�J�?DE

UVIndexiD
#%$!!"	"	 
+
+



 �F
LayerElementMaterialI�E
VersionIe�E
NameS�E
MappingInformationTypeS	ByPolygonF
ReferenceInformationTypeS
IndexToDirectuF
Q	MaterialsiD
�G
LayerI�F
VersionIdGLayerElement�F
TypeSLayerElementNormalG

+TypedIndexI�GLayerElement_G
TypeSLayerElementMaterial{G

+TypedIndexI�GLayerElement�G
TypeSLayerElementUV�G

+TypedIndexI�H
LayerI
+H
VersionId�HLayerElementhH
TypeSLayerElementUV�H

+TypedIndexI
?J)ModelLV�U�SCornell Box
ModelSMesh�H
VersionI��IProperties70QI+
PSRotationActiveSboolSSI
�IG
PS
+ScalingMaxSVector3DSVectorSDDD�I8
PSDefaultAttributeIndexSintSIntegerSIJ
ShadingCY2J
CullingS
+CullingOffQL1ModelL��U�SMODO_RenderSettings
ModelSNull�J
VersionI�LProperties70	KG
PS
+ScalingMaxSVector3DSVectorSDDDIK2
PS
-VisibilitySS
AD�D-
PSCameraSKStringSS
USCamera'E/
PSResolutionXSintSIntegerS
UIdE/
PSResolutionYSintSIntegerS
UI��E
ShadingCY�E
CullingS
-CullingOffK(MaterialL��5��SCornell Box
MaterialS
F
VersionIf0F

-ShadingModelSphongLF

-MultiLayerIKProperties70�FB
PS
EmissiveColorSColorSS
AD�?D�?D�?�F2
PSEmissiveFactorSNumberSS
ADDGA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?�G1
PS
DiffuseFactorSNumberSS
AD�������?�GB
PS
SpecularColorSColorSS
AD�?D�?D�?H2
PSSpecularFactorSNumberSS
AD{�G�z�?VH5
PSShininessExponentSNumberSS
ADp@�HD
PSReflectionColorSColorSS
AD�?D�?D�?�H4
PSReflectionFactorSNumberSS
AD=IE
PSEmissiveSVector3DSVectorSDDD�ID
PSAmbientSVector3DSVectorSD�������?D�������?D�������?�ID
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?4JE
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?tJ2
PS	ShininessSdoubleSNumberSDp@�J0
PSOpacitySdoubleSNumberSD�?�J5
PSReflectivitySdoubleSNumberSDkP,MaterialL�5��SCornell Box_red
MaterialSiK
VersionIf�K

-ShadingModelSphong�K

-MultiLayerI^PProperties70LB
PS
EmissiveColorSColorSS
AD�?D�?D�?QL2
PSEmissiveFactorSNumberSS
AD�LA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?�L1
PS
DiffuseFactorSNumberSS
AD�������?/MB
PS
SpecularColorSColorSS
AD�?D�?D�?oM2
PSSpecularFactorSNumberSS
AD{�G�z�?�M5
PSShininessExponentSNumberSS
ADp@ND
PSReflectionColorSColorSS
AD�?D�?D�?FN4
PSReflectionFactorSNumberSS
AD�NE
PSEmissiveSVector3DSVectorSDDD�ND
PSAmbientSVector3DSVectorSD�������?D�������?D�������?=OD
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?�OE
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?�O2
PS	ShininessSdoubleSNumberSDp@P0
PSOpacitySdoubleSNumberSD�?QP5
PSReflectivitySdoubleSNumberSD�U.MaterialLp�5��SCornell Box_green
MaterialS�P
VersionIf�P

-ShadingModelSphongQ

-MultiLayerI�UProperties70oQB
PS
EmissiveColorSColorSS
AD�?D�?D�?�Q2
PSEmissiveFactorSNumberSS
AD�QA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?=R1
PS
DiffuseFactorSNumberSS
AD�������?�RB
PS
SpecularColorSColorSS
AD�?D�?D�?�R2
PSSpecularFactorSNumberSS
AD{�G�z�?S5
PSShininessExponentSNumberSS
ADp@bSD
PSReflectionColorSColorSS
AD�?D�?D�?�S4
PSReflectionFactorSNumberSS
AD�SE
PSEmissiveSVector3DSVectorSDDDITD
PSAmbientSVector3DSVectorSD�������?D�������?D�������?�TD
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?�TE
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?.U2
PS	ShininessSdoubleSNumberSDp@lU0
PSOpacitySdoubleSNumberSD�?�U5
PSReflectivitySdoubleSNumberSDV&AnimationStackL`�5��STake 001
AnimStackSfV'AnimationLayerL�5��SLayer 001
AnimLayerSzW#AnimationCurveNodeL��5��ST
AnimCurveNodeSmWProperties70�V'
PSd|XSNumberSS
AD+W'
PSd|YSNumberSS
AD`W'
PSd|ZSNumberSS
AD�X#AnimationCurveNodeLP6��SR
AnimCurveNodeS�XProperties70
-X'
PSd|XSNumberSS
AD?X'
PSd|YSNumberSS
ADtX'
PSd|ZSNumberSS
AD�Y#AnimationCurveNodeL�6��SS
AnimCurveNodeS�YProperties70Y'
PSd|XSNumberSS
AD�?SY'
PSd|YSNumberSS
AD�?�Y'
PSd|ZSNumberSS
AD�?[AnimationCurveL��5��S
AnimCurveS�Y
	DefaultDZ
KeyVerI�9Z
KeyTimel
dZ

KeyValueFloatf
�Z
KeyAttrFlagsi

�Z
KeyAttrDataFloatf

�Z
KeyAttrRefCounti

b\AnimationCurveL��5��S
AnimCurveSX[
	DefaultDp[
KeyVerI��[
KeyTimel
�[

KeyValueFloatf
�[
KeyAttrFlagsi

(\
KeyAttrDataFloatf

U\
KeyAttrRefCounti

�]AnimationCurveL�6��S
AnimCurveS�\
	DefaultD�\
KeyVerI��\
KeyTimel
$]

KeyValueFloatf
N]
KeyAttrFlagsi

�]
KeyAttrDataFloatf

�]
KeyAttrRefCounti

"_AnimationCurveL�6��S
AnimCurveS^
	DefaultD0^
KeyVerI�Y^
KeyTimel
�^

KeyValueFloatf
�^
KeyAttrFlagsi

�^
KeyAttrDataFloatf

_
KeyAttrRefCounti

�`AnimationCurveL�6��S
AnimCurveSx_
	DefaultD�_
KeyVerI��_
KeyTimel
�_

KeyValueFloatf
�`
KeyAttrFlagsi

H`
KeyAttrDataFloatf

u`
KeyAttrRefCounti

�aAnimationCurveL6��S
AnimCurveS�`
	DefaultD�`
KeyVerI�a
KeyTimel
Da

KeyValueFloatf
na
KeyAttrFlagsi

�a
KeyAttrDataFloatf

�a
KeyAttrRefCounti

BcAnimationCurveL�#6��S
AnimCurveS8b
	DefaultD�?Pb
KeyVerI�yb
KeyTimel
�b

KeyValueFloatf
�?�b
KeyAttrFlagsi

c
KeyAttrDataFloatf

5c
KeyAttrRefCounti

�dAnimationCurveL )6��S
AnimCurveS�c
	DefaultD�?�c
KeyVerI��c
KeyTimel
d

KeyValueFloatf
�?.d
KeyAttrFlagsi

hd
KeyAttrDataFloatf

�d
KeyAttrRefCounti

fAnimationCurveL@-6��S
AnimCurveS�d
	DefaultD�?e
KeyVerI�9e
KeyTimel
de

KeyValueFloatf
�?�e
KeyAttrFlagsi

�e
KeyAttrDataFloatf

�e
KeyAttrRefCounti

�iConnectionsNf
CSOOL����Luf
CSOOLpx5��L�����f
CSOOL��5��L�����f
CSOOL�5��L�����f
CSOOLp�5��L����%g-
CSOPL��5��L����SLcl Translation]g*
CSOPLP6��L����SLcl Rotation�g)
CSOPL�6��L����SLcl Scaling�g
CSOOL�5��L`�5���g
CSOOL��5��L�5��	h
CSOOLP6��L�5��0h
CSOOL�6��L�5��_h!
CSOPL��5��L��5��Sd|X�h!
CSOPL��5��L��5��Sd|Y�h!
CSOPL�6��L��5��Sd|Z�h!
CSOPL�6��LP6��Sd|Xi!
CSOPL�6��LP6��Sd|YJi!
CSOPL6��LP6��Sd|Zyi!
CSOPL�#6��L�6��Sd|X�i!
CSOPL )6��L�6��Sd|Y�i!
CSOPL@-6��L�6��Sd|Z�jTakesj
CurrentS�j

TakeSTake 001Sj
FileNameSTake_001.tak{j	LocalTimeLL����
-�j
ReferenceTimeLL����
-���	���b�p���,z��Z�j���~���u�)
+VisibilitySS
AD�K-
PSCameraSKStringSS
USCamera�K/
PSResolutionXSintSIntegerS
UI�K/
PSResolutionYSintSIntegerS
UI�!L
ShadingCYDL
CullingS
+CullingOff�Q(MaterialL���X�SCornell Box
MaterialS�L
VersionIf�L

+ShadingModelSphong�L

+MultiLayerI�QProperties70OMB
PS
EmissiveColorSColorSS
AD�?D�?D�?�M2
PSEmissiveFactorSNumberSS
AD�MA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?N1
PS
DiffuseFactorSNumberSS
AD�������?mNB
PS
SpecularColorSColorSS
AD�?D�?D�?�N2
PSSpecularFactorSNumberSS
AD{�G�z�?�N5
PSShininessExponentSNumberSS
ADp@BOD
PSReflectionColorSColorSS
AD�?D�?D�?�O4
PSReflectionFactorSNumberSS
AD�OE
PSEmissiveSVector3DSVectorSDDD)PD
PSAmbientSVector3DSVectorSD�������?D�������?D�������?{PD
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?�PE
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?Q2
PS	ShininessSdoubleSNumberSDp@LQ0
PSOpacitySdoubleSNumberSD�?�Q5
PSReflectivitySdoubleSNumberSDW,MaterialL���X�SCornell Box_red
MaterialSR
VersionIf&R

+ShadingModelSphongBR

+MultiLayerI�VProperties70�RB
PS
EmissiveColorSColorSS
AD�?D�?D�?�R2
PSEmissiveFactorSNumberSS
AD:SA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?yS1
PS
DiffuseFactorSNumberSS
AD�������?�SB
PS
SpecularColorSColorSS
AD�?D�?D�?	T2
PSSpecularFactorSNumberSS
AD{�G�z�?LT5
PSShininessExponentSNumberSS
ADp@�TD
PSReflectionColorSColorSS
AD�?D�?D�?�T4
PSReflectionFactorSNumberSS
AD3UE
PSEmissiveSVector3DSVectorSDDD�UD
PSAmbientSVector3DSVectorSD�������?D�������?D�������?�UD
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?*VE
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?jV2
PS	ShininessSdoubleSNumberSDp@�V0
PSOpacitySdoubleSNumberSD�?�V5
PSReflectivitySdoubleSNumberSDc\.MaterialLp��X�SCornell Box_green
MaterialSaW
VersionIf�W

+ShadingModelSphong�W

+MultiLayerIV\Properties70	XB
PS
EmissiveColorSColorSS
AD�?D�?D�?IX2
PSEmissiveFactorSNumberSS
AD�XA
PSDiffuseColorSColorSS
AD333333�?D333333�?D333333�?�X1
PS
DiffuseFactorSNumberSS
AD�������?'YB
PS
SpecularColorSColorSS
AD�?D�?D�?gY2
PSSpecularFactorSNumberSS
AD{�G�z�?�Y5
PSShininessExponentSNumberSS
ADp@�YD
PSReflectionColorSColorSS
AD�?D�?D�?>Z4
PSReflectionFactorSNumberSS
AD�ZE
PSEmissiveSVector3DSVectorSDDD�ZD
PSAmbientSVector3DSVectorSD�������?D�������?D�������?5[D
PSDiffuseSVector3DSVectorSD���Q��?D���Q��?D���Q��?�[E
PSSpecularSVector3DSVectorSD{�G�z�?D{�G�z�?D{�G�z�?�[2
PS	ShininessSdoubleSNumberSDp@\0
PSOpacitySdoubleSNumberSD�?I\5
PSReflectivitySdoubleSNumberSD�\&AnimationStackL��9`STake 001
AnimStackS]'AnimationLayerLP��X�SLayer 001
AnimLayerS^#AnimationCurveNodeL�7`ST
AnimCurveNodeS^Properties70�]'
PSd|XSNumberSS
AD�]'
PSd|YSNumberSS
AD�]'
PSd|ZSNumberSS
AD(_#AnimationCurveNodeL��7`SR
AnimCurveNodeS_Properties70�^'
PSd|XSNumberSS
AD�^'
PSd|YSNumberSS
AD_'
PSd|ZSNumberSS
AD<`#AnimationCurveNodeL@�7`SS
AnimCurveNodeS/`Properties70�_'
PSd|XSNumberSS
AD�?�_'
PSd|YSNumberSS
AD�?"`'
PSd|ZSNumberSS
AD�?�aAnimationCurveL��2
`S
AnimCurveS�`
	DefaultD�`
KeyVerI��`
KeyTimel
�`

KeyValueFloatf
(a
KeyAttrFlagsi

ba
KeyAttrDataFloatf

�a
KeyAttrRefCounti

�bAnimationCurveL��2
`S
AnimCurveS�a
	DefaultD
+b
KeyVerI�3b
KeyTimel
^b

KeyValueFloatf
�b
KeyAttrFlagsi

�b
KeyAttrDataFloatf

�b
KeyAttrRefCounti

\dAnimationCurveL �2
`S
AnimCurveSRc
	DefaultDjc
KeyVerI��c
KeyTimel
�c

KeyValueFloatf
�c
KeyAttrFlagsi

"d
KeyAttrDataFloatf

Od
KeyAttrRefCounti

�eAnimationCurveL`�2
`S
AnimCurveS�d
	DefaultD�d
KeyVerI��d
KeyTimel
e

KeyValueFloatf
He
KeyAttrFlagsi

�e
KeyAttrDataFloatf

�e
KeyAttrRefCounti

gAnimationCurveL��2
`S
AnimCurveSf
	DefaultD*f
KeyVerI�Sf
KeyTimel
~f

KeyValueFloatf
��f
KeyAttrFlagsi

�f
KeyAttrDataFloatf

g
KeyAttrRefCounti

|hAnimationCurveL��2
`S
AnimCurveSrg
	DefaultD�g
KeyVerI��g
KeyTimel
�g

KeyValueFloatf
h
KeyAttrFlagsi

Bh
KeyAttrDataFloatf

oh
KeyAttrRefCounti

�iAnimationCurveL �2
`S
AnimCurveS�h
	DefaultD�?�h
KeyVerI�i
KeyTimel
>i

KeyValueFloatf
�?hi
KeyAttrFlagsi

�i
KeyAttrDataFloatf

�i
KeyAttrRefCounti

<kAnimationCurveL`�2
`S
AnimCurveS2j
	DefaultD�?Jj
KeyVerI�sj
KeyTimel
�j

KeyValueFloatf
�?�j
KeyAttrFlagsi

k
KeyAttrDataFloatf

/k
KeyAttrRefCounti

�lAnimationCurveL��2
`S
AnimCurveS�k
	DefaultD�?�k
KeyVerI��k
KeyTimel
�k

KeyValueFloatf
�?(l
KeyAttrFlagsi

bl
KeyAttrDataFloatf

�l
KeyAttrRefCounti

~pConnections�l
CSOOLV�U�Lm
CSOOL@��X�LV�U�6m
CSOOL���X�LV�U�]m
CSOOL���X�LV�U��m
CSOOLp��X�LV�U��m-
CSOPL�7`LV�U�SLcl Translation�m*
CSOPL��7`LV�U�SLcl Rotation.n)
CSOPL@�7`LV�U�SLcl ScalingUn
CSOOLP��X�L��9`|n
CSOOL�7`LP��X��n
CSOOL��7`LP��X��n
CSOOL@�7`LP��X��n!
CSOPL��2
`L�7`Sd|X(o!
CSOPL��2
`L�7`Sd|YWo!
CSOPL �2
`L�7`Sd|Z�o!
CSOPL`�2
`L��7`Sd|X�o!
CSOPL��2
`L��7`Sd|Y�o!
CSOPL��2
`L��7`Sd|Zp!
CSOPL �2
`L@�7`Sd|XBp!
CSOPL`�2
`L@�7`Sd|Yqp!
CSOPL��2
`L@�7`Sd|Z[qTakes�p
CurrentSNq

TakeSTake 001�p
FileNameSTake_001.takq	LocalTimeLL����
+Aq
ReferenceTimeLL����
+������m�{���%t��Z�j���~���u�)

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/010_MultiplePointLights.unity

   m_TargetEye: 3
   m_HDR: 1
   m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   renderPipeline: {fileID: 11400000, guid: e6987eea1dd29074597d54ed91a54a26, type: 2}
   cameraToUse: {fileID: 232121474}
   hdr: 0
+  msaaSamples: 4
   width: 1280
   height: 720
 --- !u!1 &235386914

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/001_SimpleCube.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.18028377, g: 0.22571409, b: 0.30692285, a: 1}
+  m_IndirectSpecularColor: {r: 0.18028378, g: 0.22571412, b: 0.30692285, 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_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 380492249}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &380492251
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 1
   m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: bded62b791643214d8d29703a7813d34, type: 2}
+  - {fileID: 2100000, guid: 14ba8c0a5d5381f4fb7ef200c8c10b26, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

ImageTemplates/LightweightPipeline/Scenes/011_UnlitSprites.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/002_Camera_Clip.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/003_Camera_Ortho.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/004_Camera_TargetTexture.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/005_LitBakedEmission.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/006_LitShaderLightProbes.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/007_LitShaderMaps.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/008_LitShaderReflection.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/009_LightweightShading.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

ImageTemplates/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres.unity.png.meta

     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
-    textureCompression: 1
+    textureCompression: 0
     compressionQuality: 50
     crunchedCompression: 0
     allowsAlphaSplitting: 0

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/002_Camera_Clip/002_CameraClip_Sphere.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_01_BaseWhite
+  m_Name: 002_CameraClip_Sphere
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_02_BaseColor
+  m_Name: 007_LitShaderMaps_02_BaseColor
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_04_Normal
+  m_Name: 007_LitShaderMaps_04_Normal
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/008_LitShaderReflection/008_LitShaderReflection_03.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_Reflection_Probe
+  m_Name: 008_LitShaderReflection_03
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_03_Specular
+  m_Name: 007_LitShaderMaps_03_Specular
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/006_LitShaderLightProbes/006_LitShaderLightProbes_Sphere.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_Reflection_Non
+  m_Name: 006_LitShaderLightProbes_Sphere
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/008_LitShaderReflection/008_LitShaderReflection_02.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_Reflection_Cube
+  m_Name: 008_LitShaderReflection_02
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _REFLECTION_CUBEMAP _SPECULAR_COLOR
   m_LightmapFlags: 4

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_06_All
+  m_Name: 007_LitShaderMaps_06_All
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _EMISSION _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA
   m_LightmapFlags: 4

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/005_LitBakedEmission/005_LitBakeEmission_Sphere.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_LitMat_05_Emission
+  m_Name: 005_LitBakeEmission_Sphere
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _EMISSION _SPECULAR_COLOR
   m_LightmapFlags: 2

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_UnlitMat
+  m_Name: 007_LitShaderMaps_UnlitMat_07
   m_Shader: {fileID: 4800000, guid: 650dd9526735d5b46b79224bc6e94025, type: 3}
   m_ShaderKeywords: _ALPHABLEND_ON _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA
   m_LightmapFlags: 4

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

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LDPipe_UnlitMatTexture
+  m_Name: 007_LitShaderMaps_UnlitMatTexture_08
   m_Shader: {fileID: 4800000, guid: 650dd9526735d5b46b79224bc6e94025, type: 3}
   m_ShaderKeywords: _EMISSION _NORMALMAP _SPECGLOSSMAP_BASE_ALPHA
   m_LightmapFlags: 4

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/011_UnlitSprites/box.prefab

   m_PreserveUVs: 0
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
-  m_StitchSeams: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 0
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/004_Camera_TargetTexture.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_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 61b48c9cd5d41264c8292c104fc5dd7d, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   field of view: 15
   orthographic: 0
   orthographic size: 1.2
-  m_Depth: -1
+  m_Depth: 1
   m_CullingMask:
     serializedVersion: 2
     m_Bits: 4294967295
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_TargetEye: 3
   m_HDR: 1
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 4e20c3cb4a41345df9244acd2c2ea860, type: 2}
+  - {fileID: 2100000, guid: 63fed6afae48b784793995b04a251662, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Material: {fileID: 0}
   m_IsTrigger: 0
   m_Enabled: 1
-  serializedVersion: 2
+  serializedVersion: 3
-  m_InflateMesh: 0
+  m_CookingOptions: 14
   m_SkinWidth: 0.01
   m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!33 &1764573547

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/003_Camera_Ortho.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_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 85273d0d6aee50b4c937c57d29e48f5a, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 85273d0d6aee50b4c937c57d29e48f5a, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 85273d0d6aee50b4c937c57d29e48f5a, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/002_Camera_Clip.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_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 50232205b9fd19b4597e42c0a4d7404c, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 50232205b9fd19b4597e42c0a4d7404c, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 874a014676eb94aa0b2df78530ae71ec, type: 2}
+  - {fileID: 2100000, guid: 50232205b9fd19b4597e42c0a4d7404c, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/005_LitBakedEmission.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_LightingDataAsset: {fileID: 112000002, guid: b659eb7d7f70e4d4eb5211330bbf8d9c,
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_LightingDataAsset: {fileID: 112000002, guid: 6a963d0bc4caa4faa93b9ab261a08f9f,
     type: 2}
   m_UseShadowmask: 0
 --- !u!196 &4
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 2
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 4fe532de4bae248f4bfff4daa180fa2d, type: 2}
+  - {fileID: 2100000, guid: 0ef5f9c836a870343a9636a205cc80ce, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/008_LitShaderReflection.unity

 LightmapSettings:
   m_ObjectHideFlags: 0
   serializedVersion: 11
-  m_GIWorkflowMode: 1
+  m_GIWorkflowMode: 0
   m_GISettings:
     serializedVersion: 2
     m_BounceScale: 1
     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: 112000002, guid: 9b679def5cafd49e5ad5fc293df3ad60,
     type: 2}
   m_UseShadowmask: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: cfab50a1f01bb41dfa96e9820de5d6c1, type: 2}
+  - {fileID: 2100000, guid: 29fb082ae8c7c1d47bcbaa4949025d62, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_Lightmapping: 2
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/006_LitShaderLightProbes.unity

 LightmapSettings:
   m_ObjectHideFlags: 0
   serializedVersion: 11
-  m_GIWorkflowMode: 1
+  m_GIWorkflowMode: 0
   m_GISettings:
     serializedVersion: 2
     m_BounceScale: 1
     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: 112000002, guid: de71753d509098b47b2d1fc3de525375,
     type: 2}
   m_UseShadowmask: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 971756569}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &971756572
 Behaviour:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 0
   m_AllowMSAA: 0
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Lightmapping: 2
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Lightmapping: 4
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
-  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_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.32063738, g: 0.28816786, b: 0.26506317, a: 1}
+  m_IndirectSpecularColor: {r: 0.32064232, g: 0.28817835, b: 0.265079, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
   m_TargetEye: 3
   m_HDR: 1
   m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
   m_ForceIntoRT: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/010_MultiplePointLights/010_MultiplePointLights_Probe.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: MobileReflection
+  m_Name: 010_MultiplePointLights_Probe
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
   m_ShaderKeywords: _REFLECTION_PROBE _SPECULAR_COLOR
   m_LightmapFlags: 4

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/Sky.mat

         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _Tex:
-        m_Texture: {fileID: 8900000, guid: 9c13f7d97fda704439868458dc2385ed, type: 3}
+        m_Texture: {fileID: 8900000, guid: 65f582fa3e33a4b44bd60cd299bb737f, type: 3}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     m_Floats:

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 9.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 9
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 8.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 8
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 7.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 7
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 6.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 6
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 5.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 5
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 4.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 4
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 3.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 3
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 21.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 21
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 20.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 20
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 2.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 2
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 19.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 19
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 18.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 18
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 17.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 17
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 16.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 16
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 15.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 15
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 14.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 14
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 13.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 13
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres/PBRSphere 12.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: PBRSphere 12
   m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_ON _METALLIC_SETUP _SPECULARHIGHLIGHTS_ON
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _MetallicSpecGlossMap:
+        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}
     - _SpecularHighlights: 1
     - _SrcBlend: 1
     - _UVSec: 0
+    - _WorkFlowMode: 0
+    - _WorkflowMode: 1
+    - _MetallicSpecColor: {r: 0, g: 0.19999996, b: 0.19999996, a: 0.2}
     - _SpecColor: {r: 1, g: 1, b: 1, a: 1}