Merge branch 'master' into Branch_Batching2

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/2D/Common/box.prefab

   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 2100000, guid: e3ef893926d86c448a80512fe05b8a37, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_PreserveUVs: 0
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 0
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

Assets/ScriptableRenderPipeline/Core/Shadow/Shadow.cs

             Object.DestroyImmediate(m_DebugMaterial);
         }
 
-        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
+        override public bool Reserve( FrameId frameId, Camera camera, bool cameraRelativeRendering, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
         {
             for( uint i = 0, cnt = sr.facecount; i < cnt; ++i )
             {
-            return Reserve( frameId, ref shadowData, sr, m_TmpWidths, m_TmpHeights, ref entries, ref payload, lights );
+            return Reserve( frameId, camera, cameraRelativeRendering, ref shadowData, sr, m_TmpWidths, m_TmpHeights, ref entries, ref payload, lights );
-        override public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
+        override public bool Reserve( FrameId frameId, Camera camera, bool cameraRelativeRendering, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payload, List<VisibleLight> lights)
         {
             if( m_FrameId.frameCount != frameId.frameCount )
                 m_ActiveEntriesCount = 0;
                     }
                     else
                         vp = Matrix4x4.identity; // should never happen, though
+                    if (cameraRelativeRendering)
+                    {
+                        Vector3 camPosWS = camera.transform.position;
+                        Matrix4x4 translation = Matrix4x4.Translate(camPosWS);
+                        ce.current.view *= translation;
+                        vp *= translation;
+                        if (sr.shadowType == GPUShadowType.Directional)
+                        {
+                            m_TmpSplits[key.faceIdx].x -= camPosWS.x;
+                            m_TmpSplits[key.faceIdx].y -= camPosWS.y;
+                            m_TmpSplits[key.faceIdx].z -= camPosWS.z;
+                        }
+                    }
                     // write :(
                     ce.current.shadowAlgo = shadowAlgo;
                     m_EntryCache[ceIdx] = ce;
             cullingParams.shadowDistance = Mathf.Min( m_ShadowSettings.maxShadowDistance, cullingParams.shadowDistance );
         }
 
-        public override void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices )
+        public override void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, bool cameraRelativeRendering, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices )
         {
             shadowDataIndices = null;
 
             ShadowDataVector shadowVector = m_ShadowCtxt.shadowDatas;
             ShadowPayloadVector payloadVector = m_ShadowCtxt.payloads;
             m_ShadowIndices.Reset( m_TmpRequests.Count() );
-            AllocateShadows( frameId, lights, totalGranted, ref m_TmpRequests, ref m_ShadowIndices, ref shadowVector, ref payloadVector );
+            AllocateShadows( frameId, camera, cameraRelativeRendering, lights, totalGranted, ref m_TmpRequests, ref m_ShadowIndices, ref shadowVector, ref payloadVector );
             Debug.Assert( m_TmpRequests.Count() == m_ShadowIndices.Count() );
             m_ShadowCtxt.shadowDatas = shadowVector;
             m_ShadowCtxt.payloads = payloadVector;
             m_TmpSortKeys.ExtractTo( ref shadowRequests, (long idx) => { return (int) idx; } );
         }
 
-        protected override void AllocateShadows( FrameId frameId, List<VisibleLight> lights, uint totalGranted, ref ShadowRequestVector grantedRequests, ref ShadowIndicesVector shadowIndices, ref ShadowDataVector shadowDatas, ref ShadowPayloadVector shadowmapPayload )
+        protected override void AllocateShadows( FrameId frameId, Camera camera, bool cameraRelativeRendering, List<VisibleLight> lights, uint totalGranted, ref ShadowRequestVector grantedRequests, ref ShadowIndicesVector shadowIndices, ref ShadowDataVector shadowDatas, ref ShadowPayloadVector shadowmapPayload )
         {
             ShadowData sd = new ShadowData();
             shadowDatas.Reserve( totalGranted );
                 int smidx = 0;
                 while( smidx < k_MaxShadowmapPerType )
                 {
-                    if( m_ShadowmapsPerType[(int)shadowtype,smidx] != null && m_ShadowmapsPerType[(int)shadowtype,smidx].Reserve( frameId, ref sd, grantedRequests[i], (uint) asd.shadowResolution, (uint) asd.shadowResolution, ref shadowDatas, ref shadowmapPayload, lights ) )
+                    if( m_ShadowmapsPerType[(int)shadowtype,smidx] != null && m_ShadowmapsPerType[(int)shadowtype,smidx].Reserve( frameId, camera, cameraRelativeRendering, ref sd, grantedRequests[i], (uint) asd.shadowResolution, (uint) asd.shadowResolution, ref shadowDatas, ref shadowmapPayload, lights ) )
                         break;
                     smidx++;
                 }
             m_ShadowCtxt.SyncData();
         }
 
-        public override void BindResources(CommandBuffer cmd)
+        public override void BindResources(CommandBuffer cmd, ComputeShader computeShader, int computeKernel)
         {
             foreach (var sm in m_Shadowmaps)
             {
-            m_ShadowCtxt.BindResources(cmd);
+            m_ShadowCtxt.BindResources(cmd, computeShader, computeKernel);
             cmd.EndSample("Bind resources to GPU");
         }
 

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs

     public class ShadowContext : ShadowContextStorage
     {
         public delegate void SyncDel( ShadowContext sc );
-        public delegate void BindDel( ShadowContext sc, CommandBuffer cb );
+        public delegate void BindDel( ShadowContext sc, CommandBuffer cb, ComputeShader computeShader, int computeKernel);
         public struct CtxtInit
         {
             public Init     storage;
         // delegate that takes care of syncing data to the GPU
         public void SyncData() { m_DataSyncerDel( this ); }
         // delegate that takes care of binding textures, buffers and samplers to shaders just before rendering
-        public void BindResources( CommandBuffer cb ) { m_ResourceBinderDel( this, cb ); }
+        public void BindResources( CommandBuffer cb, ComputeShader computeShader, int computeKernel) { m_ResourceBinderDel( this, cb, computeShader, computeKernel); }
 
         // the following functions are to be used by the bind and sync delegates
         public void GetShadowDatas( out ShadowData[] shadowDatas, out uint offset, out uint count )                           { shadowDatas   = m_ShadowDatas.AsArray( out offset, out count ); }
                  public ShadowSupport QueryShadowSupport() { return m_ShadowSupport; }
                  public uint GetMaxPayload() { return m_MaxPayloadCount; }
                  public void Assign( CullResults cullResults ) { m_CullResults = cullResults; } // TODO: Remove when m_CullResults is removed again
-        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
-        abstract public bool Reserve( FrameId frameId, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
+        abstract public bool Reserve( FrameId frameId, Camera camera, bool cameraRelativeRendering, ref ShadowData shadowData, ShadowRequest sr, uint width, uint height, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
+        abstract public bool Reserve( FrameId frameId, Camera camera, bool cameraRelativeRendering, ref ShadowData shadowData, ShadowRequest sr, uint[] widths, uint[] heights, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads, List<VisibleLight> lights);
         abstract public bool ReserveFinalize( FrameId frameId, ref VectorArray<ShadowData> entries, ref VectorArray<ShadowPayload> payloads );
         abstract public void Update( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights);
         abstract public void ReserveSlots( ShadowContextStorage sc );
         //          shadowPayloads contains implementation specific data that is accessed from the shader by indexing into an Buffer<int> using ShadowData.ShadowmapData.payloadOffset.
         //          This is the equivalent of a void pointer in the shader and there needs to be loader code that knows how to interpret the data.
         //          If there are no valid shadow casters all output arrays will be null, otherwise they will contain valid data that can be passed to shaders.
-        void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
+        void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, bool cameraRelativeRendering, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
         // Renders all shadows for lights the were deemed shadow casters after the last call to ProcessShadowRequests
         void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights);
         // Debug function to display a shadow at the screen coordinate
         void SyncData();
         // Binds resources to shader stages just before rendering the lighting pass
-        void BindResources( CommandBuffer cmd );
+        void BindResources( CommandBuffer cmd, ComputeShader computeShader, int computeKernel);
         // Fixes up some parameters within the cullResults
         void UpdateCullingParameters( ref ScriptableCullingParameters cullingParams );
 
 
     abstract public class ShadowManagerBase : ShadowRegistry, IShadowManager
     {
-        public  abstract void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
+        public  abstract void ProcessShadowRequests( FrameId frameId, CullResults cullResults, Camera camera, bool cameraRelativeRendering, List<VisibleLight> lights, ref uint shadowRequestsCount, int[] shadowRequests, out int[] shadowDataIndices );
-        public  abstract void BindResources( CommandBuffer cmd );
+        public  abstract void BindResources( CommandBuffer cmd, ComputeShader computeShader, int computeKernel);
         public  abstract void UpdateCullingParameters( ref ScriptableCullingParameters cullingParams );
         // sort the shadow requests in descending priority - may only modify shadowRequests
         protected abstract void PrioritizeShadowCasters( Camera camera, List<VisibleLight> lights, uint shadowRequestsCount, int[] shadowRequests );
-        protected abstract void AllocateShadows( FrameId frameId, List<VisibleLight> lights, uint totalGranted, ref VectorArray<ShadowmapBase.ShadowRequest> grantedRequests, ref VectorArray<int> shadowIndices, ref VectorArray<ShadowData> shadowmapDatas, ref VectorArray<ShadowPayload> shadowmapPayload );
+        protected abstract void AllocateShadows( FrameId frameId, Camera camera, bool cameraRelativeRendering, List<VisibleLight> lights, uint totalGranted, ref VectorArray<ShadowmapBase.ShadowRequest> grantedRequests, ref VectorArray<int> shadowIndices, ref VectorArray<ShadowData> shadowmapDatas, ref VectorArray<ShadowPayload> shadowmapPayload );
 
         public abstract uint GetShadowMapCount();
         public abstract uint GetShadowMapSliceCount(uint shadowMapIndex);

Assets/ScriptableRenderPipeline/Fptl/FptlLighting.cs

                 };
 
             // binding code. This needs to be in sync with ShadowContext.hlsl
-            ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb) =>
+            ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb, ComputeShader computeShader, int computeKernel) =>
                 {
                     // bind buffers
                     cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
                 uint shadowRequestCount = (uint)m_ShadowRequests.Count;
                 int[] shadowRequests = m_ShadowRequests.ToArray();
                 int[] shadowDataIndices;
-                m_ShadowMgr.ProcessShadowRequests(m_FrameId, inputs, camera, inputs.visibleLights,
+                m_ShadowMgr.ProcessShadowRequests(m_FrameId, inputs, camera, false, inputs.visibleLights,
                     ref shadowRequestCount, shadowRequests, out shadowDataIndices);
 
                 // update the visibleLights with the shadow information
             CommandBuffer cmdShadow = CommandBufferPool.Get();
             m_ShadowMgr.RenderShadows( m_FrameId, loop, cmdShadow, cullResults, cullResults.visibleLights );
             m_ShadowMgr.SyncData();
-            m_ShadowMgr.BindResources( cmdShadow );
+            m_ShadowMgr.BindResources( cmdShadow, null, 0 );
             loop.ExecuteCommandBuffer(cmdShadow);
             CommandBufferPool.Release(cmdShadow);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             EditorGUILayout.Space();
             EditorGUILayout.LabelField(styles.renderingSettingsLabel);
             EditorGUI.indentLevel++;
+            EditorGUI.BeginChangeCheck();
+
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                if (m_RenderingUseForwardOnly.boolValue && !m_RenderingUseDepthPrepass.boolValue)
+                {
+                    // Force depth prepass for forward-only rendering (for FPTL, etc).
+                    m_RenderingUseDepthPrepass.boolValue = true;
+                    HackSetDirty(renderContext); // Repaint
+                }
+            }
             EditorGUI.indentLevel--;
         }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 using UnityEngine.Rendering;
 using System;
 using System.Linq;
-using UnityEngine.Experimental.PostProcessing;
+using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
 
 #if UNITY_EDITOR
         public Matrix4x4 viewMatrix;
         public Matrix4x4 projMatrix;
         public Vector4   screenSize;
+        public Vector4[] frustumPlaneEquations;
         public Camera    camera;
 
         public Matrix4x4 viewProjMatrix
         // avoid one-frame jumps/hiccups with temporal effects (motion blur, TAA...)
         bool m_FirstFrame;
 
-        public HDCamera(Camera camera)
+        public HDCamera(Camera cam)
-            this.camera = camera;
+            camera = cam;
+            frustumPlaneEquations = new Vector4[6];
             Reset();
         }
 
             // (different Z value ranges etc.)
-            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true); // Had to change this from 'false'
-            var gpuVP = gpuProj * camera.worldToCameraMatrix;
+            Matrix4x4 gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, true); // Had to change this from 'false'
+            Matrix4x4 gpuView = camera.worldToCameraMatrix;
+
+            if (ShaderConfig.s_CameraRelativeRendering != 0)
+            {
+                // Zero out the translation component.
+                gpuView.SetColumn(3, new Vector4(0, 0, 0, 1));
+            }
+
+            Matrix4x4 gpuVP = gpuProj * gpuView;
 
             // A camera could be rendered multiple time per frame, only updates the previous viewproj if needed
             if (m_LastFrameActive != Time.frameCount)
                 m_FirstFrame = false;
             }
 
-            viewMatrix = camera.worldToCameraMatrix;
+            viewMatrix = gpuView;
+
+            Plane[] planes = GeometryUtility.CalculateFrustumPlanes(viewProjMatrix);
+
+            for (int i = 0; i < 6; i++)
+            {
+                frustumPlaneEquations[i] = new Vector4(planes[i].normal.x, planes[i].normal.y, planes[i].normal.z, planes[i].distance);
+            }
 
             m_LastFrameActive = Time.frameCount;
         }
             cmd.SetGlobalVector("_InvProjParam",       invProjParam);
             cmd.SetGlobalVector("_ScreenSize",         screenSize);
             cmd.SetGlobalMatrix("_PrevViewProjMatrix", prevViewProjMatrix);
+            cmd.SetGlobalVectorArray("_FrustumPlanes", frustumPlaneEquations);
         }
 
         // Does not modify global settings. Used for shadows, low res. rendering, etc.
             material.SetVector("_InvProjParam",       invProjParam);
             material.SetVector("_ScreenSize",         screenSize);
             material.SetMatrix("_PrevViewProjMatrix", prevViewProjMatrix);
+            material.SetVectorArray("_FrustumPlanes", frustumPlaneEquations);
         }
 
         public void SetupComputeShader(ComputeShader cs, CommandBuffer cmd)
             cmd.SetComputeVectorParam(cs, "_InvProjParam",       invProjParam);
             cmd.SetComputeVectorParam(cs, "_ScreenSize",         screenSize);
             cmd.SetComputeMatrixParam(cs, "_PrevViewProjMatrix", prevViewProjMatrix);
+            cmd.SetComputeVectorArrayParam(cs, "_FrustumPlanes", frustumPlaneEquations);
         }
     }
 
 
             renderContext.SetupCameraProperties(camera);
 
-            var hdCamera = HDCamera.Get(camera);
+            HDCamera hdCamera = HDCamera.Get(camera);
+            PushGlobalParams(hdCamera, cmd, m_Asset.sssSettings);
 
             // TODO: Find a correct place to bind these material textures
             // We have to bind the material specific global parameters in this mode
 
             InitAndClearBuffer(camera, cmd);
 
-            PushGlobalParams(hdCamera, cmd, m_Asset.sssSettings);
-
             RenderDepthPrepass(m_CullResults, camera, renderContext, cmd);
 
             // Forward opaque with deferred/cluster tile require that we fill the depth 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)
-                    m_SsaoEffect.Render(ssaoSettingsToUse, this, hdCamera, renderContext, m_Asset.renderingSettings.useForwardRenderingOnly);
+                    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);
                     renderContext.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
             if (!m_DebugDisplaySettings.renderingDebugSettings.displayOpaqueObjects)
                 return;
 
-            // This is done here because DrawRenderers API lives outside command buffers so we need to make sur eto call this before doing any DrawRenders
+            // This is done here because DrawRenderers API lives outside command buffers so we need to make call this before doing any DrawRenders
             renderContext.ExecuteCommandBuffer(cmd);
             cmd.Clear();
 
             if (!m_DebugDisplaySettings.renderingDebugSettings.displayTransparentObjects)
                 return;
 
-            // This is done here because DrawRenderers API lives outside command buffers so we need to make sur eto call this before doing any DrawRenders
+            // This is done here because DrawRenderers API lives outside command buffers so we need to make call this before doing any DrawRenders
             renderContext.ExecuteCommandBuffer(cmd);
             cmd.Clear();
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs

 using UnityEngine.Rendering;
 using System;
 using System.Linq;
-using UnityEngine.Experimental.PostProcessing;
+using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
 
 #if UNITY_EDITOR

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

         }
 
         Material m_Material;
-        CommandBuffer m_Command;
 
         // For the AO buffer, use R8 or RHalf if available.
         static RenderTextureFormat GetAOBufferFormat()
             m_Material.hideFlags = HideFlags.DontSave;
         }
 
-        public void Render(ScreenSpaceAmbientOcclusionSettings.Settings settings, HDRenderPipeline hdRP, HDCamera hdCamera, ScriptableRenderContext renderContext, bool isForward)
+        public void Render(ScreenSpaceAmbientOcclusionSettings.Settings settings, HDRenderPipeline hdRP, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool isForward)
-            if (m_Command == null)
-            {
-                m_Command = new CommandBuffer();
-                m_Command.name = "Ambient Occlusion";
-            }
-            else
-            {
-                m_Command.Clear();
-            }
-
-                m_Command.SetGlobalTexture(Uniforms._AOBuffer, PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
-                renderContext.ExecuteCommandBuffer(m_Command);
+                cmd.SetGlobalTexture(Uniforms._AOBuffer, UnityEngine.Rendering.PostProcessing.RuntimeUtilities.blackTexture); // Neutral is black, see the comment in the shaders
                 return;
             }
 
             m_Material.SetFloat(Uniforms._Downsample, 1.0f / downsize);
             m_Material.SetFloat(Uniforms._SampleCount, settings.sampleCount);
 
-            // AO estimation.
-            m_Command.GetTemporaryRT(Uniforms._TempTex1, width / downsize, height / downsize, 0, kFilter, kTempFormat, kRWMode);
-            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex1, null, 0);
-            hdRP.PushFullScreenDebugTexture(m_Command, Uniforms._TempTex1, hdCamera.camera, renderContext, FullScreenDebugMode.SSAOBeforeFiltering);
-
-            // Denoising (horizontal pass).
-            m_Command.GetTemporaryRT(Uniforms._TempTex2, width, height, 0, kFilter, kTempFormat, kRWMode);
-            m_Command.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex1);
-            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex2, null, 1);
-            m_Command.ReleaseTemporaryRT(Uniforms._TempTex1);
+            using (new Utilities.ProfilingSample("Screenspace ambient occlusion", cmd))
+            {
+                // AO estimation.
+                cmd.GetTemporaryRT(Uniforms._TempTex1, width / downsize, height / downsize, 0, kFilter, kTempFormat, kRWMode);
+                Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex1, null, 0);
+                hdRP.PushFullScreenDebugTexture(cmd, Uniforms._TempTex1, hdCamera.camera, renderContext, FullScreenDebugMode.SSAOBeforeFiltering);
-            // Denoising (vertical pass).
-            m_Command.GetTemporaryRT(Uniforms._TempTex1, width, height, 0, kFilter, kTempFormat, kRWMode);
-            m_Command.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex2);
-            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._TempTex1, null, 2);
-            m_Command.ReleaseTemporaryRT(Uniforms._TempTex2);
+                // Denoising (horizontal pass).
+                cmd.GetTemporaryRT(Uniforms._TempTex2, width, height, 0, kFilter, kTempFormat, kRWMode);
+                cmd.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex1);
+                Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex2, null, 1);
+                cmd.ReleaseTemporaryRT(Uniforms._TempTex1);
-            // Final filtering
-            m_Command.GetTemporaryRT(Uniforms._AOBuffer, width, height, 0, kFilter, GetAOBufferFormat(), kRWMode);
-            m_Command.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex1);
-            Utilities.DrawFullScreen(m_Command, m_Material, Uniforms._AOBuffer, null, 3);
-            m_Command.ReleaseTemporaryRT(Uniforms._TempTex1);
+                // Denoising (vertical pass).
+                cmd.GetTemporaryRT(Uniforms._TempTex1, width, height, 0, kFilter, kTempFormat, kRWMode);
+                cmd.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex2);
+                Utilities.DrawFullScreen(cmd, m_Material, Uniforms._TempTex1, null, 2);
+                cmd.ReleaseTemporaryRT(Uniforms._TempTex2);
-            // Setup texture for lighting pass (automagic of unity)
-            m_Command.SetGlobalTexture("_AmbientOcclusionTexture", Uniforms._AOBuffer);
-            hdRP.PushFullScreenDebugTexture(m_Command, Uniforms._AOBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.SSAO);
+                // Final filtering
+                cmd.GetTemporaryRT(Uniforms._AOBuffer, width, height, 0, kFilter, GetAOBufferFormat(), kRWMode);
+                cmd.SetGlobalTexture(Uniforms._MainTex, Uniforms._TempTex1);
+                Utilities.DrawFullScreen(cmd, m_Material, Uniforms._AOBuffer, null, 3);
+                cmd.ReleaseTemporaryRT(Uniforms._TempTex1);
-            // Register the command buffer and release it.
-            renderContext.ExecuteCommandBuffer(m_Command);
+                // Setup texture for lighting pass (automagic of unity)
+                cmd.SetGlobalTexture("_AmbientOcclusionTexture", Uniforms._AOBuffer);
+                hdRP.PushFullScreenDebugTexture(cmd, Uniforms._AOBuffer, hdCamera.camera, renderContext, FullScreenDebugMode.SSAO);
+            }
         }
 
         public void Cleanup()

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

                 };
 
             // binding code. This needs to be in sync with ShadowContext.hlsl
-            ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb) =>
-                {
-                    // bind buffers
-                    cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
-                    cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
-                    // bind textures
+            ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb, ComputeShader computeShader, int computeKernel) =>
+                {
-                    sc.GetTex2DArrays( out tex, out offset, out count );
-                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_0", tex[0] );
-                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_1", tex[1] );
-                    cb.SetGlobalTexture( "_ShadowmapExp_VSM_2", tex[2] );
-                    cb.SetGlobalTexture( "_ShadowmapExp_PCF"  , tex[3] );
+                    sc.GetTex2DArrays(out tex, out offset, out count);
+
+                    if(computeShader)
+                    {
+                        // bind buffers
+                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowDatasExp", s_ShadowDataBuffer);
+                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowPayloads", s_ShadowPayloadBuffer);
+                        // bind textures
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_0", tex[0]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_1", tex[1]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_2", tex[2]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_PCF", tex[3]);
+                    }
+                    else
+                    {
+                        // bind buffers
+                        cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
+                        cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
+                        // bind textures
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_0", tex[0]);
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_1", tex[1]);
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_2", tex[2]);
+                        cb.SetGlobalTexture("_ShadowmapExp_PCF", tex[3]);
+                    }
+                    
                     // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
                 };
 
                 // Then Culling side
                 var range = light.range;
                 var lightToWorld = light.localToWorld;
-                Vector3 lightPos = lightToWorld.GetColumn(3);
+                Vector3 lightPos = lightData.positionWS;
 
                 // Fill bounds
                 var bound = new SFiniteLightBound();
             {
                 m_lightList.Clear();
 
+                Vector3 camPosWS = camera.transform.position;
+
                 if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
                 {
                     // 0. deal with shadows
                         for (int i = 0; i < lcnt; ++i)
                         {
                             VisibleLight vl = cullResults.visibleLights[i];
+                            if (vl.light.shadows == LightShadows.None)
+                                continue;
+
-                            if( vl.light.shadows != LightShadows.None && asd != null && asd.shadowDimmer > 0.0f )
-                                m_ShadowRequests.Add( i );
+                            if (asd != null && asd.shadowDimmer > 0.0f)
+                                m_ShadowRequests.Add(i);
                         }
                         // pass this list to a routine that assigns shadows based on some heuristic
                         uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
-                        m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, cullResults.visibleLights,
+                        m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, ShaderConfig.s_CameraRelativeRendering != 0, cullResults.visibleLights,
                             ref shadowRequestCount, shadowRequests, out shadowDataIndices);
 
                         // update the visibleLights with the shadow information
                         sortKeys[sortCount++] = (uint)lightCategory << 27 | (uint)gpuLightType << 22 | (uint)lightVolumeType << 17 | shadow << 16 | (uint)lightIndex;
                     }
 
-                    //TODO: Replace with custom sort, allocates mem and increases GC pressure.
-                    Array.Sort(sortKeys, 0, sortCount);
+                    Utilities.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
 
                     // TODO: Refactor shadow management
                     // The good way of managing shadow:
                         if (gpuLightType == GPULightType.Directional)
                         {
                             if (GetDirectionalLightData(shadowSettings, gpuLightType, light, additionalLightData, additionalShadowData, lightIndex))
+                            {
+
+                                // We make the light position camera-relative as late as possible in order
+                                // to allow the preceding code to work with the absolute world space coordinates.
+                                if (ShaderConfig.s_CameraRelativeRendering != 0)
+                                {
+                                    // Caution: 'DirectionalLightData.positionWS' is camera-relative after this point.
+                                    int n = m_lightList.directionalLights.Count;
+                                    DirectionalLightData lightData = m_lightList.directionalLights[n - 1];
+                                    lightData.positionWS -= camPosWS;
+                                    m_lightList.directionalLights[n - 1] = lightData;
+                                }
+                            }
                             continue;
                         }
                         // Punctual, area, projector lights - the rendering side.
 
                             // Then culling side. Must be call in this order as we pass the created Light data to the function
                             GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], worldToView);
+
+                            // We make the light position camera-relative as late as possible in order
+                            // to allow the preceding code to work with the absolute world space coordinates.
+                            if (ShaderConfig.s_CameraRelativeRendering != 0)
+                            {
+                                // Caution: 'LightData.positionWS' is camera-relative after this point.
+                                int n = m_lightList.lights.Count;
+                                LightData lightData = m_lightList.lights[n - 1];
+                                lightData.positionWS -= camPosWS;
+                                m_lightList.lights[n - 1] = lightData;
+                            }
                         }
                     }
 
                     }
 
                     // Not necessary yet but call it for future modification with sphere influence volume
-                    Array.Sort(sortKeys, 0, sortCount);
+                    Utilities.QuickSort(sortKeys, 0, sortCount - 1); // Call our own quicksort instead of Array.Sort(sortKeys, 0, sortCount) so we don't allocate memory (note the SortCount-1 that is different from original call).
 
                     for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
                     {
                         GetEnvLightData(probe);
 
                         GetEnvLightVolumeDataAndBound(probe, lightVolumeType, worldToView);
+
+                        // We make the light position camera-relative as late as possible in order
+                        // to allow the preceding code to work with the absolute world space coordinates.
+                        if (ShaderConfig.s_CameraRelativeRendering != 0)
+                        {
+                            // Caution: 'EnvLightData.positionWS' is camera-relative after this point.
+                            int n = m_lightList.envLights.Count;
+                            EnvLightData envLightData = m_lightList.envLights[n - 1];
+                            envLightData.positionWS -= camPosWS;
+                            m_lightList.envLights[n - 1] = envLightData;
+                        }
                     }
 
                     // Sanity check
                 s_LightVolumeDataBuffer.SetData(m_lightList.lightVolumes);
             }
 
-            private void BindGlobalParams(CommandBuffer cmd, ComputeShader computeShader, int kernelIndex, Camera camera)
+            private void BindGlobalParams(CommandBuffer cmd, Camera camera)
-                m_ShadowMgr.BindResources(cmd);
+                m_ShadowMgr.BindResources(cmd, activeComputeShader, activeComputeKernel);
 
                 SetGlobalBuffer("g_vLightListGlobal", !usingFptl ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
 
                     m_ShadowMgr.SyncData();
 
                     SetGlobalPropertyRedirect(computeShader, kernelIndex, cmd);
-                    BindGlobalParams(cmd, computeShader, kernelIndex, camera);
+                    BindGlobalParams(cmd, camera);
                     SetGlobalPropertyRedirect(null, 0, null);
                 }
             }
             {
                 var bUseClusteredForDeferred = !usingFptl;
 
+                // TODO: To reduce GC pressure don't do concat string here
                 using (new Utilities.ProfilingSample((m_TileSettings.enableTileAndCluster ? "TilePass - Deferred Lighting Pass" : "SinglePass - Deferred Lighting Pass") + (outputSplitLighting ? " MRT" : ""), cmd))
                 {
                     var camera = hdCamera.camera;
 
             public void RenderForward(Camera camera, CommandBuffer cmd, bool renderOpaque)
             {
-                // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
-                bool useFptl = renderOpaque && usingFptl;
+                PushGlobalParams(camera, cmd, null, 0);
+                // Note: if we use render opaque with deferred tiling we need to render a opaque depth pass for these opaque objects
                 if (!m_TileSettings.enableTileAndCluster)
                 {
                     using (new Utilities.ProfilingSample("Forward pass", cmd))
                 }
                 else
                 {
+                    // Only opaques can use FPTL, transparents must use clustered!
+                    bool useFptl = renderOpaque && usingFptl;
+
                     using (new Utilities.ProfilingSample(useFptl ? "Forward Tiled pass" : "Forward Clustered pass", cmd))
                     {
                         // say that we want to use tile of single loop

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

 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Use the reversed normal from the front for the back of the object.
-        illuminance = F_Transm_Schlick(bsdfData.fresnel0.x, saturate(-NdotL));  // Transmission is only valid for dielectric
+        // Currently, we only model diffuse transmission. Specular transmission is not yet supported.
+        // We assume that the back side of the object is a uniformly illuminated infinite plane
+        // (we reuse the illumination) with the reversed normal of the current sample.
+        // We apply wrapped lighting instead of the regular Lambertian diffuse
+        // to compensate for these approximations.
+        illuminance = ComputeWrappedDiffuseLighting(NdotL, SSS_WRAP_LIGHT);
-        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        float3 backLight = (cookie.rgb * lightData.color) * (Lambert() * illuminance * lightData.diffuseScale);
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * (bsdfData.diffuseColor * bsdfData.transmittance);
 
 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Use the reversed normal from the front for the back of the object.
-        illuminance = F_Transm_Schlick(bsdfData.fresnel0.x , saturate(-NdotL)) * attenuation;  // Transmission is only valid for dielectric
+        // Currently, we only model diffuse transmission. Specular transmission is not yet supported.
+        // We assume that the back side of the object is a uniformly illuminated infinite plane
+        // (we reuse the illumination) with the reversed normal of the current sample.
+        // We apply wrapped lighting instead of the regular Lambertian diffuse
+        // to compensate for these approximations.
+        illuminance = ComputeWrappedDiffuseLighting(NdotL, SSS_WRAP_LIGHT) * attenuation;
-        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        float3 backLight = (cookie.rgb * lightData.color) * (Lambert() * illuminance * lightData.diffuseScale);
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * (bsdfData.diffuseColor * bsdfData.transmittance);
 
 
     [branch] if (bsdfData.enableTransmission)
     {
-        // Use the reversed normal from the front for the back of the object.
-        illuminance = F_Transm_Schlick(bsdfData.fresnel0.x, saturate(-NdotL)) * clipFactor; // Transmission is only valid for dielectric
+        // Currently, we only model diffuse transmission. Specular transmission is not yet supported.
+        // We assume that the back side of the object is a uniformly illuminated infinite plane
+        // (we reuse the illumination) with the reversed normal of the current sample.
+        // We apply wrapped lighting instead of the regular Lambertian diffuse
+        // to compensate for these approximations.
+        illuminance = ComputeWrappedDiffuseLighting(NdotL, SSS_WRAP_LIGHT) * clipFactor;
-        float3 backLight = (cookie.rgb * lightData.color) * (illuminance * lightData.diffuseScale);
+        float3 backLight = (cookie.rgb * lightData.color) * (Lambert() * illuminance * lightData.diffuseScale);
         // TODO: multiplication by 'diffuseColor' and 'transmittance' is the same for each light.
         float3 transmittedLight = backLight * (bsdfData.diffuseColor * bsdfData.transmittance);
 

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

     float2 uvXZ;
     float2 uvXY;
     float2 uvZY;
-    GetTriplanarCoordinate(positionWS * worldScale, uvXZ, uvXY, uvZY);
+
+    GetTriplanarCoordinate(GetAbsolutePositionWS(positionWS) * worldScale, uvXZ, uvXY, uvZY);
 
     // Planar is just XZ of triplanar
     if (mappingType == UV_MAPPING_PLANAR)

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

 {
     float maxDisplacement = GetMaxDisplacement();
 
-    bool frustumCulled = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])unity_CameraWorldClipPlanes);
+
+    // For tessellation we want to process tessellation factor always from the point of view of the camera (to be consistent and avoid Z-fight).
+    // For the culling part however we want to use the current view (shadow view).
+    // Thus the following code play with both.
+
+#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
+    bool frustumCulled = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])_FrustumPlanes); // _FrustumPlanes are primary camera planes
+#else
+    bool frustumCulled = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])unity_CameraWorldClipPlanes); // unity_CameraWorldClipPlanes is set by legacy Unity in case of shadow and contain shadow view plan
+#endif
-    // We use the position of the primary (scene view) camera in order
-    // to have identical tessellation levels for both the scene view and
-    // shadow views. Otherwise, depth comparisons become meaningless!
-    float3 camPosWS = _WorldSpaceCameraPos;
-
-        faceCull = BackFaceCullTriangle(p0, p1, p2, _TessellationBackFaceCullEpsilon, camPosWS);
+        faceCull = BackFaceCullTriangle(p0, p1, p2, _TessellationBackFaceCullEpsilon, GetCurrentViewPosition()); // Use shadow view
     }
 #endif
 
         return float4(0.0, 0.0, 0.0, 0.0);
     }
 
+    // We use the parameters of the primary (scene view) camera in order
+    // to have identical tessellation levels for both the scene view and
+    // shadow views. Otherwise, depth comparisons become meaningless!
-    // Aaptive screen space tessellation
+    // Adaptive screen space tessellation
-        tessFactor *= GetScreenSpaceTessFactor( p0, p1, p2, GetWorldToHClipMatrix(), _ScreenParams,  _TessellationFactorTriangleSize);
+        tessFactor *= GetScreenSpaceTessFactor( p0, p1, p2, _ViewProjMatrix, _ScreenSize, _TessellationFactorTriangleSize); // Use primary camera view
-        float3 distFactor = GetDistanceBasedTessFactor(p0, p1, p2, camPosWS, _TessellationFactorMinDistance, _TessellationFactorMaxDistance);
+        float3 distFactor = GetDistanceBasedTessFactor(p0, p1, p2, GetPrimaryCameraPosition(), _TessellationFactorMinDistance, _TessellationFactorMaxDistance);  // Use primary camera view
         // We square the disance factor as it allow a better percptual descrease of vertex density.
         tessFactor *= distFactor * distFactor;
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderConfig.cs

         // All this could be fix we a new Mesh API not ready yet. Note that this feature only affect animated mesh (vertex or skin) as others use depth reprojection.
         VelocityInGBuffer = 0, // Change to 1 to enable the feature, then regenerate hlsl headers.
         // TODO: not working yet, waiting for UINT16 RT format support
-        PackGBufferInU16 = 0
+        PackGBufferInU16 = 0,
+        CameraRelativeRendering = 1 // Rendering sets the origin of the world to the position of the primary (scene view) camera
     };
 
     // Note: #define can't be use in include file in C# so we chose this way to configure both C# and hlsl
 
         public const int k_PackgbufferInU16 = (int)ShaderOptions.PackGBufferInU16;
         public static int s_PackgbufferInU16 = (int)ShaderOptions.PackGBufferInU16;
+
+        public const int k_CameraRelativeRendering = (int)ShaderOptions.CameraRelativeRendering;
+        public static int s_CameraRelativeRendering = (int)ShaderOptions.CameraRelativeRendering;
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderConfig.cs.hlsl

 //
 #define SHADEROPTIONS_VELOCITY_IN_GBUFFER (0)
 #define SHADEROPTIONS_PACK_GBUFFER_IN_U16 (0)
+#define SHADEROPTIONS_CAMERA_RELATIVE_RENDERING (1)
 
 
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

     VaryingsToPS output;
 
     // Output UV coordinate in vertex shader
+    float2 uv;
+
-        inputMesh.positionOS.xy = inputMesh.uv1 * unity_LightmapST.xy + unity_LightmapST.zw;
+    {
+        uv = inputMesh.uv1 * unity_LightmapST.xy + unity_LightmapST.zw;
+    }
+    else if (unity_MetaVertexControl.y)
+    {
+        uv = inputMesh.uv2 * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+    }
-    if (unity_MetaVertexControl.y)
-        inputMesh.positionOS.xy = inputMesh.uv2 * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
-
-    // Zero out the Z component. However, OpenGL right now needs to actually use the incoming vertex
-    // position, so also take this opportunity to create a dependence on it.
-    inputMesh.positionOS.z = inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0;
-
-    float3 positionWS = TransformObjectToWorld(inputMesh.positionOS);
-    output.vmesh.positionCS = TransformWorldToHClip(positionWS);
-    output.vmesh.texCoord0 = inputMesh.uv0;
-    output.vmesh.texCoord1 = inputMesh.uv1;
+    // OpenGL right now needs to actually use the incoming vertex position
+    // so we create a fake dependency on it here that haven't any impact.
+    output.vmesh.positionCS = float4(uv * 2.0 - 1.0, inputMesh.positionOS.z > 0 ? 1.0e-4 : 0.0, 1.0);
+    output.vmesh.texCoord0  = inputMesh.uv0;
+    output.vmesh.texCoord1  = inputMesh.uv1;
 
 #if defined(VARYINGS_NEED_COLOR)
     output.vmesh.color = inputMesh.color;
     // input.unPositionSS is SV_Position
     PositionInputs posInput = GetPositionInput(input.unPositionSS.xy, _ScreenSize.zw);
     // No position and depth in case of light transport
-    float3 V = float3(0, 0, 1); // No vector view in case of light transport
+    float3 V = float3(0.0, 0.0, 1.0); // No vector view in case of light transport
 
     SurfaceData surfaceData;
     BuiltinData builtinData;
     LightTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
 
-    // This shader is call two time. Once for getting emissiveColor, the other time to get diffuseColor
+    // This shader is call two times. Once for getting emissiveColor, the other time to get diffuseColor
-
-    // TODO: No if / else in original code from Unity, why ? keep like original code but should be either diffuse or emissive
     if (unity_MetaFragmentControl.x)
     {
         // Apply diffuseColor Boost from LightmapSettings.
 
     if (unity_MetaFragmentControl.y)
     {
-        // TODO: THIS LIMIT MUST BE REMOVE, IT IS NOT HDR, change when RGB9e5 is here.
-        // Do we assume here that emission is [0..1] ?
-        res = PackEmissiveRGBM(lightTransportData.emissiveColor);
+        // emissive use HDR format
+        res.rgb = lightTransportData.emissiveColor;
     }
 
     return res;

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/VertMesh.hlsl

     ApplyWind(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, vertexColor.a, _Time);
 #endif
 
+    positionWS = GetCameraRelativePositionWS(positionWS);
+
 #ifdef TESSELLATION_ON
     output.positionWS = positionWS;
     #ifdef _TESSELLATION_OBJECT_SCALE

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl

 float4x4 _InvViewMatrix;
 float4x4 _InvProjMatrix;
 float4   _InvProjParam;
-float4   _ScreenSize;
+float4   _ScreenSize;       // (w, h, 1/w, 1/h)
+float4   _FrustumPlanes[6]; // (N, -dot(N, P))
 CBUFFER_END
 
 #ifdef USE_LEGACY_UNITY_MATRIX_VARIABLES

Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariablesFunctions.hlsl

     return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
 }
 
-float3 GetCurrentCameraPosition()
+float3 GetAbsolutePositionWS(float3 cameraRelativePositionWS)
+{
+    float3 pos = cameraRelativePositionWS;
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    pos += _WorldSpaceCameraPos;
+#endif
+    return pos;
+}
+
+float3 GetCameraRelativePositionWS(float3 absolutePositionWS)
+{
+    float3 pos = absolutePositionWS;
+#if (SHADEROPTIONS_CAMERA_RELATIVE_RENDERING != 0)
+    pos -= _WorldSpaceCameraPos;
+#endif
+    return pos;
+}
+
+// Note: '_WorldSpaceCameraPos' is set by the legacy Unity code.
+float3 GetPrimaryCameraPosition()
+{
+    return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
+}
+
+// Could be e.g. the position of a primary camera or a shadow-casting light.
+float3 GetCurrentViewPosition()
-    return _WorldSpaceCameraPos;
+    return GetPrimaryCameraPosition();
 #else
     // TEMP: this is rather expensive. Then again, we need '_WorldSpaceCameraPos'
     // to represent the position of the primary (scene view) camera in order to
     float3   rotCamPos = trViewMat[3].xyz;
-   return mul((float3x3)trViewMat, -rotCamPos);
+    return mul((float3x3)trViewMat, -rotCamPos);
-// Returns the forward direction of the current camera in the world space.
-float3 GetCameraForwardDir()
+// Returns the forward (central) direction of the current view in the world space.
+float3 GetViewForwardDir()
-// Returns 'true' if the current camera performs a perspective projection.
-bool IsPerspectiveCamera()
+// Returns 'true' if the current view performs a perspective projection.
+bool IsPerspectiveProjection()
 {
 #if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS)
     return (unity_OrthoParams.w == 0);
 #endif
 }
 
-// Computes the world space view direction (pointing towards the camera).
+// Computes the world space view direction (pointing towards the viewer).
-    if (IsPerspectiveCamera())
+    if (IsPerspectiveProjection())
-        float3 V = GetCurrentCameraPosition() - positionWS;
+        float3 V = GetCurrentViewPosition() - positionWS;
-        return -GetCameraForwardDir();
+        return -GetViewForwardDir();
     }
 }
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

                 overlayLineHeight = -1.0f;
             }
         }
+
+        // Just a sort function that doesn't allocate memory
+        // Note: Shoud be repalc by a radix sort for positive integer
+        static public int Partition(uint[] numbers, int left, int right)
+        {
+            uint pivot = numbers[left];
+            while (true)
+            {
+                while (numbers[left] < pivot)
+                    left++;
+
+                while (numbers[right] > pivot)
+                    right--;
+
+                if (left < right)
+                {
+                    uint temp = numbers[right];
+                    numbers[right] = numbers[left];
+                    numbers[left] = temp;
+                }
+                else
+                {
+                    return right;
+                }
+            }
+        }
+
+        static public void QuickSort(uint[] arr, int left, int right)
+        {
+            // For Recusrion
+            if (left < right)
+            {
+                int pivot = Partition(arr, left, right);
+
+                if (pivot > 1)
+                    QuickSort(arr, left, pivot - 1);
+
+                if (pivot + 1 < right)
+                    QuickSort(arr, pivot + 1, right);
+            }
+        }
     }
 }

Assets/ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent shadowLabel = new GUIContent("Shadows");
             public static GUIContent defaults = new GUIContent("Defaults");
 
-            public static GUIContent maxPixelLights = new GUIContent("Max per-pixel lights supported",
-                    "Amount of dynamic lights processed in fragment shader. More than 1 per-pixel light is not recommended.");
+            public static GUIContent maxPixelLights = new GUIContent("Per-Object Pixel Lights",
+                    "Max amount of dynamic per-object pixel lights.");
-                    "Enable up to 4 per-vertex dynamic lights.");
+                    "Lightweight pipeline support at most 4 per-object lights between pixel and vertex. If value in pixel lights is set to max this settings has no effect.");
-                    "Only non-directional lightmaps are supported");
+                    "Enabled/Disable support for non-directional lightmaps.");
-                    "Enables/Disabled light probe support.");
+                    "Enables/Disable light probe support.");
 
             public static GUIContent shadowType = new GUIContent("Shadow Type",
                     "Single directional shadow supported. SOFT_SHADOWS applies shadow filtering.");
                 "Percentages to split shadow volume");
 
             public static GUIContent defaultDiffuseMaterial = new GUIContent("Default Diffuse Material",
-                "Material to use when creating objects");
+                "Material to use when creating 3D objects");
+
+            public static GUIContent defaultParticleMaterial = new GUIContent("Default Particle Material",
+                "Material to use when creating Paticle Systems");
+
+            public static GUIContent defaultLineMaterial = new GUIContent("Default Line Material",
+                "Material to use when creating Line Renderers");
+
+            public static GUIContent defaultUIMaterial = new GUIContent("Default UI Material", "Material to use when creating UI Text");
+
+            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.");
         }
 
         private SerializedProperty m_MaxPixelLights;
         private SerializedProperty m_ShadowTypeProp;
         private SerializedProperty m_ShadowNearPlaneOffsetProp;
-        private SerializedProperty m_ShadowMinNormalBiasProperty;
-        private SerializedProperty m_ShadowNormalBiasProperty;
         private SerializedProperty m_ShadowDistanceProp;
         private SerializedProperty m_ShadowAtlasResolutionProp;
         private SerializedProperty m_ShadowCascadesProp;
+        private SerializedProperty m_DefaultParticleMaterial;
+        private SerializedProperty m_DefaultLineMaterial;
+        private SerializedProperty m_DefaultUIMaterial;
+        private SerializedProperty m_MSAA;
 
         void OnEnable()
         {
             m_EnableAmbientProbeProp = serializedObject.FindProperty("m_EnableAmbientProbe");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
             m_ShadowNearPlaneOffsetProp = serializedObject.FindProperty("m_ShadowNearPlaneOffset");
-            m_ShadowMinNormalBiasProperty = serializedObject.FindProperty("m_MinShadowNormalBias");
-            m_ShadowNormalBiasProperty = serializedObject.FindProperty("m_ShadowNormalBias");
             m_ShadowDistanceProp = serializedObject.FindProperty("m_ShadowDistance");
             m_ShadowAtlasResolutionProp = serializedObject.FindProperty("m_ShadowAtlasResolution");
             m_ShadowCascadesProp = serializedObject.FindProperty("m_ShadowCascades");
+            m_DefaultParticleMaterial = serializedObject.FindProperty("m_DefaultParticleMaterial");
+            m_DefaultLineMaterial = serializedObject.FindProperty("m_DefaultLineMaterial");
+            m_DefaultUIMaterial = serializedObject.FindProperty("m_DefaultUIMaterial");
+            m_MSAA = serializedObject.FindProperty("m_MSAA");
         }
 
         public override void OnInspectorGUI()
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.renderingLabel, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_MaxPixelLights, Styles.maxPixelLights);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(Styles.maxPixelLights);
+            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, 4);
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.PropertyField(m_MSAA, Styles.msaaContent);
             EditorGUI.indentLevel--;
             EditorGUILayout.Space();
             EditorGUILayout.Space();
 
             EditorGUI.indentLevel--;
 
+            EditorGUILayout.Space();
+            EditorGUILayout.PropertyField(m_DefaultParticleMaterial, Styles.defaultParticleMaterial);
+            EditorGUILayout.PropertyField(m_DefaultLineMaterial, Styles.defaultLineMaterial);
+            EditorGUILayout.PropertyField(m_DefaultUIMaterial, Styles.defaultUIMaterial);
             EditorGUILayout.PropertyField(m_DefaultShader, Styles.defaultShader);
             EditorGUI.indentLevel--;
 

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

         // Max amount of visible lights. This controls the lights constant buffers in shader but not the max shaded lights.
         // Lights are set per-object and the max shaded lights for each object are controlled by the max pixel lights in pipeline asset and kMaxVertexLights.
         private static readonly int kMaxVisibleLights = 16;
-        private static readonly int kMaxVertexLights = 4;
+        private static readonly int kMaxPerObjectLights = 4;
 
         private Vector4[] m_LightPositions = new Vector4[kMaxVisibleLights];
         private Vector4[] m_LightColors = new Vector4[kMaxVisibleLights];
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
         private int m_ShadowMapProperty;
+        private int m_CameraRTProperty;
-        private int m_DepthBufferBits = 16;
+        private RenderTargetIdentifier m_CameraRTID;
+
+        private bool m_RenderToIntermediateTarget = false;
+
+        private const int kShadowDepthBufferBits = 16;
+        private const int kCameraDepthBufferBits = 32;
         private Vector4[] m_DirectionalShadowSplitDistances = new Vector4[kMaxCascades];
 
         private ShadowSettings m_ShadowSettings = ShadowSettings.Default;
-        private static readonly ShaderPassName m_UnlitPassName = new ShaderPassName("SrpDefaultUnlit");
+        private static readonly ShaderPassName m_UnlitPassName = new ShaderPassName("SRPDefaultUnlit");
 
         public LightweightPipeline(LightweightPipelineAsset asset)
         {
             m_ShadowMapProperty = Shader.PropertyToID("_ShadowMap");
+            m_CameraRTProperty = Shader.PropertyToID("_CameraRT");
+            m_CameraRTID = new RenderTargetIdentifier(m_CameraRTProperty);
+
+            // Let engine know we have MSAA on for cases where we support MSAA backbuffer
+            if (QualitySettings.antiAliasing != m_Asset.MSAASampleCount)
+                QualitySettings.antiAliasing = m_Asset.MSAASampleCount;
+
             Shader.globalRenderPipeline = "LightweightPipeline";
         }
 
                 InitializeLightData(visibleLights, out lightData);
 
                 // Render Shadow Map
-                if (lightData.shadowLightIndex > -1) 
+                if (lightData.shadowLightIndex > -1)
-                // 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
-                var cmd = CommandBufferPool.Get("Clear");
-                cmd.ClearRenderTarget(true, true, camera.backgroundColor);
-                context.ExecuteCommandBuffer(cmd);
-                CommandBufferPool.Release(cmd);
-
                 // Setup light and shadow shader constants
                 SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
                 if (lightData.shadowsRendered)
                     configuration |= RendererConfiguration.PerObjectLightProbe;
 
                 if (!lightData.isSingleDirectionalLight)
-                    configuration |= RendererConfiguration.ProvideLightIndices;
+                    configuration |= RendererConfiguration.PerObjectLightIndices8;
+
+                BeginForwardRendering(camera, ref context);
 
                 // Render Opaques
                 var litSettings = new DrawRendererSettings(m_CullResults, camera, m_LitPassName);
 
                 var unlitSettings = new DrawRendererSettings(m_CullResults, camera, m_UnlitPassName);
-                unlitSettings.sorting.flags = SortFlags.CommonOpaque;
-                unlitSettings.inputFilter.SetQueuesOpaque();
+                unlitSettings.sorting.flags = SortFlags.CommonTransparent;
+                unlitSettings.inputFilter.SetQueuesTransparent();
 
                 context.DrawRenderers(ref litSettings);
 
+                discardRT.ReleaseTemporaryRT(m_CameraRTProperty);
-                CommandBufferPool.Release(cmd);
-
-                context.DrawRenderers(ref unlitSettings);
+                CommandBufferPool.Release(discardRT);
 
                 // TODO: Check skybox shader
                 context.DrawSkybox(camera);
                 litSettings.inputFilter.SetQueuesTransparent();
                 context.DrawRenderers(ref litSettings);
+                context.DrawRenderers(ref unlitSettings);
-                unlitSettings.sorting.flags = SortFlags.CommonTransparent;
-                unlitSettings.inputFilter.SetQueuesTransparent();
-                context.DrawRenderers(ref unlitSettings);
+                EndForwardRendering(camera, ref context);
             }
 
             context.Submit();
             }
 
             int lightsCount = lights.Length;
-            lightData.pixelLightsCount = Mathf.Min(lightsCount, m_Asset.MaxSupportedPixelLights);
-            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Mathf.Min(lightsCount - lightData.pixelLightsCount, kMaxVertexLights) : 0;
+            int maxPerPixelLights = Math.Min(m_Asset.MaxSupportedPixelLights, kMaxPerObjectLights);
+            lightData.pixelLightsCount = Math.Min(lightsCount, maxPerPixelLights);
+            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Math.Min(lightsCount - lightData.pixelLightsCount, kMaxPerObjectLights) : 0;
-            
+
-        private void FillLightIndices(ref CullResults cullResults, int visibleLightsCount)
-        {
-            //int visibleRenderersCount = cullResults.GetVisibleRenderersCount();
-            // TODO: commenting cullResults.GetVisislbeRenderersCount() to avoid compiler errors as it is not in main SRP trunk yet
-            // For now setting a small amount enough for the test scenes.
-            int visibleRenderersCount = 1024;
-            if (visibleRenderersCount > m_LightIndicesCount)
-            {
-                m_LightIndicesCount = visibleRenderersCount * visibleLightsCount;
-                if (m_LightIndexListBuffer != null)
-                    m_LightIndexListBuffer.Release();
-                m_LightIndexListBuffer = new ComputeBuffer(m_LightIndicesCount, sizeof(uint));
-            }
-            cullResults.FillLightIndices(m_LightIndexListBuffer);
-        }
-
-            if (lightData.isSingleDirectionalLight) 
+            if (lightData.isSingleDirectionalLight)
-                SetupShaderLightListConstants(lights, lightData.pixelLightsCount, ref cullResults, ref context);
+                SetupShaderLightListConstants(lights, ref lightData, ref context);
-             
+
             CommandBuffer cmd = new CommandBuffer() { name = "SetupLightConstants" };
             cmd.SetGlobalVector("_LightPosition0", new Vector4(lightDir.x, lightDir.y, lightDir.z, 0.0f));
             cmd.SetGlobalColor("_LightColor0", light.finalColor);
 
-        // TODO: Perform tests on light lights memory pattern access (SOA vs AOS vs Swizzling)
-        private void SetupShaderLightListConstants(VisibleLight[] lights, int pixelLightsCount, ref CullResults cullResults, ref ScriptableRenderContext context)
+        private void SetupShaderLightListConstants(VisibleLight[] lights, ref LightData lightData, ref ScriptableRenderContext context)
-            FillLightIndices(ref cullResults, lights.Length);
-            for (int i = 0; i < maxLights; ++i) 
+            for (int i = 0; i < maxLights; ++i)
-                if (currLight.lightType == LightType.Directional) 
+                if (currLight.lightType == LightType.Directional)
-                } 
-                else 
+                }
+                else
                 {
                     Vector4 pos = currLight.localToWorld.GetColumn (3);
                     m_LightPositions [i] = new Vector4 (pos.x, pos.y, pos.z, 1.0f);
                 float rangeSq = currLight.range * currLight.range;
                 float quadAtten = (currLight.lightType == LightType.Directional) ? 0.0f : 25.0f / rangeSq;
 
-                if (currLight.lightType == LightType.Spot) 
+                if (currLight.lightType == LightType.Spot)
                 {
                     Vector4 dir = currLight.localToWorld.GetColumn (2);
                     m_LightSpotDirections [i] = new Vector4 (-dir.x, -dir.y, -dir.z, 0.0f);
                     float angleRange = cosInneAngle - cosOuterAngle;
                     m_LightAttenuations [i] = new Vector4 (cosOuterAngle,
                         Mathf.Approximately (angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
-                } 
+                }
                 else
                 {
                     m_LightSpotDirections [i] = new Vector4 (0.0f, 0.0f, 1.0f, 0.0f);
 
+            // Lightweight pipeline only upload kMaxVisibleLights to shader cbuffer.
+            // We tell the pipe to disable remaining lights by setting it to -1.
+            int[] lightIndexMap = m_CullResults.GetLightIndexMap();
+            for (int i = kMaxVisibleLights; i < lightIndexMap.Length; ++i)
+                lightIndexMap[i] = -1;
+            m_CullResults.SetLightIndexMap(lightIndexMap);
+
-            cmd.SetGlobalVector("globalLightCount", new Vector4 (pixelLightsCount, 0.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVector("globalLightCount", new Vector4 (lightData.pixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
-            cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
         }
             var setRenderTargetCommandBuffer = CommandBufferPool.Get();
             setRenderTargetCommandBuffer.name = "Render packed shadows";
             setRenderTargetCommandBuffer.GetTemporaryRT(m_ShadowMapProperty, m_ShadowSettings.shadowAtlasWidth,
-                m_ShadowSettings.shadowAtlasHeight, m_DepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth,
-                RenderTextureReadWrite.Linear);
+                m_ShadowSettings.shadowAtlasHeight, kShadowDepthBufferBits, FilterMode.Bilinear, RenderTextureFormat.Depth);
             setRenderTargetCommandBuffer.SetRenderTarget(m_ShadowMapRTID);
             setRenderTargetCommandBuffer.ClearRenderTarget(true, true, Color.black);
             context.ExecuteCommandBuffer(setRenderTargetCommandBuffer);
         private void InitializeMainShadowLightIndex(VisibleLight[] lights, out int shadowIndex)
         {
             shadowIndex = -1;
+            if (m_Asset.CurrShadowType == ShadowType.NO_SHADOW)
+                return;
+
             float maxIntensity = -1;
             for (int i = 0; i < lights.Length; ++i)
             {
         private bool IsSupportedShadowType(LightType type)
         {
             return (type == LightType.Directional || type == LightType.Spot);
+        }
+
+        private void BeginForwardRendering(Camera camera, ref ScriptableRenderContext context)
+        {
+            m_RenderToIntermediateTarget = GetRenderToIntermediateTarget(camera);
+
+            var cmd = CommandBufferPool.Get("SetCameraRenderTarget");
+            if (m_RenderToIntermediateTarget)
+            {
+                if (camera.activeTexture == null)
+                {
+                    cmd.GetTemporaryRT(m_CameraRTProperty, Screen.width, Screen.height, kCameraDepthBufferBits,
+                        FilterMode.Bilinear, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default, m_Asset.MSAASampleCount);
+                    cmd.SetRenderTarget(m_CameraRTID);
+                }
+                else
+                {
+                    cmd.SetRenderTarget(new RenderTargetIdentifier(camera.activeTexture));
+                }
+            }
+            else
+            {
+                cmd.SetRenderTarget(BuiltinRenderTextureType.None);
+            }
+
+            // Clear RenderTarget to avoid tile initialization on mobile GPUs
+            // https://community.arm.com/graphics/b/blog/posts/mali-performance-2-how-to-correctly-handle-framebuffers
+            if (camera.clearFlags != CameraClearFlags.Nothing)
+                cmd.ClearRenderTarget(camera.clearFlags == CameraClearFlags.Color, camera.clearFlags == CameraClearFlags.Color || camera.clearFlags == CameraClearFlags.Depth, camera.backgroundColor);
+
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        private void EndForwardRendering(Camera camera, ref ScriptableRenderContext context)
+        {
+            if (!m_RenderToIntermediateTarget)
+                return;
+
+            var cmd = CommandBufferPool.Get("Blit");
+            cmd.Blit(BuiltinRenderTextureType.CurrentActive, BuiltinRenderTextureType.CameraTarget);
+            if (camera.cameraType == CameraType.SceneView)
+                cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
+        }
+
+        private bool GetRenderToIntermediateTarget(Camera camera)
+        {
+            bool allowMSAA = camera.allowMSAA && m_Asset.MSAASampleCount > 1 && !PlatformSupportsMSAABackBuffer();
+            if (camera.cameraType == CameraType.SceneView || allowMSAA || camera.activeTexture != null)
+                return true;
+
+            return false;
+        }
+
+        private bool PlatformSupportsMSAABackBuffer()
+        {
+#if UNITY_ANDROID || UNITY_IPHONE || UNITY_TVOS || UNITY_SAMSUNGTV
+            return true;
+#else
+            return false;
+#endif
         }
     }
 }

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_SupportsVertexLight: 1
   m_EnableLightmaps: 1
   m_EnableAmbientProbe: 1
+  m_MSAA: 4
   m_ShadowType: 1
   m_ShadowAtlasResolution: 1024
   m_ShadowNearPlaneOffset: 2
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}
   m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 6a1143ee683302f4aa628c052723efc1,
     type: 2}
+  m_DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
+    type: 2}
+  m_DefaultLineMaterial: {fileID: 2100000, guid: 541b04d3bf488324f816937313973e15,
+    type: 2}
+  m_DefaultUIMaterial: {fileID: 2100000, guid: 786cc499ea3906946b10ab7d24c8d0e7, type: 2}
   m_DefaultShader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         _2048 = 2048
     }
 
+    public enum MSAAQuality
+    {
+        Disabled = 1,
+        _2x = 2,
+        _4x = 4,
+        _8x = 8
+    }
+
     public class LightweightPipelineAsset : RenderPipelineAsset
     {
         private static readonly string m_PipelineFolder = "Assets/ScriptableRenderPipeline/LightweightPipeline";
         [SerializeField] private bool m_SupportsVertexLight = true;
         [SerializeField] private bool m_EnableLightmaps = true;
         [SerializeField] private bool m_EnableAmbientProbe = true;
+        [SerializeField] private MSAAQuality m_MSAA = MSAAQuality.Disabled;
         [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 Material m_DefaultDiffuseMaterial;
+        [SerializeField] private Material m_DefaultParticleMaterial;
+        [SerializeField] private Material m_DefaultLineMaterial;
+        [SerializeField] private Material m_DefaultUIMaterial;
         [SerializeField] private Shader m_DefaultShader;
 
         public int MaxSupportedPixelLights
             private set { m_EnableAmbientProbe = value; }
         }
 
+        public int MSAASampleCount
+        {
+            get { return (int)m_MSAA; }
+            set { m_MSAA = (MSAAQuality)value; }
+        }
+
         public ShadowType CurrShadowType
         {
             get { return m_ShadowType; }
             get { return (int)m_ShadowCascades; }
             private set { m_ShadowCascades = (ShadowCascades)value; }
         }
-       
+
         public float Cascade2Split
         {
             get { return m_Cascade2Split; }
 
         public override Material GetDefaultParticleMaterial()
         {
-            return m_DefaultDiffuseMaterial;
+            return m_DefaultParticleMaterial;
-            return m_DefaultDiffuseMaterial;
+            return m_DefaultLineMaterial;
         }
 
         public override Material GetDefaultTerrainMaterial()
 
         public override Material GetDefaultUIMaterial()
         {
-            return m_DefaultDiffuseMaterial;
+            return m_DefaultUIMaterial;
         }
 
         public override Material GetDefaultUIOverdrawMaterial()

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-Default.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: Lightweight-Default
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: 
+  m_ShaderKeywords: _SPECULAR_COLOR
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
     - _Mode: 0
     - _Parallax: 0.02
     - _ReflectionSource: 0
-    - _Shininess: 1
+    - _Shininess: 0.15
     - _SmoothnessTextureChannel: 0
     - _SpecSource: 0
     - _SpecularHighlights: 1

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultSprite.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: Lightweight-SpritesDefault
+  m_Name: Lightweight-DefaultSprite
-  m_ShaderKeywords: 
+  m_ShaderKeywords: ETC1_EXTERNAL_ALPHA
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader

 
 #if defined(_VERTEX_LIGHTS) && !defined(_SINGLE_DIRECTIONAL_LIGHT)
                 half4 diffuseAndSpecular = half4(1.0, 1.0, 1.0, 1.0);
-                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightCount.x;
-                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightCount.x);
+                // 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);
-                    int lightIndex = globalLightIndexList[lightIter];
+                    int lightIndex = unity_4LightIndices0[lightIter];
                     LightInput lightInput;
                     INITIALIZE_LIGHT(lightInput, lightIndex);
                     o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz);
 #ifdef _SHADOWS
                 half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
 #endif
-                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                for (int lightIter = unity_LightIndicesOffsetAndCount.x; lightIter < pixelLightEnd; ++lightIter)
+                int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+                for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
-                    int lightIndex = globalLightIndexList[lightIter];
+                    int lightIndex = unity_4LightIndices0[lightIter];
-                    // multiplies shadowAttenuation to avoid branching.
-                    // step will only evaluate to 1 when lightIndex == _ShadowData.x (shadowLightIndex)
-                    half currLightAttenuation = shadowAttenuation * step(abs(lightIndex - _ShadowData.x), 0);
+                    half currLightAttenuation = max(shadowAttenuation, half(lightIter != _ShadowData.x));
                     color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir) * currLightAttenuation;
 #else
                     color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir);

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc

 // Per object light list data
 #ifndef _SINGLE_DIRECTIONAL_LIGHT
 half4 unity_LightIndicesOffsetAndCount;
-StructuredBuffer<uint> globalLightIndexList;
+half4 unity_4LightIndices0;
 
 // The variables are very similar to built-in unity_LightColor, unity_LightPosition,
 // unity_LightAtten, unity_SpotDirection as used by the VertexLit shaders, except here

Assets/ScriptableRenderPipeline/LightweightPipeline/TestScenes/LDRenderPipelineBasicScene.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: 112000002, guid: 740b181ab47c46a47ae28377711d7097,
     type: 2}
   m_UseShadowmask: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1254169578
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1366180536
 Transform:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1447851825}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &1447851827
 Behaviour:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1449522779
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1659249726
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!108 &1677622457
 Light:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1911408598
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &2025477086
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

Assets/ScriptableRenderPipeline/LightweightPipeline/TestScenes/Materials/LDRenderPipeMaterials/MobilePlane.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: MobilePlane
   m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
-  m_ShaderKeywords: _EMISSION _GLOSSINESS_FROM_BASE_ALPHA _NORMALMAP _SHARED_SPECULAR_DIFFUSE
+  m_ShaderKeywords: _GLOSSINESS_FROM_BASE_ALPHA _NORMALMAP _SHARED_SPECULAR_DIFFUSE
+    _SPECULAR_COLOR
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []
     - _BumpMap:
         m_Texture: {fileID: 2800000, guid: d63435d934a30fd439a005c25fa542f0, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _DetailAlbedoMap:
     - _Mode: 0
     - _OcclusionStrength: 1
     - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 1
-    - _SpecSource: 1
+    - _SpecSource: 0
     - _SpecularHighlights: 1
     - _SpecularStrength: 64.1
     - _SrcBlend: 1

Assets/ScriptableRenderPipeline/LightweightPipeline/TestScenes/Textures/154.JPG.meta

 licenseType: Pro
 TextureImporter:
   fileIDToRecycleName: {}
+  externalObjects: {}
   serializedVersion: 4
   mipmaps:
     mipMapMode: 0
     fadeOut: 0
     borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
     mipMapFadeDistanceStart: 1
     mipMapFadeDistanceEnd: 3
   bumpmap:
   textureFormat: 1
   maxTextureSize: 2048
   textureSettings:
-    filterMode: -1
+    serializedVersion: 2
+    filterMode: 1
-    wrapMode: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
   nPOTScale: 1
   lightmap: 0
   compressionQuality: 50
   platformSettings:
   - buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
   - buildTarget: Standalone
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
   - buildTarget: iPhone
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
   - buildTarget: tvOS
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
   - buildTarget: Android
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
   - buildTarget: Windows Store Apps
     maxTextureSize: 2048
+    resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     compressionQuality: 50
     serializedVersion: 2
     sprites: []
     outline: []
+    physicsShape: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

     return positionSS;
 }
 
+float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
+{
+    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
+    float4 positionVS = mul(invProjMatrix, positionCS);
+    // The view space uses a right-handed coordinate system.
+    positionVS.z = -positionVS.z;
+    return positionVS.xyz / positionVS.w;
+}
+
-// It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
-// of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
 void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
 {
     posInput.depthRaw = depthRaw;
 
     // The compiler should optimize this (less expensive than reconstruct depth VS from depth buffer)
     posInput.depthVS = mul(viewProjMatrix, float4(posInput.positionWS, 1.0)).w;
-}
-
-// It may be necessary to flip the Y axis as the origin of the screen-space coordinate system
-// of Direct3D is at the top left corner of the screen, with the Y axis pointing downwards.
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
-{
-    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
-    float4 positionVS = mul(invProjMatrix, positionCS);
-    // The view space uses a right-handed coordinate system.
-    positionVS.z = -positionVS.z;
-    return positionVS.xyz / positionVS.w;
 }
 
 // The view direction 'V' points towards the camera.

Assets/ScriptableRenderPipeline/ShaderLibrary/CommonMaterial.hlsl

     return 0.25 * (expOneThird + 3 * expOneThird * expOneThird * expOneThird) * volumeAlbedo;
 }
 
+// Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+float ComputeWrappedDiffuseLighting(float NdotL, float w)
+{
+    return saturate((-NdotL + w) / ((1 + w) * (1 + w)));
+}
+
 // MACRO from Legacy Untiy
 // Transforms 2D UV by scale/bias property
 #define TRANSFORM_TEX(tex, name) ((tex.xy) * name##_ST.xy + name##_ST.zw)

Assets/ScriptableRenderPipeline/ShaderLibrary/Tessellation.hlsl

     return (dot(V, N) < backFaceCullEpsilon) ? true : false;
 }
 
-float2 GetScreenSpacePosition(float3 positionWS, float4x4 viewProjectionMatrix, float4 screenParams)
+float2 GetScreenSpacePosition(float3 positionWS, float4x4 viewProjectionMatrix, float4 screenSize)
-    return (positionSS * 0.5 + 0.5) * float2(screenParams.x, -screenParams.y);
+    return (positionSS * 0.5 + 0.5) * float2(screenSize.x, -screenSize.y);
-float3 GetScreenSpaceTessFactor(float3 p0, float3 p1, float3 p2, float4x4 viewProjectionMatrix, float4 screenParams, float triangleSize)
+float3 GetScreenSpaceTessFactor(float3 p0, float3 p1, float3 p2, float4x4 viewProjectionMatrix, float4 screenSize, float triangleSize)
-    float2 edgeScreenPosition0 = GetScreenSpacePosition(p0, viewProjectionMatrix, screenParams);
-    float2 edgeScreenPosition1 = GetScreenSpacePosition(p1, viewProjectionMatrix, screenParams);
-    float2 edgeScreenPosition2 = GetScreenSpacePosition(p2, viewProjectionMatrix, screenParams);
+    float2 edgeScreenPosition0 = GetScreenSpacePosition(p0, viewProjectionMatrix, screenSize);
+    float2 edgeScreenPosition1 = GetScreenSpacePosition(p1, viewProjectionMatrix, screenSize);
+    float2 edgeScreenPosition2 = GetScreenSpacePosition(p2, viewProjectionMatrix, screenSize);
 
     float EdgeScale = 1.0 / triangleSize; // Edge size in reality, but name is simpler
     float3 tessFactor;

Assets/TestScenes/HDTest/Material/StandardShaderMaterials/Gray.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Gray
-  m_Shader: {fileID: 0}
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/TestScenes/HDTest/Material/StandardShaderMaterials/Green.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Green
-  m_Shader: {fileID: 0}
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/TestScenes/HDTest/Material/StandardShaderMaterials/Red.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Red
-  m_Shader: {fileID: 0}
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

Assets/TestScenes/HDTest/Material/StandardShaderMaterials/Std_Blue_Emissive.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Std_Blue_Emissive
-  m_Shader: {fileID: 0}
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_DoubleSidedGI: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
   disabledShaderPasses: []

README.md

-# Unity Scriptable Render Loop testbed
+# Unity Scriptable Render Pipeline testbed
 
 **NOTE**: this is a testbed for a Unity feature that has not shipped yet! The latest commits in this project does not work
 with any public Unity version, and things in it might and will be broken.
 
 Did we mention it's a very WIP, no promises, may or might not ship feature, anything and everything in it can change? It totally is.
 
+## For Unity 2017.1 beta users
+SRP depends on PostProcessing submodule. Perform the following instructions to get a working copy of SRP:
+* git clone https://github.com/Unity-Technologies/ScriptableRenderLoop
+* git checkout unity-2017.1b5 (or the latest tag)
+* git submodule update --init --recursive
 
 ## For Unity 5.6 beta users
 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts.meta

+fileFormatVersion: 2
+guid: ac5e33c9370558b4d88db4eca81a4c4f
+folderAsset: yes
+timeCreated: 1498746585
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/Materials.meta

+fileFormatVersion: 2
+guid: 53a4327b506073b47b9c4e843d28f306
+folderAsset: yes
+timeCreated: 1498824718
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultETC1.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lightweight-DefaultETC1
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Mode: 0
+    - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultETC1.mat.meta

+fileFormatVersion: 2
+guid: 77da5f76bec40af47be3a3b79da0e81c
+timeCreated: 1499350842
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultLine.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lightweight-DefaultLine
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultLine.mat.meta

+fileFormatVersion: 2
+guid: 541b04d3bf488324f816937313973e15
+timeCreated: 1499342258
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultParticle.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lightweight-DefaultParticle
+  m_Shader: {fileID: 207, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultParticle.mat.meta

+fileFormatVersion: 2
+guid: e823cd5b5d27c0f4b8256e7c12ee3e6d
+timeCreated: 1499342173
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultUI.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Lightweight-DefaultUI
+  m_Shader: {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _ColorMask: 15
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Mode: 0
+    - _Parallax: 0.02
+    - _ReflectionSource: 0
+    - _Shininess: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UVSec: 0
+    - _UseUIAlphaClip: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Assets/ScriptableRenderPipeline/LightweightPipeline/Materials/Lightweight-DefaultUI.mat.meta

+fileFormatVersion: 2
+guid: 786cc499ea3906946b10ab7d24c8d0e7
+timeCreated: 1499329524
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightSpritesDefault.shader

+Shader "ScriptableRenderPipeline/LightweightPipeline/SpritesDefault"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex("Sprite Texture", 2D) = "white" {}
+        _Color("Tint", Color) = (1,1,1,1)
+        [MaterialToggle] PixelSnap("Pixel snap", Float) = 0
+        [HideInInspector] _RendererColor("RendererColor", Color) = (1,1,1,1)
+        [HideInInspector] _Flip("Flip", Vector) = (1,1,1,1)
+        [PerRendererData] _AlphaTex("External Alpha", 2D) = "white" {}
+        [PerRendererData] _EnableExternalAlpha("Enable External Alpha", Float) = 0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue" = "Transparent"
+            "IgnoreProjector" = "True"
+            "RenderType" = "Transparent"
+            "PreviewType" = "Plane"
+            "CanUseSpriteAtlas" = "True"
+            "RenderPipeline" = "LightweightPipeline"
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        Blend One OneMinusSrcAlpha
+
+        Pass
+        {
+            Tags {"Lightmode" = "LightweightForward"}
+            CGPROGRAM
+            #pragma vertex SpriteVert
+            #pragma fragment SpriteFrag
+            #pragma target 2.0
+            #pragma multi_compile_instancing
+            #pragma multi_compile _ PIXELSNAP_ON
+            #pragma multi_compile _ ETC1_EXTERNAL_ALPHA
+            #include "UnitySprites.cginc"
+            ENDCG
+        }
+    }
+}

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightSpritesDefault.shader.meta

+fileFormatVersion: 2
+guid: 4fa7301da83bc7d469cf2a5059581c57
+timeCreated: 1498831782
+licenseType: Pro
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/Boomerang.cs

+using System.Collections;
+using UnityEngine;
+
+public class Boomerang : MonoBehaviour
+{
+    public Transform m_Target1;
+    public Transform m_Target2;
+    public float m_Speed = 2f;
+
+    private Vector3 m_Direction;
+    private Vector3[] m_Targets = new Vector3[2];
+    private int m_TargetIndex = 0;
+
+    void OnEnable()
+    {
+        m_Targets[0] = m_Target1.position;
+        m_Targets[1] = m_Target2.position;
+        transform.position = m_Targets[0];
+        m_Direction = Vector3.Normalize(m_Targets[1] - m_Targets[0]);
+
+        m_TargetIndex = 1;
+    }
+
+    void Update()
+    {
+        transform.position += m_Direction * m_Speed * Time.deltaTime;
+        Vector3 targetPosVec = m_Targets[m_TargetIndex] - transform.position;
+        if (Vector3.Dot(targetPosVec, m_Direction) < 0)
+        {
+            m_TargetIndex = (m_TargetIndex + 1) % 2;
+            m_Direction = -m_Direction;
+        }
+    }
+}

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/Boomerang.cs.meta

+fileFormatVersion: 2
+guid: e41d23cf7d8aa3f4cad90e0f87b9db57
+timeCreated: 1498748776
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/RotateAround.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class RotateAround : MonoBehaviour
+{
+    public Transform m_RotationPivot;
+    public float m_DegreePerSecond;
+
+    public void Update()
+    {
+        float step = m_DegreePerSecond * Time.deltaTime;
+        transform.RotateAround(m_RotationPivot.transform.position, Vector3.up, step);
+    }
+}

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/RotateAround.cs.meta

+fileFormatVersion: 2
+guid: 200ecff91ea6fc2429eb4ae8898b002d
+timeCreated: 1498746574
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/Materials/MobileReflection.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: MobileReflection
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_ShaderKeywords: _REFLECTION_PROBE _SPECULAR_COLOR
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Cube:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossinessSource: 0
+    - _GlossyReflections: 1
+    - _Mode: 0
+    - _Parallax: 0.02
+    - _ReflectionSource: 2
+    - _Shininess: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 1, g: 1, b: 1, a: 1}

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/Materials/MobileReflection.mat.meta

+fileFormatVersion: 2
+guid: c93c9e065d18f0b419ba14e6c5cbb204
+timeCreated: 1498824742
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Packages/Config/manifest.json

+{
+	"dependencies": {
+	}
+}

Packages/Config/manifest.json.meta

+fileFormatVersion: 2
+guid: 4da0f3a9d8c6b614ca13a0b9857c0298
+timeCreated: 1499267976
+licenseType: Pro
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: