Merge branch 'master' into scriptablerenderloop-materialgraph

# Conflicts:
#	Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Editor/LitUI.cs

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             skyParameters.skyHDRI = (Cubemap)EditorGUILayout.ObjectField("Cubemap", skyParameters.skyHDRI, typeof(Cubemap), false);
             skyParameters.exposure = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyExposure, skyParameters.exposure), 32), -32);
             skyParameters.multiplier = Mathf.Max(EditorGUILayout.FloatField(styles.skyMultiplier, skyParameters.multiplier), 0);
-            skyParameters.rotation = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyRotation, skyParameters.rotation), 360), 0);
+            skyParameters.rotation = Mathf.Max(Mathf.Min(EditorGUILayout.FloatField(styles.skyRotation, skyParameters.rotation), 360), -360);
  
             if (EditorGUI.EndChangeCheck())
             {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

-// Must be in sync with ShaderConfig.cs
-//#define VELOCITY_IN_GBUFFER
-
 using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
 using System.Collections.Generic;
         }
 #endif
 
-        public class SkyParameters
-        {
-            public Cubemap skyHDRI;
-            public float rotation;
-            public float exposure;
-            public float multiplier;
-        }
-
+        SkyRenderer m_SkyRenderer = null;
         [SerializeField]
         SkyParameters m_SkyParameters = new SkyParameters();
  
                 }
             }
 
-            public RenderTargetIdentifier[] GetGBuffers(CommandBuffer cmd)
+            public RenderTargetIdentifier[] GetGBuffers()
             {
                 var colorMRTs = new RenderTargetIdentifier[gbufferCount];
                 for (int index = 0; index < gbufferCount; index++)
         TextureSettings m_TextureSettings = TextureSettings.Default;
 
         // Various set of material use in render loop
-        Material m_SkyboxMaterial;
-        Material m_SkyHDRIMaterial;
-        Material m_DeferredMaterial;
         Material m_FinalPassMaterial;
         Material m_DebugViewMaterialGBuffer;
 
         int m_VelocityBuffer;
         int m_DistortionBuffer;
 
+        RenderTargetIdentifier m_CameraColorBufferRT;
+        RenderTargetIdentifier m_CameraDepthBufferRT;
+        RenderTargetIdentifier m_VelocityBufferRT;
+        RenderTargetIdentifier m_DistortionBufferRT;
+		
         public class LightList
         {
             public List<DirectionalLightData> directionalLights;
             Rebuild();
         }
 
-        Material CreateEngineMaterial(string shaderPath)
-        {
-            var mat = new Material(Shader.Find(shaderPath) as Shader)
-            {
-                hideFlags = HideFlags.HideAndDontSave
-            };
-            return mat;
-        }
-
-            // TODO: We need to have an API to send our sky information to Enlighten. For now use a workaround through skybox/cubemap material...
-            m_SkyboxMaterial = CreateEngineMaterial("Skybox/Cubemap");
-            RenderSettings.skybox = m_SkyboxMaterial; // Setup this material as the default to be use in RenderSettings
-            RenderSettings.ambientIntensity = 1.0f; // fix this to 1, this parameter should not exist!
-            RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox; // Force skybox for our HDRI
-            RenderSettings.reflectionIntensity = 1.0f;
-        
-            m_SkyHDRIMaterial = CreateEngineMaterial("Hidden/HDRenderLoop/SkyHDRI");
-            m_DeferredMaterial   = CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
-            m_FinalPassMaterial  = CreateEngineMaterial("Hidden/HDRenderLoop/FinalPass");
-            m_DebugViewMaterialGBuffer = CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewMaterialGBuffer");
+            m_CameraColorBufferRT = new RenderTargetIdentifier(m_CameraColorBuffer);
+            m_CameraDepthBufferRT = new RenderTargetIdentifier(m_CameraDepthBuffer);
+
+            m_SkyRenderer = new SkyRenderer();
+            m_SkyRenderer.Rebuild();
+
+            m_FinalPassMaterial  = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/FinalPass");
+            m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewMaterialGBuffer");
 
             m_ShadowPass = new ShadowRenderPass(m_ShadowSettings);
 
                 m_gbufferManager.SetBufferDescription(m_gbufferManager.gbufferCount, "_VelocityTexture", Builtin.RenderLoop.GetVelocityBufferFormat(), Builtin.RenderLoop.GetVelocityBufferReadWrite());
                 m_gbufferManager.gbufferCount++;
             }
+            m_VelocityBufferRT = new RenderTargetIdentifier(m_VelocityBuffer);
+            m_DistortionBufferRT = new RenderTargetIdentifier(m_DistortionBuffer);
 
             m_LitRenderLoop.Rebuild();
 
             m_SinglePassLightLoop.OnDisable();
             m_TilePassLightLoop.OnDisable();
 
-            if (m_SkyboxMaterial) DestroyImmediate(m_SkyboxMaterial);
-            if (m_SkyHDRIMaterial) DestroyImmediate(m_SkyHDRIMaterial);
-            if (m_DeferredMaterial)  DestroyImmediate(m_DeferredMaterial);
-            if (m_FinalPassMaterial) DestroyImmediate(m_FinalPassMaterial);
-            if (m_DebugViewMaterialGBuffer) DestroyImmediate(m_DebugViewMaterialGBuffer);
+            Utilities.Destroy(m_FinalPassMaterial);
+            Utilities.Destroy(m_DebugViewMaterialGBuffer);
+
+            m_SkyRenderer.OnDisable();
         }
 
         void NewFrame()
                 {
                     m_gbufferManager.InitGBuffers(w, h, cmd);
                 }
-
-                cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraColorBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
-                cmd.ClearRenderTarget(true, false, new Color(0, 0, 0, 0));
+
+                Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearDepth);
             }
 
 
             {
-                var cmd = new CommandBuffer();
-                cmd.name = "Clear HDR target";
-                cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraColorBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
-                cmd.ClearRenderTarget(false, true, new Color(0, 0, 0, 0));
-                renderLoop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black, "Clear HDR target");
-                var cmd = new CommandBuffer();
-                cmd.name = "Clear GBuffer";
-                // Write into the Camera Depth buffer
-                cmd.SetRenderTarget(m_gbufferManager.GetGBuffers(cmd), new RenderTargetIdentifier(m_CameraDepthBuffer));
-                // Clear everything
-                // TODO: Clear is not required for color as we rewrite everything, will save performance.
-                cmd.ClearRenderTarget(false, true, new Color(0, 0, 0, 0));
-                renderLoop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                Utilities.SetRenderTarget(renderLoop, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, ClearFlag.ClearColor, Color.black, "Clear GBuffer");
-        void RenderOpaqueNoLightingRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
+        void RenderOpaqueRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
         {
             if (!debugParameters.displayOpaqueObjects)
                 return;
-                rendererConfiguration = 0,
+                rendererConfiguration = rendererConfiguration,
                 sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
             };        
             settings.inputFilter.SetQueuesOpaque();
-        void RenderOpaqueRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
-        {
-            if (!debugParameters.displayOpaqueObjects)
-                return;
-
-            var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
-            {
-                rendererConfiguration = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume,
-                sorting = { sortOptions = SortOptions.SortByMaterialThenMesh }
-            };
-            settings.inputFilter.SetQueuesOpaque();
-            renderLoop.DrawRenderers(ref settings);
-        }
-
-        void RenderTransparentNoLightingRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)
-        {
-            if (!debugParameters.displayTransparentObjects)
-                return;
-
-            var settings = new DrawRendererSettings(cull, camera, new ShaderPassName(passName))
-            {
-                rendererConfiguration = 0,
-                sorting = { sortOptions = SortOptions.BackToFront }
-            };
-            settings.inputFilter.SetQueuesTransparent();
-            renderLoop.DrawRenderers(ref settings);
-        }
-
-        void RenderTransparentRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName)        
+        void RenderTransparentRenderList(CullResults cull, Camera camera, RenderLoop renderLoop, string passName, RendererConfiguration rendererConfiguration = 0)
         {
             if (!debugParameters.displayTransparentObjects)
                 return;
-                rendererConfiguration = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume,
+                rendererConfiguration = rendererConfiguration,
                 sorting = { sortOptions = SortOptions.BackToFront }
             };
             settings.inputFilter.SetQueuesTransparent();
             if (!debugParameters.useDepthPrepass)
                 return;
 
-              // TODO: Must do opaque then alpha masked for performance! 
+            // TODO: Must do opaque then alpha masked for performance! 
-            var cmd = new CommandBuffer { name = "Depth Prepass" };
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraDepthBuffer));
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-
-            RenderOpaqueNoLightingRenderList(cull, camera, renderLoop, "DepthOnly");
+            Utilities.SetRenderTarget(renderLoop, m_CameraDepthBufferRT, "Depth Prepass");
+            RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
         }
 
         void RenderGBuffer(CullResults cull, Camera camera, RenderLoop renderLoop)
             }
 
             // setup GBuffer for rendering
-            var cmd = new CommandBuffer { name = "GBuffer Pass" };
-            cmd.SetRenderTarget(m_gbufferManager.GetGBuffers(cmd), new RenderTargetIdentifier(m_CameraDepthBuffer));
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-
+            Utilities.SetRenderTarget(renderLoop, m_gbufferManager.GetGBuffers(), m_CameraDepthBufferRT, "GBuffer Pass");
-            RenderOpaqueRenderList(cull, camera, renderLoop, "GBuffer");
+            RenderOpaqueRenderList(cull, camera, renderLoop, "GBuffer", Utilities.kRendererConfigurationBakedLighting);
         }
 
         // This pass is use in case of forward opaque and deferred rendering. We need to render forward objects before tile lighting pass
                 return;
 
             // TODO: Use the render queue index to only send the forward opaque!
-            var cmd = new CommandBuffer { name = "Depth Prepass" };
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraDepthBuffer));
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-
-            RenderOpaqueNoLightingRenderList(cull, camera, renderLoop, "DepthOnly");
+            Utilities.SetRenderTarget(renderLoop, m_CameraDepthBufferRT, "Clear HDR target");
+			RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
         }
 
         void RenderDebugViewMaterial(CullResults cull, Camera camera, RenderLoop renderLoop)
-                var cmd = new CommandBuffer { name = "DebugView Material Mode Pass" };
-                cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraColorBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
-                cmd.ClearRenderTarget(true, true, new Color(0, 0, 0, 0));
-                renderLoop.ExecuteCommandBuffer(cmd);
-                cmd.Dispose();
+                Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, Utilities.kClearAll, Color.black, "DebugView Material Mode Pass");
 
                 Shader.SetGlobalInt("_DebugViewMaterial", (int)debugParameters.debugViewMaterial);
 
             // Render GBuffer opaque
             if (!debugParameters.useForwardRenderingOnly)
             {
-                Vector4 screenSize = ComputeScreenSize(camera);
+                Vector4 screenSize = Utilities.ComputeScreenSize(camera);
-                // m_gbufferManager.BindBuffers(m_DeferredMaterial);
+                // m_gbufferManager.BindBuffers(m_DebugViewMaterialGBuffer);
-                cmd.Blit(null, new RenderTargetIdentifier(m_CameraColorBuffer), m_DebugViewMaterialGBuffer, 0);
+                cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
                 renderLoop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
             // Last blit
             {
                 var cmd = new CommandBuffer { name = "Blit DebugView Material Debug" };
-                cmd.Blit(new RenderTargetIdentifier(m_CameraColorBuffer), BuiltinRenderTextureType.CameraTarget);
+                cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
-        Matrix4x4 GetViewProjectionMatrix(Camera camera)
-        {
-            // The actual projection matrix used in shaders is actually massaged a bit to work across all platforms
-            // (different Z value ranges etc.)
-            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false);
-            var gpuVP = gpuProj * camera.worldToCameraMatrix;
-
-            return gpuVP;
-        }
-
-        Vector4 ComputeScreenSize(Camera camera)
-        {
-            return new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
-        }
-
         void RenderDeferredLighting(Camera camera, RenderLoop renderLoop)
         {
             if (debugParameters.useForwardRenderingOnly)
             // Bind material data
             m_LitRenderLoop.Bind();
 
-            var invViewProj = GetViewProjectionMatrix(camera).inverse;
-            m_DeferredMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
-
-            var screenSize = ComputeScreenSize(camera);
-            m_DeferredMaterial.SetVector("_ScreenSize", screenSize);
-
-            // m_gbufferManager.BindBuffers(m_DeferredMaterial);
-            // TODO: Bind depth textures
-            var cmd = new CommandBuffer { name = "Deferred Ligthing Pass" };
-            cmd.Blit(null, new RenderTargetIdentifier(m_CameraColorBuffer), m_DeferredMaterial, 0);
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
+           // m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, );
-            /*
-            // Render sky into a cubemap - doesn't happen every frame, can be control
-
-            // TODO: do a render to texture here
-
-            // Downsample the cubemap and provide it to Enlighten
-
-            // TODO: currently workaround is to set the cubemap in a Skybox/cubemap material
-            //m_SkyboxMaterial.SetTexture(cubemap);
-
-            // Render the sky itself
-
-            Vector3[] vertData = new Vector3[4];
-            vertData[0] = new Vector3(-1.0f, -1.0f, 0.0f);
-            vertData[1] = new Vector3(1.0f, -1.0f, 0.0f);
-            vertData[2] = new Vector3(1.0f, 1.0f, 0.0f);
-            vertData[3] = new Vector3(-1.0f, 1.0f, 0.0f);            
-
-            Vector3[] eyeVectorData = new Vector3[4];
-            // camera.worldToCameraMatrix, camera.projectionMatrix
-            // Get view vector vased on the frustrum, i.e (invert transform frustrum get position etc...)
-            eyeVectorData[0] = 
-            eyeVectorData[1] = 
-            eyeVectorData[2] = 
-            eyeVectorData[3] = 
-
-            // Write out the mesh
-            var triangles = new int[4];
-            for (int i = 0; i < 4; i++)
-            {
-                triangles[i] = i;
-            }
-
-            Mesh mesh = new Mesh
-            {
-                vertices = vertData,
-                normals = eyeVectorData,
-                triangles = triangles
-            };
-
-            m_SkyHDRIMaterial.SetTexture("_Cubemap", skyParameters.skyHDRI);
-            m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(skyParameters.exposure, skyParameters.multiplier, skyParameters.rotation, 0.0f));
-
-            var cmd = new CommandBuffer { name = "Skybox" };
-            cmd.DrawMesh(mesh, Matrix4x4.identity, m_SkyHDRIMaterial);
-            renderloop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-            */
+            m_SkyRenderer.RenderSky(camera, m_SkyParameters, m_CameraColorBufferRT, m_CameraDepthBufferRT, renderLoop);
         }
 
         void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop)
 
-            var cmd = new CommandBuffer { name = "Forward Pass" };
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraColorBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, "Forward Pass");
 
             if (debugParameters.useForwardRenderingOnly)
             {
-            RenderTransparentRenderList(cullResults, camera, renderLoop, "Forward");
+            RenderTransparentRenderList(cullResults, camera, renderLoop, "Forward", Utilities.kRendererConfigurationBakedLighting);
         }
 
         void RenderForwardUnlit(CullResults cullResults, Camera camera, RenderLoop renderLoop)
 
-            var cmd = new CommandBuffer { name = "Forward Unlit Pass" };
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_CameraColorBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
-
-            RenderOpaqueNoLightingRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
-            RenderTransparentNoLightingRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+            Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, "Forward Unlit Pass");
+            RenderOpaqueRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
+            RenderTransparentRenderList(cullResults, camera, renderLoop, "ForwardUnlit");
         }
 
         void RenderVelocity(CullResults cullResults, Camera camera, RenderLoop renderLoop)
 
             var cmd = new CommandBuffer { name = "Velocity Pass" };
             cmd.GetTemporaryRT(m_VelocityBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetVelocityBufferFormat(), Builtin.RenderLoop.GetVelocityBufferReadWrite());
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_VelocityBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
+            cmd.SetRenderTarget(m_VelocityBufferRT, m_CameraDepthBufferRT);
-            RenderOpaqueNoLightingRenderList(cullResults, camera, renderLoop, "MotionVectors");
+            RenderOpaqueRenderList(cullResults, camera, renderLoop, "MotionVectors");
 #pragma warning restore 162, 429
         }
 
 
             var cmd = new CommandBuffer { name = "Distortion Pass" };
             cmd.GetTemporaryRT(m_DistortionBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetDistortionBufferFormat(), Builtin.RenderLoop.GetDistortionBufferReadWrite());
-            cmd.SetRenderTarget(new RenderTargetIdentifier(m_DistortionBuffer), new RenderTargetIdentifier(m_CameraDepthBuffer));
+            cmd.SetRenderTarget(m_DistortionBufferRT, m_CameraDepthBufferRT);
-            RenderTransparentNoLightingRenderList(cullResults, camera, renderLoop, "DistortionVectors");
+            RenderTransparentRenderList(cullResults, camera, renderLoop, "DistortionVectors");
         }
 
 
             var cmd = new CommandBuffer { name = "FinalPass" };
 
             // Resolve our HDR texture to CameraTarget.
-            cmd.Blit(new RenderTargetIdentifier(m_CameraColorBuffer), BuiltinRenderTextureType.CameraTarget, m_FinalPassMaterial, 0);
+            cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget, m_FinalPassMaterial, 0);
             renderLoop.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
         }
                     m_TilePassLightLoop.BuildGPULightLists(camera, renderLoop, m_lightList, m_CameraDepthBuffer);
 
                     PushGlobalParams(camera, renderLoop, m_lightList);
-
-                    
 
                     RenderDeferredLighting(camera, renderLoop);
 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Resources/Deferred.shader

             #pragma multi_compile LIGHTLOOP_SINGLE_PASS
             //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF 
 
+        // TODO: This must be on lightloop side and include here....
+#pragma multi_compile USE_FPTL_LIGHTLIST    USE_CLUSTERED_LIGHTLIST
+#pragma multi_compile __ ENABLE_DEBUG
+
             //-------------------------------------------------------------------------------------
             // Include
             //-------------------------------------------------------------------------------------
                 Coordinate coord = GetCoordinate(unPositionSS.xy, _ScreenSize.zw);
 
                 // No need to manage inverse depth, this is handled by the projection matrix
-                float depth = _CameraDepthTexture.Load(uint3(coord.unPositionSS, 0)).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, uint3(coord.unPositionSS, 0)).x;
                 float3 positionWS = UnprojectToWorld(depth, coord.positionSS, _InvViewProjMatrix);
                 float3 V = GetWorldSpaceNormalizeViewDir(positionWS);
 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.cs

 using UnityEngine;
+using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
 using System;
 
             static ComputeBuffer s_AreaLightList;
             static ComputeBuffer s_PunctualShadowList;
             static ComputeBuffer s_DirectionalShadowList;
+
+            Material m_DeferredMaterial;
 
             void ClearComputeBuffers()
             {
                 s_AreaLightList = new ComputeBuffer(HDRenderLoop.k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
                 s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
+
+                m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
             }
 
             public void OnDisable()
                 s_EnvLightList = null;
                 s_PunctualShadowList.Release();
                 s_PunctualShadowList = null;
+
+                Utilities.Destroy(m_DeferredMaterial);
             }
 
             public void PrepareLightsForGPU(CullResults cullResults, Camera camera, HDRenderLoop.LightList lightList) {}
                 Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
                 Shader.SetGlobalInt("_EnvLightCount", lightList.envLights.Count);
 
-                Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);
-                
+                Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);      
+            }
+
+            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier colorBuffer)
+            {
+                var invViewProj = Utilities.GetViewProjectionMatrix(camera).inverse;
+                m_DeferredMaterial.SetMatrix("_InvViewProjMatrix", invViewProj);
+
+                var screenSize = Utilities.ComputeScreenSize(camera);
+                m_DeferredMaterial.SetVector("_ScreenSize", screenSize);
+
+                // m_gbufferManager.BindBuffers(m_DeferredMaterial);
+                // TODO: Bind depth textures
+                var cmd = new CommandBuffer { name = "Single Pass - Deferred Ligthing Pass" };
+                cmd.Blit(null, colorBuffer, m_DeferredMaterial, 0);
+                renderLoop.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePassLoop.hlsl

     {
         float3 localDiffuseLighting, localSpecularLighting;
 
-        EvaluateBSDF_Area(context, V, positionWS, prelightData, _AreaLightList[i], bsdfData,
-                          localDiffuseLighting, localSpecularLighting);
+        if (_AreaLightList[i].lightType == GPULIGHTTYPE_LINE)
+        {
+            EvaluateBSDF_Line(context, V, positionWS, prelightData, _AreaLightList[i], bsdfData,
+                              localDiffuseLighting, localSpecularLighting);
+        }
+        else
+        {
+            EvaluateBSDF_Area(context, V, positionWS, prelightData, _AreaLightList[i], bsdfData,
+                              localDiffuseLighting, localSpecularLighting);
+        }
 
         diffuseLighting  += localDiffuseLighting;
         specularLighting += localSpecularLighting;

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild-bigtile.compute

 #pragma kernel BigTileLightListGen
 
+#include "common.hlsl"
 #include "../TilePass.cs.hlsl"
 #include "../LightingConvexHullUtils.hlsl"
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild-clustered.compute

 #pragma kernel TileLightListGen_DepthRT_MSAA_SrcBigTile		LIGHTLISTGEN=TileLightListGen_DepthRT_MSAA_SrcBigTile		ENABLE_DEPTH_TEXTURE_BACKPLANE		MSAA_ENABLED		USE_TWO_PASS_TILED_LIGHTING
 #pragma kernel ClearAtomic
 
+#include "common.hlsl"
 #include "../ShaderBase.hlsl"
 #include "../TilePass.cs.hlsl"
 #include "../LightingConvexHullUtils.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/lightlistbuild.compute

 #pragma kernel TileLightListGen					LIGHTLISTGEN=TileLightListGen
 #pragma kernel TileLightListGen_SrcBigTile		LIGHTLISTGEN=TileLightListGen_SrcBigTile		USE_TWO_PASS_TILED_LIGHTING
 
+#include "common.hlsl"
 #include "../ShaderBase.hlsl"
 #include "../TilePass.cs.hlsl"
 #include "../LightingConvexHullUtils.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/Resources/scrbound.compute

 
 #pragma kernel ScreenBoundsAABB
 
+#include "common.hlsl"
 #include "../TilePass.cs.hlsl"
 
 uniform int g_iNrVisibLights;

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/ShaderBase.hlsl

 
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
-    return 1 - depthTexture.Load(uint3(pixCoord.xy, 0)).x;
+    return 1 - LOAD_TEXTURE2D(depthTexture, uint3(pixCoord.xy, 0)).x;
-    return 1 - depthTexture.Load(uint3(pixCoord.xy, 0), sampleIdx).x;
+    return 1 - LOAD_TEXTURE2D_MSAA(depthTexture, uint3(pixCoord.xy, 0), sampleIdx).x;
 }
 
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs

                 }
             }
 
+            // Static keyword is required here else we get a "DestroyBuffer can only be call in main thread"
+            static ComputeBuffer s_DirectionalLights;
+            static ComputeBuffer s_PunctualLightList;
+            static ComputeBuffer s_EnvLightList;
+            static ComputeBuffer s_AreaLightList;
+            static ComputeBuffer s_PunctualShadowList;
+            static ComputeBuffer s_DirectionalShadowList;
+
+            Material m_DeferredMaterial;
+            Material m_DeferredReflectionMaterial;
+
             // Local function
             void ClearComputeBuffers()
             {
                     if (s_GlobalLightListAtomic != null)
                         s_GlobalLightListAtomic.Release();
                 }
+
+                if (s_DirectionalLights != null)
+                    s_DirectionalLights.Release();
+
+                if (s_DirectionalShadowList != null)
+                    s_DirectionalShadowList.Release();
+
+                if (s_PunctualLightList != null)
+                    s_PunctualLightList.Release();
+
+                if (s_AreaLightList != null)
+                    s_AreaLightList.Release();
+
+                if (s_PunctualShadowList != null)
+                    s_PunctualShadowList.Release();
+
+                if (s_EnvLightList != null)
+                    s_EnvLightList.Release();
             }
 
             public void Rebuild()
                     s_GlobalLightListAtomic = new ComputeBuffer(1, sizeof(uint));
                 }
 
-
                 if (enableBigTilePrepass)
                 {
                     s_GenListPerBigTileKernel = buildPerBigTileLightListShader.FindKernel("BigTileLightListGen");
                 m_boundData = new SFiniteLightBound[MaxNumLights];
                 m_lightData = new SFiniteLightData[MaxNumLights];
                 m_lightCount = 0;
+
+                s_DirectionalLights = new ComputeBuffer(HDRenderLoop.k_MaxDirectionalLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
+                s_DirectionalShadowList = new ComputeBuffer(HDRenderLoop.k_MaxCascadeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalShadowData)));
+                s_PunctualLightList = new ComputeBuffer(HDRenderLoop.k_MaxPunctualLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
+                s_AreaLightList = new ComputeBuffer(HDRenderLoop.k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
+                s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
+                s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
+
+      //          m_DeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/TileDeferred");
+       //         m_DeferredReflectionMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/TileDeferredReflection");
             }
 
             public void OnDisable()
                 {
                     s_GlobalLightListAtomic.Release();
                 }
+
+                s_DirectionalLights.Release();
+                s_DirectionalLights = null;
+                s_DirectionalShadowList.Release();
+                s_DirectionalShadowList = null;
+                s_PunctualLightList.Release();
+                s_PunctualLightList = null;
+                s_AreaLightList.Release();
+                s_AreaLightList = null;
+                s_EnvLightList.Release();
+                s_EnvLightList = null;
+                s_PunctualShadowList.Release();
+                s_PunctualShadowList = null;
+/*
+                Utilities.Destroy(m_DeferredMaterial);
+                Utilities.Destroy(m_DeferredReflectionMaterial);
+*/
-            
             public bool NeedResize()
             {
                 return s_LightList == null || (s_BigTileLightList == null && enableBigTilePrepass) || (s_PerVoxelLightLists == null && enableClustered);
                     cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, "g_vLightList", s_BigTileLightList);
                     cmd.DispatchCompute(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, numBigTilesX, numBigTilesY, 1);
                 }
-
+/*
                 if (usingFptl)       // optimized for opaques only
                 {
                     cmd.SetComputeIntParams(buildPerTileLightListShader, "g_viDimensions", new int[2] { w, h });
                 {
                     VoxelLightListGeneration(cmd, camera, projscr, invProjscr, cameraDepthBuffer);
                 }
+                */
+                loop.ExecuteCommandBuffer(cmd);
+                cmd.Dispose();
+            }
+
+            public void PushGlobalParams(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList)
+            {
+                s_DirectionalLights.SetData(lightList.directionalLights.ToArray());
+                s_DirectionalShadowList.SetData(lightList.directionalShadows.ToArray());
+                s_PunctualLightList.SetData(lightList.punctualLights.ToArray());
+                s_AreaLightList.SetData(lightList.areaLights.ToArray());
+                s_EnvLightList.SetData(lightList.envLights.ToArray());
+                s_PunctualShadowList.SetData(lightList.punctualShadows.ToArray());
+
+                Shader.SetGlobalBuffer("_DirectionalLightList", s_DirectionalLights);
+                Shader.SetGlobalInt("_DirectionalLightCount", lightList.directionalLights.Count);
+                Shader.SetGlobalBuffer("_DirectionalShadowList", s_DirectionalShadowList);
+                Shader.SetGlobalBuffer("_PunctualLightList", s_PunctualLightList);
+                Shader.SetGlobalBuffer("_AreaLightList", s_AreaLightList);
+                Shader.SetGlobalBuffer("_PunctualShadowList", s_PunctualShadowList);
+                Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
+ 
+                Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);
+
+                /*
+                if (enableBigTilePrepass)
+                    cmd.SetGlobalBuffer("g_vBigTileLightList", s_BigTileLightList);
+
+                if (enableClustered)
+                {
+                    cmd.SetGlobalFloat("g_fClustScale", m_ClustScale);
+                    cmd.SetGlobalFloat("g_fClustBase", k_ClustLogBase);
+                    cmd.SetGlobalFloat("g_fNearPlane", camera.nearClipPlane);
+                    cmd.SetGlobalFloat("g_fFarPlane", camera.farClipPlane);
+                    cmd.SetGlobalFloat("g_iLog2NumClusters", k_Log2NumClusters);
+
+
+                    cmd.SetGlobalFloat("g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
+
+                    cmd.SetGlobalBuffer("g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
+                    if (k_UseDepthBuffer)
+                    {
+                        cmd.SetGlobalBuffer("g_logBaseBuffer", s_PerTileLogBaseTweak);
+                    }
+                }
+
+                cmd.SetGlobalFloat("g_nNumDirLights", numDirLights);
+                cmd.SetGlobalBuffer("g_dirLightData", s_DirLightList);
+                */
-            public void PushGlobalParams(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList)
+            public void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier colorBuffer)
+                /*
+                var bUseClusteredForDeferred = !usingFptl;       // doesn't work on reflections yet but will soon
+                var cmd = new CommandBuffer();
+
+                m_DeferredMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                m_DeferredReflectionMaterial.EnableKeyword(bUseClusteredForDeferred ? "USE_CLUSTERED_LIGHTLIST" : "USE_FPTL_LIGHTLIST");
+                if (enableDrawTileDebug)
+                    m_DeferredMaterial.EnableKeyword("ENABLE_DEBUG");
+                else
+                    m_DeferredMaterial.DisableKeyword("ENABLE_DEBUG");
+
+                cmd.SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
+
+                // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
+                if (bUseClusteredForDeferred)
+                {
+                    cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", 0);
+                }
+
+                cmd.name = "DoTiledDeferredLighting";
+
+                /*
+                if (enableComputeLightEvaluation)  //TODO: temporary workaround for "All kernels must use same constant buffer layouts"
+                {
+                    var w = camera.pixelWidth;
+                    var h = camera.pixelHeight;
+                    var numTilesX = (w + 7) / 8;
+                    var numTilesY = (h + 7) / 8;
+
+                    string kernelName = "ShadeDeferred" + (bUseClusteredForDeferred ? "_Clustered" : "_Fptl") + (enableDrawTileDebug ? "_Debug" : "");
+                    int kernel = deferredComputeShader.FindKernel(kernelName);
+
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraDepthTexture", new RenderTargetIdentifier(s_CameraDepthTexture));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture0", new RenderTargetIdentifier(s_GBufferAlbedo));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture1", new RenderTargetIdentifier(s_GBufferSpecRough));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture2", new RenderTargetIdentifier(s_GBufferNormal));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_CameraGBufferTexture3", new RenderTargetIdentifier(s_GBufferEmission));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_spotCookieTextures", m_CookieTexArray.GetTexCache());
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_pointCookieTextures", m_CubeCookieTexArray.GetTexCache());
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflCubeTextures", m_CubeReflTexArray.GetTexCache());
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_reflRootCubeTexture", ReflectionProbe.GetDefaultTexture());
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "g_tShadowBuffer", new RenderTargetIdentifier(m_shadowBufferID));
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "unity_NHxRoughness", m_NHxRoughnessTexture);
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "_LightTextureB0", m_LightAttentuationTexture);
+
+                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);
+                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLightData", s_LightDataBuffer);
+                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
+
+                    var defdecode = ReflectionProbe.GetDefaultTextureHDRDecodeValues();
+                    cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeMult", defdecode.x);
+                    cmd.SetComputeFloatParam(deferredComputeShader, "_reflRootHdrDecodeExp", defdecode.y);
+
+                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustScale", m_ClustScale);
+                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fClustBase", k_ClustLogBase);
+                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fNearPlane", camera.nearClipPlane);
+                    cmd.SetComputeFloatParam(deferredComputeShader, "g_fFarPlane", camera.farClipPlane);
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_iLog2NumClusters", k_Log2NumClusters);
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_isLogBaseBufferEnabled", k_UseDepthBuffer ? 1 : 0);
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_isOpaquesOnlyEnabled", 0);
+
+
+                    //
+                    var proj = camera.projectionMatrix;
+                    var temp = new Matrix4x4();
+                    temp.SetRow(0, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                    temp.SetRow(1, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                    temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
+                    temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                    var projh = temp * proj;
+                    var invProjh = projh.inverse;
+
+                    temp.SetRow(0, new Vector4(0.5f * w, 0.0f, 0.0f, 0.5f * w));
+                    temp.SetRow(1, new Vector4(0.0f, 0.5f * h, 0.0f, 0.5f * h));
+                    temp.SetRow(2, new Vector4(0.0f, 0.0f, 0.5f, 0.5f));
+                    temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                    var projscr = temp * proj;
+                    var invProjscr = projscr.inverse;
+
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_iNrVisibLights", numLights);
+                    SetMatrixCS(cmd, deferredComputeShader, "g_mScrProjection", projscr);
+                    SetMatrixCS(cmd, deferredComputeShader, "g_mInvScrProjection", invProjscr);
+                    SetMatrixCS(cmd, deferredComputeShader, "g_mViewToWorld", camera.cameraToWorldMatrix);
+
+
+                    if (bUseClusteredForDeferred)
+                    {
+                        cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_vLayeredOffsetsBuffer", s_PerVoxelOffset);
+                        if (k_UseDepthBuffer)
+                        {
+                            cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_logBaseBuffer", s_PerTileLogBaseTweak);
+                        }
+                    }
+
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_widthRT", w);
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_heightRT", h);
+                    cmd.SetComputeIntParam(deferredComputeShader, "g_nNumDirLights", numDirLights);
+                    cmd.SetComputeBufferParam(deferredComputeShader, kernel, "g_dirLightData", s_DirLightList);
+                    cmd.SetComputeTextureParam(deferredComputeShader, kernel, "uavOutput", new RenderTargetIdentifier(s_CameraTarget));
+
+                    SetMatrixArrayCS(cmd, deferredComputeShader, "g_matWorldToShadow", m_MatWorldToShadow);
+                    SetVectorArrayCS(cmd, deferredComputeShader, "g_vDirShadowSplitSpheres", m_DirShadowSplitSpheres);
+                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms0", m_Shadow3X3PCFTerms[0]);
+                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms1", m_Shadow3X3PCFTerms[1]);
+                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms2", m_Shadow3X3PCFTerms[2]);
+                    cmd.SetComputeVectorParam(deferredComputeShader, "g_vShadow3x3PCFTerms3", m_Shadow3X3PCFTerms[3]);
+
+                    cmd.DispatchCompute(deferredComputeShader, kernel, numTilesX, numTilesY, 1);
+                }
+                else
+                {*/
+            //        cmd.Blit(0, colorBuffer, m_DeferredMaterial, 0);
+              //      cmd.Blit(0, colorBuffer, m_DeferredReflectionMaterial, 0);
+                //}
+
+               // renderLoop.ExecuteCommandBuffer(cmd);
+               // cmd.Dispose();
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/LayeredLit/LayeredLit.shader

     #pragma shader_feature _LAYER_MASK_MAP
     #pragma shader_feature _LAYER_MASK_VERTEX_COLOR
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
-    //#pragma shader_feature _ _LAYER_MAPPING_UV1_0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_TRIPLANAR_0
-    //#pragma shader_feature _ _LAYER_MAPPING_UV1_1 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_TRIPLANAR_1
-    //#pragma shader_feature _ _LAYER_MAPPING_UV1_2 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_TRIPLANAR_2
-    //#pragma shader_feature _ _LAYER_MAPPING_UV1_3 _LAYER_MAPPING_PLANAR_3 _LAYER_MAPPING_TRIPLANAR_3
+    #pragma shader_feature _ _LAYER_MAPPING_UV1_0 _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_TRIPLANAR_0
+    #pragma shader_feature _ _LAYER_MAPPING_UV1_1 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_TRIPLANAR_1
+    #pragma shader_feature _ _LAYER_MAPPING_UV1_2 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_TRIPLANAR_2
+    #pragma shader_feature _ _LAYER_MAPPING_UV1_3 _LAYER_MAPPING_PLANAR_3 _LAYER_MAPPING_TRIPLANAR_3
 
     //-------------------------------------------------------------------------------------
     // Define

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Editor/LitUI.cs

 using System;
-using System.Linq;
-    public class BaseLitGUI : ShaderGUI
+    public abstract class BaseLitGUI : ShaderGUI
     {
         protected static class Styles
         {
             alphaCutoff = FindProperty(kAlphaCutoff, props);
             alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
             doubleSidedMode = FindProperty(kDoubleSidedMode, props);
+            FindInputOptionProperties(props);
         }
 
         protected void SetupMaterial(Material material)
             }
 
             SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
+            SetupInputMaterial(material);
         }
 
         protected void SetKeyword(Material m, string keyword, bool state)
             }
         }
 
-        public virtual void FindInputProperties(MaterialProperty[] props) { }
-        protected virtual void ShaderInputGUI() { }
-        protected virtual void ShaderInputOptionsGUI() { }
-
-
         public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
         {
             FindOptionProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
         private const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
         private const string kDoubleSidedMode = "_DoubleSidedMode";
         protected static string[] reservedProperties = new string[] { kSurfaceType, kBlendMode, kAlphaCutoff, kAlphaCutoffEnabled, kDoubleSidedMode };
+
+        protected abstract void FindInputProperties(MaterialProperty[] props);
+        protected abstract void ShaderInputGUI();
+        protected abstract void ShaderInputOptionsGUI();
+        protected abstract void FindInputOptionProperties(MaterialProperty[] props);
+        protected abstract void SetupInputMaterial(Material material);
     }
 
     class LitGUI : BaseLitGUI
         protected const string kDetailHeightScale = "_DetailHeightScale";
         protected const string kDetailAOScale = "_DetailAOScale";
 
-        new public void FindOptionProperties(MaterialProperty[] props)
+        override protected void FindInputOptionProperties(MaterialProperty[] props)
-            base.FindOptionProperties(props);
             UVDetail = FindProperty(kUVDetail, props);
             smoothnessMapChannel = FindProperty(kSmoothnessTextureChannelProp, props);
             emissiveColorMode = FindProperty(kEmissiveColorMode, props);
         }
 
-        override public void FindInputProperties(MaterialProperty[] props)
+        override protected void FindInputProperties(MaterialProperty[] props)
         {
             baseColor = FindProperty("_BaseColor", props);
             baseColorMap = FindProperty("_BaseColorMap", props);
             GUILayout.Label(Styles.detailText, EditorStyles.boldLabel);
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask); 
-			m_MaterialEditor.ShaderProperty(UVDetail, Styles.uvSetLabel.text);          
+            m_MaterialEditor.ShaderProperty(UVDetail, Styles.uvSetLabel.text);          
 
             if (useDetailMapWithNormal)
             {
             }
         }
 
-        new protected void SetupMaterial(Material material)
+        override protected void SetupInputMaterial(Material material)
-            base.SetupMaterial(material);
-
             SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", (NormalMapSpace)material.GetFloat(kNormalMapSpace) == NormalMapSpace.TangentSpace);
             SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", ((SmoothnessMapChannel)material.GetFloat(kSmoothnessTextureChannelProp)) == SmoothnessMapChannel.AlbedoAlpha);
             SetKeyword(material, "_EMISSIVE_COLOR", ((EmissiveColorMode)material.GetFloat(kEmissiveColorMode)) == EmissiveColorMode.UseEmissiveColor);

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.hlsl

 TEXTURE2D(_LtcDisneyDiffuseMatrix);          // RGBA
 TEXTURE2D(_LtcMultiGGXFresnelDisneyDiffuse); // RGB, A unused
 
-
+static const float3x3 _identity3x3 = {1.0, 0.0, 0.0,
+                                      0.0, 1.0, 0.0,
+                                      0.0, 0.0, 1.0};
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
     GetPreIntegratedFGD(iblNdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
 
     // #if SHADERPASS == SHADERPASS_GBUFFER
-    // preLightData.ambientOcclusion = _AmbientOcclusion.Load(uint3(coord.unPositionSS, 0)).x;
+    // preLightData.ambientOcclusion = LOAD_TEXTURE2D(_AmbientOcclusion, uint3(coord.unPositionSS, 0)).x;
     // #endif
 
     // Area light specific
 }
 
 //-----------------------------------------------------------------------------
+// EvaluateBSDF_Line - Reference
+//-----------------------------------------------------------------------------
+
+void IntegrateBSDF_LineRef(float3 V, float3 positionWS,
+                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                           out float3 diffuseLighting, out float3 specularLighting,
+                           int sampleCount = 128)
+{
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    const float  len = lightData.size.x;
+    const float3 T   = lightData.right;
+    const float3 P1  = lightData.positionWS - T * (0.5 * len);
+    const float  dt  = len * rcp(sampleCount);
+    const float  off = 0.5 * dt;
+
+    // Uniformly sample the line segment with the Pdf = 1 / len.
+    const float invPdf = len;
+
+    for (int i = 0; i < sampleCount; ++i)
+    {
+        // Place the sample in the middle of the interval.
+        float  t     = off + i * dt;
+        float3 sPos  = P1 + t * T;
+        float3 unL   = sPos - positionWS;
+        float  dist2 = dot(unL, unL);
+        float3 L     = normalize(unL);
+        float  sinLT = length(cross(L, T));
+        float  NdotL = saturate(dot(bsdfData.normalWS, L));
+
+        float3 lightDiff, lightSpec;
+
+        BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
+
+        // The value of the specular BSDF could be infinite.
+        // Summing up infinities leads to NaNs.
+        lightSpec = min(lightSpec, FLT_MAX);
+
+        diffuseLighting  += lightDiff * (sinLT / dist2 * NdotL);
+        specularLighting += lightSpec * (sinLT / dist2 * NdotL);
+    }
+
+    // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
+    float normFactor = 2.0 * invPdf * rcp(sampleCount);
+
+    diffuseLighting  *= normFactor * lightData.diffuseScale  * lightData.color;
+    specularLighting *= normFactor * lightData.specularScale * lightData.color;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Line - Approximation with Linearly Transformed Cosines
+//-----------------------------------------------------------------------------
+
+void EvaluateBSDF_Line(LightLoopContext lightLoopContext,
+                       float3 V, float3 positionWS,
+                       PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                       out float3 diffuseLighting, out float3 specularLighting)
+{
+#ifdef LIT_DISPLAY_REFERENCE_AREA
+    IntegrateBSDF_LineRef(V, positionWS, preLightData, lightData, bsdfData,
+                          diffuseLighting, specularLighting);
+#else
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    float  len = lightData.size.x;
+    float3 T   = lightData.right;
+
+    float3 unL = positionWS - lightData.positionWS;
+
+    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
+    float3 axis = lightData.right;
+
+    // We define the ellipsoid s.t. r1 = r, r2 = (r + len / 2).
+    // TODO: This could be precomputed.
+    float radius         = rsqrt(lightData.invSqrAttenuationRadius);
+    float invAspectRatio = radius / (radius + (0.5 * len));
+
+    // Compute the light attenuation.
+    float intensity = GetEllipsoidalDistanceAttenuation(unL,  lightData.invSqrAttenuationRadius,
+                                                        axis, invAspectRatio);
+
+    // Terminate if the shaded point is too far away.
+    if (intensity == 0.0) return;
+
+    lightData.diffuseScale  *= intensity;
+    lightData.specularScale *= intensity;
+
+    // TODO: This could be precomputed.
+    float3 P1 = lightData.positionWS - T * (0.5 * len);
+    float3 P2 = lightData.positionWS + T * (0.5 * len);
+
+    // Translate the endpoints s.t. the shaded point is at the origin of the coordinate system.
+    P1 -= positionWS;
+    P2 -= positionWS;
+
+    // Construct an orthonormal basis (local coordinate system) around N.
+    // TODO: it could be stored in PreLightData. All LTC lights compute it more than once!
+    // Also consider using 'bsdfData.tangentWS', 'bsdfData.bitangentWS', 'bsdfData.normalWS'.
+    float3x3 basis;
+    basis[0] = normalize(V - bsdfData.normalWS * preLightData.NdotV);
+    basis[1] = normalize(cross(bsdfData.normalWS, basis[0]));
+    basis[2] = bsdfData.normalWS;
+
+    // Rotate the endpoints into the local coordinate system (left-handed).
+    P1 = mul(P1, transpose(basis));
+    P2 = mul(P2, transpose(basis));
+
+    // Compute the binormal.
+    float3 B = normalize(cross(P2 - P1, P1));
+
+    float ltcValue;
+
+    // Evaluate the diffuse part.
+    {
+    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
+        ltcValue = LTCEvaluate(P1, P2, B, _identity3x3);
+    #else
+        ltcValue = LTCEvaluate(P1, P2, B, preLightData.ltcXformDisneyDiffuse);
+    #endif
+
+        if (ltcValue == 0.0)
+        {
+            // The light is below the horizon.
+            return;
+        }
+
+    #ifndef LIT_DIFFUSE_LAMBERT_BRDF
+        ltcValue *= preLightData.ltcDisneyDiffuseMagnitude;
+    #endif
+
+        ltcValue *= lightData.diffuseScale;
+        diffuseLighting = bsdfData.diffuseColor * lightData.color * ltcValue;
+    }
+
+    // Evaluate the specular part.
+    {
+        // TODO: the fit seems rather poor. The scaling factor of 0.5 allows us
+        // to match the reference for rough metals, but further darkens dielectrics.
+        float3 fresnelTerm = bsdfData.fresnel0 * preLightData.ltcGGXFresnelMagnitudeDiff
+                           + (float3)preLightData.ltcGGXFresnelMagnitude;
+
+        ltcValue  = LTCEvaluate(P1, P2, B, preLightData.ltcXformGGX);
+        ltcValue *= lightData.specularScale;
+        specularLighting = fresnelTerm * lightData.color * ltcValue;
+    }
+#endif
+}
+
+//-----------------------------------------------------------------------------
-void IntegrateGGXAreaRef(   float3 V, float3 positionWS, PreLightData preLightData, LightData lightData, BSDFData bsdfData,
-                            out float3 diffuseLighting,
-                            out float3 specularLighting,
-                            uint sampleCount = 512)
+void IntegrateBSDF_AreaRef(float3 V, float3 positionWS,
+                           PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                           out float3 diffuseLighting, out float3 specularLighting,
+                           uint sampleCount = 512)
 {
     // Add some jittering on Hammersley2d
     float2 randNum = InitRandom(V.xy * 0.5 + 0.5);
 
     for (uint i = 0; i < sampleCount; ++i)
     {
-        float3 P = float3(0.0, 0.0, 0.0);	// Sample light point. Random point on the light shape in local space.
-        float3 Ns = float3(0.0, 0.0, 0.0);	// Unit surface normal at P
-        float lightPdf = 0.0;	            // Pdf of the light sample
+        float3 P = float3(0.0, 0.0, 0.0);   // Sample light point. Random point on the light shape in local space.
+        float3 Ns = float3(0.0, 0.0, 0.0);  // Unit surface normal at P
+        float lightPdf = 0.0;               // Pdf of the light sample
 
         float2 u = Hammersley2d(i, sampleCount);
         u = frac(u + randNum + 0.5);
 }
 
 //-----------------------------------------------------------------------------
-// EvaluateBSDFLine - Reference
+// EvaluateBSDF_Area - Approximation with Linearly Transformed Cosines
-void IntegrateBSDFLineRef(float3 V, float3 positionWS, PreLightData preLightData,
-                          LightData lightData, BSDFData bsdfData,
-                          out float3 diffuseLighting, out float3 specularLighting,
-                          int sampleCount = 128)
+void EvaluateBSDF_Area(LightLoopContext lightLoopContext,
+                       float3 V, float3 positionWS,
+                       PreLightData preLightData, LightData lightData, BSDFData bsdfData,
+                       out float3 diffuseLighting, out float3 specularLighting)
+#ifdef LIT_DISPLAY_REFERENCE_AREA
+    IntegrateBSDF_AreaRef(V, positionWS, preLightData, lightData, bsdfData,
+                          diffuseLighting, specularLighting);
+#else    
-    const float  len = lightData.size.x;
-    const float3 dir = lightData.right;
-    const float3 p1  = lightData.positionWS - lightData.right * (0.5 * len);
-    const float  dt  = len * rcp(sampleCount);
-    const float  off = 0.5 * dt;
+    // TODO: This could be precomputed.
+    float halfWidth  = lightData.size.x * 0.5;
+    float halfHeight = lightData.size.y * 0.5;
-    // Uniformly sample the line segment with the Pdf = 1 / len.
-    const float invPdf = len;
+    float3 unL = positionWS - lightData.positionWS;
-    for (int i = 0; i < sampleCount; ++i)
-    {
-        // Place the sample in the middle of the interval.
-        float  t     = off + i * dt;
-        float3 sPos  = p1 + t * dir;
-        float3 unL   = sPos - positionWS;
-        float  dist2 = dot(unL, unL);
-        float3 L     = normalize(unL);
-        float  sinLD = length(cross(L, dir));
-        float  NdotL = saturate(dot(bsdfData.normalWS, L));
+    // Pick the axis along which to expand the fade-out sphere into an ellipsoid.
+    float3 axis = (halfWidth >= halfHeight) ? lightData.right : lightData.up;
-        float3 lightDiff, lightSpec;
-
-        BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
-
-        diffuseLighting  += lightDiff * (sinLD / dist2 * NdotL);
-        specularLighting += lightSpec * (sinLD / dist2 * NdotL);
-    }
-
-    // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
-    float normFactor = 2.0 * invPdf * rcp(sampleCount);
-
-    diffuseLighting  *= normFactor * lightData.diffuseScale  * lightData.color;
-    specularLighting *= normFactor * lightData.specularScale * lightData.color;
-}
-
-//-----------------------------------------------------------------------------
-// EvaluateBSDF_Line | Approximation with Linearly Transformed Cosines
-//-----------------------------------------------------------------------------
+    // We define the ellipsoid s.t. r1 = r, r2 = (r + |w - h| / 2).
+    // TODO: This could be precomputed.
+    float radius         = rsqrt(lightData.invSqrAttenuationRadius);
+    float invAspectRatio = radius / (radius + abs(halfWidth - halfHeight));
-void EvaluateBSDF_Line( LightLoopContext lightLoopContext,
-                        float3 V, float3 positionWS, PreLightData preLightData,
-                        LightData lightData, BSDFData bsdfData,
-                        out float3 diffuseLighting, out float3 specularLighting)
-{
-    diffuseLighting  = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
-
-    float  len = lightData.size.x;
-    float3 dir = lightData.right;
-
-    // TODO: precompute half-length. Same as for LTC area lights.
-    // In fact, why not store both endpoints? Saves us 7 cycles.
-    float3 p1 = lightData.positionWS - lightData.right * (0.5 * len);
-    float3 p2 = lightData.positionWS + lightData.right * (0.5 * len);
-
-    // Translate both points s.t. the shaded point is at the origin of the coordinate system.
-    p1 -= positionWS;
-    p2 -= positionWS;
-
-    // Construct an orthonormal basis (local coordinate system) around N.
-    // TODO: it could be stored in PreLightData. All LTC lights compute it more than once!
-    float3x3 basis;
-    basis[0] = normalize(V - bsdfData.normalWS * preLightData.NdotV);
-    basis[1] = normalize(cross(bsdfData.normalWS, basis[0]));
-    basis[2] = bsdfData.normalWS;
-
-    // Transform (rotate) both endpoints into the local coordinate system (left-handed).
-    p1 = mul(p1, transpose(basis));
-    p2 = mul(p2, transpose(basis));
-
-    // Terminate the algorithm if both points are below the horizon.
-    if (p1.z <= 0.0 && p2.z <= 0.0) return;
-
-    if (p2.z <= 0.0)
-    {
-        // Convention: 'p2' is above the horizon.
-        swap(p1, p2);
-        dir = -dir;
-    }
-
-    // Clip the part of the light below the horizon.
-    if (p1.z <= 0.0)
-    {
-        // p = p1 + t * dir; p.z == 0.
-        float t = -p1.z / dir.z;
-        p1 = float3(p1.xy + t * dir.xy, 0.0);
-
-        // Set the length of the visible part of the light.
-        len -= t;
-    }
-
-    // Compute the direction to the point on the line orthogonal to 'dir'.
-    // Its length is the shortest distance to the line.
-    float3 p0   = p1 - dot(p1, dir) * dir;
-    float  dist = length(p0);
-
-    // Compute the parameterization: distances from 'l1' and 'l2' to 'l0'.
-    float l1 = dot(p1 - p0, dir);
-    float l2 = l1 + len;
-
-    // Integrate the clamped cosine over the line segment.
-    float irradiance = LineIrradiance(l1, l2, dist, p0.z, dir.z);
-
-    // Only Lambertian for now. TODO: Disney Diffuse and GGX.
-    diffuseLighting = (lightData.diffuseScale * irradiance * INV_PI) * bsdfData.diffuseColor * lightData.color;
-}
+    // Compute the light attenuation.
+    float intensity = GetEllipsoidalDistanceAttenuation(unL,  lightData.invSqrAttenuationRadius,
+                                                        axis, invAspectRatio);
-//-----------------------------------------------------------------------------
-// EvaluateBSDF_Area | Approximation with Linearly Transformed Cosines
-//-----------------------------------------------------------------------------
+    // Terminate if the shaded point is too far away.
+    if (intensity == 0.0) return;
-void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
-                        float3 V, float3 positionWS, PreLightData preLightData, LightData lightData, BSDFData bsdfData,
-                        out float3 diffuseLighting,
-                        out float3 specularLighting)
-{
-#ifdef LIT_DISPLAY_REFERENCE_AREA
-    if (lightData.lightType == GPULIGHTTYPE_LINE)
-    {
-        IntegrateBSDFLineRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
-    }
-    else
-    {
-        IntegrateGGXAreaRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
-    }
-#else
-    if (lightData.lightType == GPULIGHTTYPE_LINE)
-    {
-        diffuseLighting = float3(0.0, 0.0, 0.0);
-        specularLighting = float3(0.0, 0.0, 0.0);
-        // EvaluateBSDF_Line(lightLoopContext, V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
-        return;
-    }
-    
-    // TODO: This could be precomputed
-    float halfWidth  = lightData.size.x * 0.5;
-    float halfHeight = lightData.size.y * 0.5;
+    lightData.diffuseScale  *= intensity;
+    lightData.specularScale *= intensity;
-    // TODO: store 4 points and save 24 cycles.
+    // TODO: store 4 points and save 12 cycles (24x MADs - 12x MOVs).
-    float4x3 matL = float4x3(p0, p1, p2, p3);
-    float4x3 L    = matL - float4x3(positionWS, positionWS, positionWS, positionWS);
-
-    diffuseLighting  = float3(0.0, 0.0, 0.0);
-    specularLighting = float3(0.0, 0.0, 0.0);
-
-    // Pick the correct axis along which to expand the fade-out sphere into an ellipsoid.
-    float3 axisLS;
-    float  minDim, maxDim;
-
-    // The compiler should generate conditional MOVs.
-    if (halfWidth >= halfHeight)
-    {
-        axisLS = lightData.right;
-        minDim = halfHeight;
-        maxDim = halfWidth;
-    }
-    else
-    {
-        axisLS = lightData.up;
-        minDim = halfWidth;
-        maxDim = halfHeight;
-    }
-
-    float3 dirLS          = positionWS - lightData.positionWS;
-    float  lightSpaceProj = dot(dirLS, axisLS);
-    float  invAspectRatio = minDim / maxDim;
-
-    // We want 'dirLS' to shrink along 'axisLS' by the aspect ratio. Therefore,
-    // we compute the difference between the original length and the shrunk one.
-    // This is equivalent to the expansion of the fade-out sphere into an ellipsoid.
-    float scaleLS = lightSpaceProj - lightSpaceProj * invAspectRatio;
-    dirLS -= scaleLS * axisLS;
-
-    // Compute the light attenuation.
-    float sqDist    = dot(dirLS, dirLS);
-    float intensity = SmoothDistanceAttenuation(sqDist, lightData.invSqrAttenuationRadius);
-
-    // Return the black color if the shaded point is too far away.
-    if (intensity == 0.0) return;
-
-    lightData.diffuseScale  *= intensity;
-    lightData.specularScale *= intensity;
+    float4x3 matL = float4x3(p0, p1, p2, p3) - float4x3(positionWS, positionWS, positionWS, positionWS);
-    #ifdef DIFFUSE_LAMBERT_BRDF
-        static const float3x3 identity3x3 = {1.0, 0.0, 0.0,
-                                             0.0, 1.0, 0.0,
-                                             0.0, 0.0, 1.0};
-                                             
-        ltcValue = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
-                               identity3x3);
+    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
+        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+                               _identity3x3);
-        ltcValue = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+        ltcValue = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
                                preLightData.ltcXformDisneyDiffuse);
     #endif
 
             return;
         }
 
-    #ifndef DIFFUSE_LAMBERT_BRDF
+    #ifndef LIT_DIFFUSE_LAMBERT_BRDF
         ltcValue *= preLightData.ltcDisneyDiffuseMagnitude;
     #endif
 
 
     // Evaluate the specular part.
     {
+        // TODO: the fit seems rather poor. The scaling factor of 0.5 allows us
+        // to match the reference for rough metals, but further darkens dielectrics.
-        ltcValue  = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+        ltcValue  = LTCEvaluate(matL, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
                                 preLightData.ltcXformGGX);
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/Resources/SkyHDRI.shader

         Pass
         {
             ZWrite Off
-            Blend SrcAlpha OneMinusSrcAlpha // We will lerp only the values that are valid
+            ZTest LEqual
+            Blend One Zero
 
             HLSLPROGRAM
             #pragma target 5.0
                 // TODO: implement SV_vertexID full screen quad
                 Varyings output;
                 output.positionCS = float4(input.positionCS.xy, UNITY_RAW_FAR_CLIP_VALUE
-                    #if UNITY_REVERSED_Z
-                    + 0.000001
-                    #else
-                    - 0.000001
-                    #endif
                     , 1.0);
                 output.eyeVector = input.eyeVector;
 
                 float3 dir = normalize(input.eyeVector);
 
                 // Rotate direction
-                float phi = _SkyParam.z * PI / 180.0; // Convert to radiant
+                float phi = DegToRad(_SkyParam.z);
-                sincos(phi, cosPhi, sinPhi);
-                float3 rotDirX = float3(cosPhi, 0, sinPhi);
-                float3 rotDirY = float3(sinPhi, 0, -cosPhi);                
+                sincos(phi, sinPhi, cosPhi);
+                float3 rotDirX = float3(cosPhi, 0, -sinPhi);
+                float3 rotDirY = float3(sinPhi, 0, cosPhi);
                 dir = float3(dot(rotDirX, dir), dir.y, dot(rotDirY, dir));
 
                 return ClampToFloat16Max(SAMPLE_TEXTURECUBE_LOD(_Cubemap, sampler_Cubemap, dir, 0) * exp2(_SkyParam.x) * _SkyParam.y);

Assets/ScriptableRenderLoop/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLER2D_FLOAT SAMPLER2D
 
 #define LOAD_TEXTURE2D(textureName, unCoord3) textureName.Load(unCoord3)
+#define LOAD_TEXTURE2D_MSAA(textureName, unCoord3, sampleIndex) textureName.Load(unCoord3, sampleIndex)
+

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

     return twoSided ? abs(sum) : max(sum, 0.0);
 }
 
-float LTCEvaluate(float4x3 L, float3 V, float3 N, float NdotV, bool twoSided, float3x3 minV)
+// For polygonal lights.
+float LTCEvaluate(float4x3 L, float3 V, float3 N, float NdotV, bool twoSided, float3x3 invM)
+    // Also consider using 'bsdfData.tangentWS', 'bsdfData.bitangentWS', 'bsdfData.normalWS'.
     float3x3 basis;
     basis[0] = normalize(V - N * NdotV);
     basis[1] = normalize(cross(N, basis[0]));
-    minV = mul(transpose(basis), minV);
-    L = mul(L, minV);
+    invM = mul(transpose(basis), invM);
+    L = mul(L, invM);
-float LineFpo(float rcpD, float rcpDL, float l)
+float LineFpo(float tLDDL, float lrcpD, float rcpD)
-    // Compute: l / d / (d * d + l * l) + 1.0 / (d * d) * atan(l / d).
-    return l * rcpDL + rcpD * rcpD * atan(l * rcpD);
+    // Compute: ((l / d) / (d * d + l * l)) + (1.0 / (d * d)) * atan(l / d).
+    return tLDDL + sq(rcpD) * atan(lrcpD);
-float LineFwt(float sqL, float rcpDL)
+float LineFwt(float tLDDL, float l)
-    // Compute: l * l / d / (d * d + l * l).
-    return sqL * rcpDL;
+    // Compute: l * ((l / d) / (d * d + l * l)).
+    return l * tLDDL;
-// 'dist' is the shortest distance to the line. 'l1' and 'l2' define the integration interval.
-float LineIrradiance(float l1, float l2, float dist, float pointZ, float tangentZ)
+// 'l1' and 'l2' define the integration interval.
+// 'tangent' is the line's tangent direction.
+// 'normal' is the direction orthogonal to the tangent. It is the shortest vector between
+// the shaded point and the line, pointing away from the shaded point.
+float LineIrradiance(float l1, float l2, float3 normal, float3 tangent)
-    float sqD    = dist * dist;
-    float sqL1   = l1 * l1;
-    float sqL2   = l2 * l2;
-    float rcpD   = rcp(dist);
-    float rcpDL1 = rcpD * rcp(sqD + sqL1);
-    float rcpDL2 = rcpD * rcp(sqD + sqL2);
-    float intP0  = LineFpo(rcpD, rcpDL2, l2) - LineFpo(rcpD, rcpDL1, l1);
-    float intWt  = LineFwt(sqL2, rcpDL2) - LineFwt(sqL1, rcpDL1);
-    return intP0 * pointZ + intWt * tangentZ;
+    float d      = length(normal);
+    float l1rcpD = l1 * rcp(d);
+    float l2rcpD = l2 * rcp(d);
+    float tLDDL1 = l1rcpD * rcp(sq(d) + sq(l1));
+    float tLDDL2 = l2rcpD * rcp(sq(d) + sq(l2));
+    float intWt  = LineFwt(tLDDL2, l2) - LineFwt(tLDDL1, l1);
+    float intP0  = LineFpo(tLDDL2, l2rcpD, rcp(d)) - LineFpo(tLDDL1, l1rcpD, rcp(d));
+    return intP0 * normal.z + intWt * tangent.z;
+}
+
+// For line lights.
+float LTCEvaluate(float3 P1, float3 P2, float3 B, float3x3 invM)
+{
+    // Inverse-transform the endpoints and the binormal.
+    P1 = mul(P1, invM);
+    P2 = mul(P2, invM);
+    B  = mul(B,  invM);
+
+    // Terminate the algorithm if both points are below the horizon.
+    if (P1.z <= 0.0 && P2.z <= 0.0) return 0.0;
+
+    if (P2.z <= 0.0)
+    {
+        // Convention: 'P2' is above the horizon.
+        swap(P1, P2);
+    }
+
+    // Recompute the length and the tangent in the new coordinate system.
+    float  len = length(P2 - P1);
+    float3 T   = normalize(P2 - P1);
+
+    // Clip the part of the light below the horizon.
+    if (P1.z <= 0.0)
+    {
+        // P = P1 + t * T; P.z == 0.
+        float t = -P1.z / T.z;
+        P1 = float3(P1.xy + t * T.xy, 0.0);
+
+        // Set the length of the visible part of the light.
+        len -= t;
+    }
+
+    // Compute the normal direction to the line, s.t. it is the shortest vector
+    // between the shaded point and the line, pointing away from the shaded point.
+    // Can be interpreted as a point on the line, since the shaded point is at the origin.
+    float  proj = dot(P1, T);
+    float3 P0   = P1 - proj * T;
+
+    // Compute the parameterization: distances from 'P1' and 'P2' to 'P0'.
+    float l1 = proj;
+    float l2 = l1 + len;
+
+    // Integrate the clamped cosine over the line segment.
+    float irradiance = LineIrradiance(l1, l2, P0, T);
+
+    // Compute the width factor. We take the absolute value because the points may be swapped.
+    float width = abs(dot(B, normalize(cross(T, P1))));
+
+    // Guard against numerical precision issues.
+    return max(INV_PI * width * irradiance, 0.0);
 }
 
 #endif // UNITY_AREA_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

 }
 #endif // INTRINSIC_MINMAX3
 
+float sq(float x)
+{
+    return x * x;
+}
+
 void swap(inout float a, inout float b)
 {
     float  t = a; a = b; b = t;
 #define HALF_PI     1.57079632679
 #define INV_HALF_PI 0.636619772367
 
-#define FLT_EPSILON     1.192092896e-07f // smallest such that 1.0 + FLT_EPSILON != 1.0
+#define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
+#define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
+
+float DegToRad(float deg)
+{
+    return deg * PI / 180.0;
+}
+
+float RadToDeg(float rad)
+{
+    return rad * 180.0 / PI;
+}
 
 // Acos in 14 cycles.
 // Ref: https://seblagarde.wordpress.com/2014/12/01/inverse-trigonometric-functions-gpu-optimization-for-amd-gcn-architecture/

Assets/ScriptableRenderLoop/ShaderLibrary/CommonLighting.hlsl

     return attenuation;
 }
 
+// Applies SmoothDistanceAttenuation() after stretching the fade-out sphere of the given radius
+// into an ellipsoid with the specified aspect ratio and the longest axis.
+float GetEllipsoidalDistanceAttenuation(float3 unL,  float invSqrAttenuationRadius,
+                                        float3 axis, float invAspectRatio)
+{
+    // Project the unnormalized light vector onto the expansion axis.
+    float projL = dot(unL, axis);
+
+    // We want 'unL' to shrink along 'axis' by the aspect ratio. Therefore, we compute
+    // the difference between the length of the original projection and the shrunk one.
+    // It is equivalent to the expansion of the fade-out sphere into an ellipsoid.
+    float scale = projL - projL * invAspectRatio;
+    unL -= scale * axis;
+
+    return SmoothDistanceAttenuation(dot(unL, unL), invSqrAttenuationRadius);
+}
+
 //-----------------------------------------------------------------------------
 // IES Helper
 //-----------------------------------------------------------------------------

Assets/TestScenes/HDTest/GlobalIlluminationTest.unity

   m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
   m_AmbientIntensity: 1
   m_AmbientMode: 0
-  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_SkyboxMaterial: {fileID: 0}
   m_HaloStrength: 0.5
   m_FlareStrength: 1
   m_FlareFadeSpeed: 3
-  m_DefaultReflectionResolution: 128
+  m_DefaultReflectionResolution: 1024
-  m_IndirectSpecularColor: {r: 0.11480248, g: 0.11976801, b: 0.105756685, a: 1}
+  m_IndirectSpecularColor: {r: 0.5456174, g: 0.39782104, b: 0.24038851, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_AlbedoBoost: 1
     m_TemporalCoherenceThreshold: 1
     m_EnvironmentLightingMode: 0
-    m_EnableBakedLightmaps: 1
+    m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 1
   m_LightmapEditorSettings:
     serializedVersion: 4
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &20738782
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &32562345
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &439514138
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &841702837
 BoxCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &877242193
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &931864777
 BoxCollider:
   - {fileID: 931864775}
   - {fileID: 190482350}
   - {fileID: 1232831964}
+  - {fileID: 1543726726}
   m_Father: {fileID: 0}
   m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_Component:
   - component: {fileID: 1108908832}
   - component: {fileID: 1108908833}
+  - component: {fileID: 1108908834}
   m_Layer: 0
   m_Name: Spotlight
   m_TagString: Untagged
   m_BounceIntensity: 1
   m_ShadowRadius: 0
   m_ShadowAngle: 0
+--- !u!114 &1108908834
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1108908831}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  shadowResolution: 512
+  shadowDimmer: 1
+  affectDiffuse: 1
+  affectSpecular: 1
+  treatAsAreaLight: 0
+  isDoubleSided: 0
+  areaLightLength: 0
+  areaLightWidth: 0
 --- !u!1 &1197900219
 GameObject:
   m_ObjectHideFlags: 0
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!64 &1197900222
 MeshCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1232831966
 SphereCollider:
   - {fileID: 1845946151}
   - {fileID: 1910068097}
   - {fileID: 1686135373}
+  - {fileID: 1736468425}
   m_Father: {fileID: 0}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1315831391
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1330031311
 BoxCollider:
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1330031308}
   m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1543726725
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1543726726}
+  - component: {fileID: 1543726729}
+  - component: {fileID: 1543726728}
+  - component: {fileID: 1543726727}
+  m_Layer: 0
+  m_Name: Sphere_Skybox
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1543726726
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1543726725}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -6.33, y: 0.428, z: -5.0499997}
+  m_LocalScale: {x: 1.6119599, y: 1.6119599, z: 1.6119599}
+  m_Children: []
+  m_Father: {fileID: 1027688891}
+  m_RootOrder: 10
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1543726727
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1543726725}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 0
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 6abcdf01974b58c45af2b04a9c0fdd13, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &1543726728
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1543726725}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1543726729
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1543726725}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1617519335
 GameObject:
   m_ObjectHideFlags: 0
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1617519338
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1664670956
 SphereCollider:
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!135 &1686135375
 SphereCollider:
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1686135372}
   m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1736468424
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1736468425}
+  - component: {fileID: 1736468428}
+  - component: {fileID: 1736468427}
+  - component: {fileID: 1736468426}
+  m_Layer: 0
+  m_Name: Sphere_Skybox
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1736468425
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1736468424}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: -5.815, y: 0.47800002, z: 0.013999939}
+  m_LocalScale: {x: 1.6119577, y: 1.6119568, z: 1.6119568}
+  m_Children: []
+  m_Father: {fileID: 1271727142}
+  m_RootOrder: 10
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &1736468426
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1736468424}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 0
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 1971c044ea2fd954382f35c444500b9d, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!135 &1736468427
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1736468424}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1736468428
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1736468424}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
 --- !u!1 &1845946150
 GameObject:
   m_ObjectHideFlags: 0
   m_AutoUVMaxAngle: 89
   m_LightmapParameters: {fileID: 0}
   m_SortingLayerID: 0
+  m_SortingLayer: 0
   m_SortingOrder: 0
 --- !u!65 &1845946153
 BoxCollider:

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

   m_CustomRenderQueue: -1
   stringTagMap: {}
   m_SavedProperties:
-    serializedVersion: 2
+    serializedVersion: 3
-    - first:
-        name: _AmbientOcclusionMap
-      second:
+    - _AmbientOcclusionMap:
-    - first:
-        name: _BaseColorMap
-      second:
+    - _AnisotropyMap:
-    - first:
-        name: _BumpMap
-      second:
+    - _BaseColorMap:
-    - first:
-        name: _DetailAlbedoMap
-      second:
+    - _BumpMap:
-    - first:
-        name: _DetailMask
-      second:
+    - _DetailAlbedoMap:
-    - first:
-        name: _DetailNormalMap
-      second:
+    - _DetailMask:
-    - first:
-        name: _DiffuseLightingMap
-      second:
+    - _DetailNormalMap:
-    - first:
-        name: _EmissionMap
-      second:
+    - _DiffuseLightingMap:
-    - first:
-        name: _EmissiveColorMap
-      second:
+    - _EmissionMap:
-    - first:
-        name: _HeightMap
-      second:
+    - _EmissiveColorMap:
-    - first:
-        name: _MainTex
-      second:
+    - _HeightMap:
-    - first:
-        name: _MaskMap
-      second:
+    - _MainTex:
-    - first:
-        name: _MetallicGlossMap
-      second:
+    - _MaskMap:
-    - first:
-        name: _MettalicMap
-      second:
+    - _MetallicGlossMap:
-    - first:
-        name: _NormalMap
-      second:
+    - _MettalicMap:
-    - first:
-        name: _OcclusionMap
-      second:
+    - _NormalMap:
+        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:
-    - first:
-        name: _ParallaxMap
-      second:
+    - _SmoothnessMap:
-    - first:
-        name: _SmoothnessMap
-      second:
+    - _SpecularOcclusionMap:
-    - first:
-        name: _SpecularOcclusionMap
-      second:
+    - _SubSurfaceRadiusMap:
-    - first:
-        name: _SubSurfaceRadiusMap
-      second:
+    - _TangentMap:
-    - first:
-        name: _AlphaCutoff
-      second: 0.5
-    - first:
-        name: _AlphaCutoffEnable
-      second: 0
-    - first:
-        name: _BlendMode
-      second: 0
-    - first:
-        name: _BumpScale
-      second: 1
-    - first:
-        name: _CullMode
-      second: 2
-    - first:
-        name: _Cutoff
-      second: 0.5
-    - first:
-        name: _DetailNormalMapScale
-      second: 1
-    - first:
-        name: _DistortionDepthTest
-      second: 0
-    - first:
-        name: _DistortionOnly
-      second: 0
-    - first:
-        name: _DoubleSided
-      second: 1
-    - first:
-        name: _DoubleSidedLigthing
-      second: 1
-    - first:
-        name: _DoubleSidedMode
-      second: 0
-    - first:
-        name: _DstBlend
-      second: 0
-    - first:
-        name: _EmissiveColorMode
-      second: 1
-    - first:
-        name: _EmissiveIntensity
-      second: 0
-    - first:
-        name: _GlossMapScale
-      second: 1
-    - first:
-        name: _Glossiness
-      second: 0.5
-    - first:
-        name: _GlossyReflections
-      second: 1
-    - first:
-        name: _HeightBias
-      second: 0
-    - first:
-        name: _HeightMapMode
-      second: 0
-    - first:
-        name: _HeightScale
-      second: 1
-    - first:
-        name: _MaterialID
-      second: 0
-    - first:
-        name: _MaterialId
-      second: 0
-    - first:
-        name: _Metalic
-      second: 0
-    - first:
-        name: _Metallic
-      second: 0
-    - first:
-        name: _Mettalic
-      second: 0
-    - first:
-        name: _Mode
-      second: 0
-    - first:
-        name: _NormalMapSpace
-      second: 0
-    - first:
-        name: _OcclusionStrength
-      second: 1
-    - first:
-        name: _Parallax
-      second: 0.02
-    - first:
-        name: _Smoothness
-      second: 0.5
-    - first:
-        name: _SmoothnessTextureChannel
-      second: 0
-    - first:
-        name: _SpecularHighlights
-      second: 1
-    - first:
-        name: _SrcBlend
-      second: 1
-    - first:
-        name: _SubSurfaceRadius
-      second: 0
-    - first:
-        name: _SurfaceType
-      second: 0
-    - first:
-        name: _UVSec
-      second: 0
-    - first:
-        name: _ZWrite
-      second: 1
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.5
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVSec: 0
+    - _ZWrite: 1
-    - first:
-        name: _BaseColor
-      second: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
-    - first:
-        name: _Color
-      second: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
-    - first:
-        name: _EmissionColor
-      second: {r: 0, g: 0, b: 0, a: 1}
-    - first:
-        name: _EmissiveColor
-      second: {r: 0, g: 0, b: 0, a: 1}
+    - _BaseColor: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Layered/Layered.mat

   m_Shader: {fileID: 4800000, guid: 81d02e8644315b742b154842a3a2f98c, type: 3}
   m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DISTORTIONDEPTHTEST_OFF _DISTORTIONONLY_OFF
     _EMISSION _LAYEREDLIT_4_LAYER _LAYEREDLIT_4_LAYERS _LAYERMASKMAP _LAYER_MAPPING_PLANAR0
-    _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_UV1_2 _LAYER_MASK_VERTEX_COLOR
-    _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
+    _LAYER_MAPPING_PLANAR_0 _LAYER_MAPPING_PLANAR_1 _LAYER_MAPPING_PLANAR_2 _LAYER_MAPPING_PLANAR_3
+    _LAYER_MASK_VERTEX_COLOR _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE
   m_LightmapFlags: 1
   m_CustomRenderQueue: -1
   stringTagMap: {}
     - _LayerCount: 4
     - _LayerMapping0: 2
     - _LayerMapping1: 2
-    - _LayerMapping2: 1
-    - _LayerMapping3: 0
+    - _LayerMapping2: 2
+    - _LayerMapping3: 2
-    - _LayerSize2: 1
-    - _LayerSize3: 1
+    - _LayerSize2: 2
+    - _LayerSize3: 2
     - _LayerTiling0: 10
     - _LayerTiling1: 10
     - _LayerTiling2: 1

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/Layered/Layered.mat.meta

 fileFormatVersion: 2
 guid: 6e7fa39a7d1b15c4184c9f51d86eba22
-timeCreated: 1479298680
+timeCreated: 1479379836
 licenseType: Pro
 NativeFormatImporter:
   userData: '{"GUIDArray":["01fa3be727161d249a81ad7065c15459","3acf8f156d29e494e8cd196462d1a17c","62b3c923bc540b94a803550e9927936a","c569253e641dc934db7c3595b31890da"]}'

ProjectSettings/ProjectSettings.asset

   - m_BuildTarget: WindowsStandaloneSupport
     m_APIs: 0200000001000000
     m_Automatic: 1
+  - m_BuildTarget: MacStandaloneSupport
+    m_APIs: 11000000
+    m_Automatic: 0
   m_BuildTargetVRSettings:
   - m_BuildTarget: Android
     m_Enabled: 0

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl

+// uses the optimized single layered light list for opaques only
+
+#ifdef USE_FPTL_LIGHTLIST
+#define OPAQUES_ONLY
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl.meta

+fileFormatVersion: 2
+guid: bb7311b8d11d7ef42971ee6bed87ecb4
+timeCreated: 1479752859
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl

+//-----------------------------------------------------------------------------
+// LightLoop
+// ----------------------------------------------------------------------------
+
+// bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
+void LightLoop(float3 V, float3 positionWS, PreLightData prelightData, BSDFData bsdfData, float3 bakeDiffuseLighting,
+    out float3 diffuseLighting,
+    out float3 specularLighting)
+{
+    LightLoopContext context;
+    ZERO_INITIALIZE(LightLoopContext, context);
+
+    diffuseLighting = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    int i = 0; // Declare once to avoid the D3D11 compiler warning.
+
+    for (i = 0; i < _DirectionalLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Directional(context, V, positionWS, prelightData, _DirectionalLightList[i], bsdfData,
+            localDiffuseLighting, localSpecularLighting);
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    for (i = 0; i < _PunctualLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Punctual(context, V, positionWS, prelightData, _PunctualLightList[i], bsdfData,
+            localDiffuseLighting, localSpecularLighting);
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+
+    for (i = 0; i < _AreaLightCount; ++i)
+    {
+        float3 localDiffuseLighting, localSpecularLighting;
+
+        EvaluateBSDF_Area(context, V, positionWS, prelightData, _AreaLightList[i], bsdfData,
+            localDiffuseLighting, localSpecularLighting);
+
+        diffuseLighting += localDiffuseLighting;
+        specularLighting += localSpecularLighting;
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl.meta

+fileFormatVersion: 2
+guid: 382359a4ad457f94a9906526773642c0
+timeCreated: 1479752859
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
+using System.Collections.Generic;
+using System;
+
+namespace UnityEngine.Experimental.ScriptableRenderLoop
+{
+    [Serializable]
+    public class SkyParameters
+    {
+        public Cubemap skyHDRI;
+        public float rotation = 0.0f;
+        public float exposure = 0.0f;
+        public float multiplier = 1.0f;
+    }
+
+    public class SkyRenderer
+    {
+        const int kSkyCubemapSize = 256;
+
+        RenderTexture m_SkyboxCubemapRT = null;
+
+        Material m_StandardSkyboxMaterial = null; // This is the Unity standard skybox material. Used to pass the correct cubemap to Enlighten.
+        Material m_SkyHDRIMaterial = null; // Renders a cubemap into a render texture (can be cube or 2D)
+
+        GameObject[] m_CubemapFaceCamera = new GameObject[6];
+
+        Mesh BuildSkyMesh(Camera camera, bool forceUVBottom)
+        {
+            Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 1.0f, 1.0f);
+            Vector4 vertData1 = new Vector4(1.0f, -1.0f, 1.0f, 1.0f);
+            Vector4 vertData2 = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
+            Vector4 vertData3 = new Vector4(-1.0f, 1.0f, 1.0f, 1.0f);
+
+            Vector3[] vertData = new Vector3[4];
+            vertData[0] = new Vector3(vertData0.x, vertData0.y, vertData0.z);
+            vertData[1] = new Vector3(vertData1.x, vertData1.y, vertData1.z);
+            vertData[2] = new Vector3(vertData2.x, vertData2.y, vertData2.z);
+            vertData[3] = new Vector3(vertData3.x, vertData3.y, vertData3.z);
+
+            // Get view vector vased on the frustrum, i.e (invert transform frustrum get position etc...)
+            Vector3[] eyeVectorData = new Vector3[4];
+
+            Matrix4x4 transformMatrix = camera.cameraToWorldMatrix * camera.projectionMatrix.inverse;
+
+            Vector4 posWorldSpace0 = transformMatrix * vertData0;
+            Vector4 posWorldSpace1 = transformMatrix * vertData1;
+            Vector4 posWorldSpace2 = transformMatrix * vertData2;
+            Vector4 posWorldSpace3 = transformMatrix * vertData3;
+
+            Vector3 temp = camera.GetComponent<Transform>().position;
+            Vector4 cameraPosition = new Vector4(temp.x, temp.y, temp.z, 0.0f);
+
+            Vector4 direction0 = (posWorldSpace0 / posWorldSpace0.w - cameraPosition);
+            Vector4 direction1 = (posWorldSpace1 / posWorldSpace1.w - cameraPosition);
+            Vector4 direction2 = (posWorldSpace2 / posWorldSpace2.w - cameraPosition);
+            Vector4 direction3 = (posWorldSpace3 / posWorldSpace3.w - cameraPosition);
+
+            if (SystemInfo.graphicsUVStartsAtTop && !forceUVBottom)
+            {
+                eyeVectorData[3] = new Vector3(direction0.x, direction0.y, direction0.z).normalized;
+                eyeVectorData[2] = new Vector3(direction1.x, direction1.y, direction1.z).normalized;
+                eyeVectorData[1] = new Vector3(direction2.x, direction2.y, direction2.z).normalized;
+                eyeVectorData[0] = new Vector3(direction3.x, direction3.y, direction3.z).normalized;                
+            }
+            else
+            {
+                eyeVectorData[0] = new Vector3(direction0.x, direction0.y, direction0.z).normalized;
+                eyeVectorData[1] = new Vector3(direction1.x, direction1.y, direction1.z).normalized;
+                eyeVectorData[2] = new Vector3(direction2.x, direction2.y, direction2.z).normalized;
+                eyeVectorData[3] = new Vector3(direction3.x, direction3.y, direction3.z).normalized;
+            }
+
+            // Write out the mesh
+            var triangles = new int[6] { 0, 1, 2, 2, 3, 0 };
+
+            return new Mesh
+            {
+                vertices = vertData,
+                normals = eyeVectorData,
+                triangles = triangles
+            };
+        }
+
+        public void Rebuild()
+        {
+            // TODO: We need to have an API to send our sky information to Enlighten. For now use a workaround through skybox/cubemap material...
+            m_StandardSkyboxMaterial = Utilities.CreateEngineMaterial("Skybox/Cubemap");
+
+            m_SkyHDRIMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/SkyHDRI");
+
+            m_SkyboxCubemapRT = new RenderTexture(kSkyCubemapSize, kSkyCubemapSize, 1, RenderTextureFormat.ARGBHalf);
+            m_SkyboxCubemapRT.dimension = TextureDimension.Cube;
+            m_SkyboxCubemapRT.useMipMap = true;
+            m_SkyboxCubemapRT.autoGenerateMips = true;
+            m_SkyboxCubemapRT.Create();
+
+            Matrix4x4 cubeProj = Matrix4x4.Perspective(90.0f, 1.0f, 0.1f, 1.0f);
+
+            Vector3[] lookAtList = {
+                            new Vector3(1.0f, 0.0f, 0.0f),
+                            new Vector3(-1.0f, 0.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, -1.0f, 0.0f),
+                            new Vector3(0.0f, 0.0f, 1.0f),
+                            new Vector3(0.0f, 0.0f, -1.0f),
+                        };
+            
+            Vector3[] UpVectorList = {
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, 0.0f, -1.0f),
+                            new Vector3(0.0f, 0.0f, 1.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                            new Vector3(0.0f, 1.0f, 0.0f),
+                        };
+
+            for (int i = 0; i < 6; ++i)
+            {
+                m_CubemapFaceCamera[i] = new GameObject();
+                m_CubemapFaceCamera[i].hideFlags = HideFlags.HideAndDontSave;
+
+                Camera camera = m_CubemapFaceCamera[i].AddComponent<Camera>();
+                camera.projectionMatrix = cubeProj;
+                Transform transform = camera.GetComponent<Transform>();
+                transform.LookAt(lookAtList[i], UpVectorList[i]);
+            }
+        }
+
+        public void OnDisable()
+        {
+            Utilities.Destroy(m_StandardSkyboxMaterial);
+            Utilities.Destroy(m_SkyHDRIMaterial);
+            Utilities.Destroy(m_SkyboxCubemapRT);
+
+            for(int i = 0 ; i < 6 ; ++i)
+            {
+                Utilities.Destroy(m_CubemapFaceCamera[i]);
+            }
+
+        }
+
+        private void RenderSky(Camera camera, SkyParameters skyParameters, bool forceUVBottom, RenderLoop renderLoop)
+        {
+            Mesh skyMesh = BuildSkyMesh(camera, forceUVBottom);
+
+            m_SkyHDRIMaterial.SetTexture("_Cubemap", skyParameters.skyHDRI);
+            m_SkyHDRIMaterial.SetVector("_SkyParam", new Vector4(skyParameters.exposure, skyParameters.multiplier, skyParameters.rotation, 0.0f));
+
+            var cmd = new CommandBuffer { name = "Skybox" };
+            cmd.DrawMesh(skyMesh, Matrix4x4.identity, m_SkyHDRIMaterial);
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        public void RenderSky(Camera camera, SkyParameters skyParameters, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, RenderLoop renderLoop)
+        {
+            // Render sky into a cubemap - doesn't happen every frame, can be control
+            for (int i = 0; i < 6; ++i)
+            {
+                Utilities.SetRenderTarget(renderLoop, m_SkyboxCubemapRT, "", 0, (CubemapFace)i);
+                Camera faceCamera = m_CubemapFaceCamera[i].GetComponent<Camera>();
+                RenderSky(faceCamera, skyParameters, true, renderLoop);
+            }
+
+            m_StandardSkyboxMaterial.SetTexture("_Tex", m_SkyboxCubemapRT);
+            RenderSettings.skybox = m_StandardSkyboxMaterial; // Setup this material as the default to be use in RenderSettings
+            RenderSettings.ambientIntensity = 1.0f; // fix this to 1, this parameter should not exist!
+            RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox; // Force skybox for our HDRI
+            RenderSettings.reflectionIntensity = 1.0f;
+            DynamicGI.UpdateEnvironment();
+
+            // TODO: do a render to texture here
+
+            // Downsample the cubemap and provide it to Enlighten
+
+            // TODO: currently workaround is to set the cubemap in a Skybox/cubemap material
+            //m_SkyboxMaterial.SetTexture(cubemap);
+
+            // Render the sky itself
+            Utilities.SetRenderTarget(renderLoop, colorBuffer, depthBuffer, "Sky Pass");
+            RenderSky(camera, skyParameters, false, renderLoop);
+        }
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs.meta

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

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
+
+using UnityObject = UnityEngine.Object;
+
+namespace UnityEngine.Experimental.ScriptableRenderLoop
+{
+    [Flags]
+    public enum ClearFlag
+    {
+        ClearNone = 0,
+        ClearColor = 1,
+        ClearDepth = 2
+    }
+
+    public class Utilities
+    {
+        public const RendererConfiguration kRendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
+
+
+        // Render Target Management.
+        public const ClearFlag kClearAll = ClearFlag.ClearDepth | ClearFlag.ClearColor;
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier buffer, string name = "", int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        {
+            var cmd = new CommandBuffer();
+            cmd.name = name;
+            cmd.SetRenderTarget(buffer, miplevel, cubemapFace);
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, string name = "", int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        {
+            SetRenderTarget(renderLoop, colorBuffer, depthBuffer, ClearFlag.ClearNone, new Color(0.0f, 0.0f, 0.0f, 0.0f), name, miplevel, cubemapFace);
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, string name = "", int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        {
+            SetRenderTarget(renderLoop, colorBuffer, depthBuffer, clearFlag, new Color(0.0f, 0.0f, 0.0f, 0.0f), name, miplevel, cubemapFace);
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, string name = "", int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown)
+        {
+            var cmd = new CommandBuffer();
+            cmd.name = name;
+            cmd.SetRenderTarget(colorBuffer, depthBuffer, miplevel, cubemapFace);
+            if (clearFlag != ClearFlag.ClearNone)
+                cmd.ClearRenderTarget((clearFlag & ClearFlag.ClearDepth) != 0, (clearFlag & ClearFlag.ClearColor) != 0, clearColor);
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, string name = "")
+        {
+            SetRenderTarget(renderLoop, colorBuffers, depthBuffer, ClearFlag.ClearNone, Color.black, name);
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag = ClearFlag.ClearNone, string name = "")
+        {
+            SetRenderTarget(renderLoop, colorBuffers, depthBuffer, clearFlag, Color.black, name);
+        }
+
+        public static void SetRenderTarget(RenderLoop renderLoop, RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier depthBuffer, ClearFlag clearFlag, Color clearColor, string name = "")
+        {
+            var cmd = new CommandBuffer();
+            cmd.name = name;
+            cmd.SetRenderTarget(colorBuffers, depthBuffer);
+            if (clearFlag != ClearFlag.ClearNone)
+                cmd.ClearRenderTarget((clearFlag & ClearFlag.ClearDepth) != 0, (clearFlag & ClearFlag.ClearColor) != 0, clearColor);
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+        }
+
+        // Miscellanous
+        public static Material CreateEngineMaterial(string shaderPath)
+        {
+            var mat = new Material(Shader.Find(shaderPath))
+            {
+                hideFlags = HideFlags.HideAndDontSave
+            };
+            return mat;
+        }
+
+        public static void Destroy(UnityObject obj)
+        {
+            if (obj != null)
+            {
+#if UNITY_EDITOR
+                if (Application.isPlaying)
+                    UnityObject.Destroy(obj);
+                else
+                    UnityObject.DestroyImmediate(obj);
+#else
+                    UnityObject.Destroy(obj);
+#endif
+            }
+        }
+		
+        public static Matrix4x4 GetViewProjectionMatrix(Camera camera)
+        {
+            // The actual projection matrix used in shaders is actually massaged a bit to work across all platforms
+            // (different Z value ranges etc.)
+            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false);
+            var gpuVP = gpuProj * camera.worldToCameraMatrix;
+
+            return gpuVP;
+        }
+
+        public static Vector4 ComputeScreenSize(Camera camera)
+        {
+            return new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
+        }
+    }
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs.meta

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

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s00.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: GGX_D_a00_s00
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s00.mat.meta

+fileFormatVersion: 2
+guid: 7ba24c2e8c22ccf4d88652e79595e8f1
+timeCreated: 1479746532
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s02.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: GGX_D_a00_s02
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.2
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s02.mat.meta

+fileFormatVersion: 2
+guid: de888486ebd304e48883a3ba5eb2b6a1
+timeCreated: 1479746595
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s04.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: GGX_D_a00_s04
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.4
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s04.mat.meta

+fileFormatVersion: 2
+guid: aeb096239e876a44faf16cf6b6d91874
+timeCreated: 1479746595
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s06.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: GGX_D_a00_s06
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.6
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s06.mat.meta

+fileFormatVersion: 2
+guid: 0d91bbd9abea15a498907cb4f19bc92f
+timeCreated: 1479746595
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s08.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: GGX_D_a00_s08
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 0.8
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s08.mat.meta

+fileFormatVersion: 2
+guid: bb4a92bc2a42fd442af65b31a94532b9
+timeCreated: 1479746595
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s10.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: GGX_D_a00_s10
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _DETAIL_MAP_WITH_NORMAL _DISTORTIONDEPTHTEST_OFF
+    _DISTORTIONONLY_OFF _EMISSION _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AmbientOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _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}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        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}
+    - _MettalicMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        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}
+    - _SmoothnessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DetailAOScale: 1
+    - _DetailAlbedoScale: 1
+    - _DetailHeightScale: 1
+    - _DetailMapMode: 0
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DistortionDepthTest: 0
+    - _DistortionOnly: 0
+    - _DoubleSided: 1
+    - _DoubleSidedLigthing: 1
+    - _DoubleSidedMode: 0
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightBias: 0
+    - _HeightMapMode: 0
+    - _HeightScale: 1
+    - _MaterialID: 0
+    - _MaterialId: 0
+    - _Metalic: 0
+    - _Metallic: 0
+    - _Mettalic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _Smoothness: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SubSurfaceRadius: 0
+    - _SurfaceType: 0
+    - _UVDetail: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 0.5019608, g: 0.5019608, b: 0.5019608, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

Assets/TestScenes/HDTest/Material/HDRenderLoopMaterials/GGX Test/GGX_D_a00_s10.mat.meta

+fileFormatVersion: 2
+guid: bd24e956f1c1f6c4a8636a6f6abdc302
+timeCreated: 1479746595
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders.meta

-fileFormatVersion: 2
-guid: fafbb144d7f66074785b7727293d89c5
-folderAsset: yes
-timeCreated: 1474297943
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: