Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop

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;
         TextureSettings m_TextureSettings = TextureSettings.Default;
 
         // Various set of material use in render loop
-        Material m_DeferredMaterial;
         Material m_FinalPassMaterial;
         Material m_DebugViewMaterialGBuffer;
 
         RenderTargetIdentifier m_CameraDepthBufferRT;
         RenderTargetIdentifier m_VelocityBufferRT;
         RenderTargetIdentifier m_DistortionBufferRT;
-
-
+		
         public class LightList
         {
             public List<DirectionalLightData> directionalLights;
 
             m_SkyRenderer = new SkyRenderer();
             m_SkyRenderer.Rebuild();
-        
-            m_DeferredMaterial   = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+
             m_FinalPassMaterial  = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/FinalPass");
             m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewMaterialGBuffer");
 
             m_SinglePassLightLoop.OnDisable();
             m_TilePassLightLoop.OnDisable();
 
-            Utilities.Destroy(m_DeferredMaterial);
             Utilities.Destroy(m_FinalPassMaterial);
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
 
 
                 Utilities.SetRenderTarget(renderLoop, m_CameraColorBufferRT, m_CameraDepthBufferRT, ClearFlag.ClearDepth);
             }
+
 
             // TEMP: As we are in development and have not all the setup pass we still clear the color in emissive buffer and gbuffer, but this will be removed later.
 
             if (!debugParameters.useDepthPrepass)
                 return;
 
-              // TODO: Must do opaque then alpha masked for performance! 
+            // TODO: Must do opaque then alpha masked for performance! 
-			RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
+            RenderOpaqueRenderList(cull, camera, renderLoop, "DepthOnly");
         }
 
         void RenderGBuffer(CullResults cull, Camera camera, RenderLoop renderLoop)
             // 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);
                 // TODO: Bind depth textures
                 var cmd = new CommandBuffer { name = "GBuffer Debug Pass" };
                 cmd.Blit(null, m_CameraColorBufferRT, m_DebugViewMaterialGBuffer, 0);
             }
         }
 
-        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, m_CameraColorBufferRT, m_DeferredMaterial, 0);
-            renderLoop.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            m_SinglePassLightLoop.RenderDeferredLighting(camera, renderLoop, m_CameraColorBuffer);
+           // m_TilePassLightLoop.RenderDeferredLighting(camera, renderLoop, );
-            }
+        }
 
         void RenderForward(CullResults cullResults, Camera camera, RenderLoop renderLoop)
         {
 
                     if (additionalData.archetype == LightArchetype.Rectangle)
                     {
-                    lightData.lightType = GPULightType.Rectangle;
-                }
-                else
-                {
+                        lightData.lightType = GPULightType.Rectangle;
+                    }
+                    else
+                    {
                         lightData.lightType = GPULightType.Line;
                     }
                 }
                     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/Lit/Editor/LitUI.cs

 
 namespace UnityEditor
 {
-    internal class LitGUI : ShaderGUI
+    public abstract class BaseLitGUI : ShaderGUI
-        public enum SurfaceType
-        {
-            Opaque,
-            Transparent
-        }
-        public enum BlendMode
-        {
-            Lerp,
-            Add,
-            SoftAdd,
-            Multiply,
-            Premultiply
-        }
-
-        public enum SmoothnessMapChannel
-        {
-            MaskAlpha,
-            AlbedoAlpha,
-        }
-        public enum EmissiveColorMode
-        {
-            UseEmissiveColor,
-            UseEmissiveMask,
-        }
-        public enum DoubleSidedMode
-        {
-            None,
-            DoubleSided,
-            DoubleSidedLightingFlip,
-            DoubleSidedLightingMirror,
-        }
-
-        public enum NormalMapSpace
+        protected static class Styles
-            TangentSpace,
-            ObjectSpace,
-        }
-
-        public enum HeightmapMode
-        {
-            Parallax,
-            Displacement,
-        }
-        public enum DetailMapMode
-        {
-            DetailWithNormal,
-            DetailWithAOHeight,
-        }
-
-        private static class Styles
-        {
+            public enum DetailMapMode
+            {
+                DetailWithNormal,
+                DetailWithAOHeight,
+            }
             public static string OptionText = "Options";
             public static string SurfaceTypeText = "Surface Type";
             public static string BlendModeText = "Blend Mode";
 
         }
 
-        MaterialProperty surfaceType = null;
-        MaterialProperty blendMode = null;
+        public enum SurfaceType
+        {
+            Opaque,
+            Transparent
+        }
+        public enum BlendMode
+        {
+            Lerp,
+            Add,
+            SoftAdd,
+            Multiply,
+            Premultiply
+        }
+        public enum DoubleSidedMode
+        {
+            None,
+            DoubleSided,
+            DoubleSidedLightingFlip,
+            DoubleSidedLightingMirror,
+        }
+
+        void SurfaceTypePopup()
+        {
+            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
+            var mode = (SurfaceType)surfaceType.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
+                surfaceType.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected void ShaderOptionsGUI()
+        {
+            EditorGUI.indentLevel++;
+            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
+            SurfaceTypePopup();
+            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
+            {
+                BlendModePopup();
+            }
+            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
+            if (alphaCutoffEnable.floatValue == 1.0)
+            {
+                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
+            }
+            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
+
+            EditorGUI.indentLevel--;
+        }
+
+        private void BlendModePopup()
+        {
+            EditorGUI.showMixedValue = blendMode.hasMixedValue;
+            var mode = (BlendMode)blendMode.floatValue;
+
+            EditorGUI.BeginChangeCheck();
+            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
+            if (EditorGUI.EndChangeCheck())
+            {
+                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
+                blendMode.floatValue = (float)mode;
+            }
+
+            EditorGUI.showMixedValue = false;
+        }
+
+        protected void FindOptionProperties(MaterialProperty[] props)
+        {
+            surfaceType = FindProperty(kSurfaceType, props);
+            blendMode = FindProperty(kBlendMode, props);
+            alphaCutoff = FindProperty(kAlphaCutoff, props);
+            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
+            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
+            FindInputOptionProperties(props);
+        }
+
+        protected void SetupMaterial(Material material)
+        {
+            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
+            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
+            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
+            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
+
+            if (surfaceType == SurfaceType.Opaque)
+            {
+                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
+                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                material.SetInt("_ZWrite", 1);
+                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
+            }
+            else
+            {
+                material.SetOverrideTag("RenderType", "Transparent");
+                material.SetInt("_ZWrite", 0);
+                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+
+                switch (blendMode)
+                {
+                    case BlendMode.Lerp:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+
+                    case BlendMode.Add:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.SoftAdd:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        break;
+
+                    case BlendMode.Multiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+                        break;
+
+                    case BlendMode.Premultiply:
+                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+                        break;
+                }
+            }
+
+            if (doubleSidedMode == DoubleSidedMode.None)
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
+            }
+            else
+            {
+                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
+            }
+
+            if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingFlip)
+            {
+                material.EnableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+            else if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingMirror)
+            {
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.EnableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+            else
+            {
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
+                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
+            }
+
+            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
+            SetupInputMaterial(material);
+        }
+
+        protected void SetKeyword(Material m, string keyword, bool state)
+        {
+            if (state)
+                m.EnableKeyword(keyword);
+            else
+                m.DisableKeyword(keyword);
+        }
+
+        public void ShaderPropertiesGUI(Material material)
+        {
+            // Use default labelWidth
+            EditorGUIUtility.labelWidth = 0f;
+
+            // Detect any changes to the material
+            EditorGUI.BeginChangeCheck();
+            {
+                ShaderOptionsGUI();
+                EditorGUILayout.Space();
+
+                ShaderInputOptionsGUI();
+
+                EditorGUILayout.Space();
+                ShaderInputGUI();
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                foreach (var obj in m_MaterialEditor.targets)
+                    SetupMaterial((Material)obj);
+            }
+        }
+
+        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
+            FindInputProperties(props);
+
+            m_MaterialEditor = materialEditor;
+            Material material = materialEditor.target as Material;
+            ShaderPropertiesGUI(material);
+        }
+
+        protected MaterialEditor m_MaterialEditor;
+
+        private MaterialProperty surfaceType = null;
+        private MaterialProperty alphaCutoffEnable = null;
+        private MaterialProperty blendMode = null;
+        private MaterialProperty alphaCutoff = null;
+        private MaterialProperty doubleSidedMode = null;
+ 
+        private const string kSurfaceType = "_SurfaceType";
+        private const string kBlendMode = "_BlendMode";
+        private const string kAlphaCutoff = "_AlphaCutoff";
+        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
+    {
+        public enum SmoothnessMapChannel
+        {
+            MaskAlpha,
+            AlbedoAlpha,
+        }
+        public enum EmissiveColorMode
+        {
+            UseEmissiveColor,
+            UseEmissiveMask,
+        }
+ 
+        public enum NormalMapSpace
+        {
+            TangentSpace,
+            ObjectSpace,
+        }
+
+        public enum HeightmapMode
+        {
+            Parallax,
+            Displacement,
+        }
+        public enum DetailMapMode
+        {
+            DetailWithNormal,
+            DetailWithAOHeight,
+        }
+
-        MaterialProperty alphaCutoff = null;
-        MaterialProperty alphaCutoffEnable = null;
-        MaterialProperty doubleSidedMode = null;
         MaterialProperty smoothnessMapChannel = null;
         MaterialProperty emissiveColorMode = null;
         MaterialProperty detailMapMode = null;
 //	MaterialProperty subSurfaceRadius = null;
 //	MaterialProperty subSurfaceRadiusMap = null;
 
-        protected MaterialEditor m_MaterialEditor;
-
-        protected const string kSurfaceType = "_SurfaceType";
-        protected const string kBlendMode = "_BlendMode";
-        protected const string kAlphaCutoff = "_AlphaCutoff";
-        protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable";
-        protected const string kDoubleSidedMode = "_DoubleSidedMode";
         protected const string kSmoothnessTextureChannelProp = "_SmoothnessTextureChannel";
         protected const string kEmissiveColorMode = "_EmissiveColorMode";
         protected const string kNormalMapSpace = "_NormalMapSpace";
         protected const string kDetailHeightScale = "_DetailHeightScale";
         protected const string kDetailAOScale = "_DetailAOScale";
 
-        public void FindOptionProperties(MaterialProperty[] props)
+        override protected void FindInputOptionProperties(MaterialProperty[] props)
-            surfaceType = FindProperty(kSurfaceType, props);
-            blendMode = FindProperty(kBlendMode, props);
-            alphaCutoff = FindProperty(kAlphaCutoff, props);
-            alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props);
-            doubleSidedMode = FindProperty(kDoubleSidedMode, props);
             smoothnessMapChannel = FindProperty(kSmoothnessTextureChannelProp, props);
             emissiveColorMode = FindProperty(kEmissiveColorMode, props);
             normalMapSpace = FindProperty(kNormalMapSpace, props);
 
-        public void FindInputProperties(MaterialProperty[] props)
+        override protected void FindInputProperties(MaterialProperty[] props)
         {
             baseColor = FindProperty("_BaseColor", props);
             baseColorMap = FindProperty("_BaseColorMap", props);
             detailAOScale = FindProperty(kDetailAOScale, props);
         }
 
-        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
-            FindInputProperties(props);
-
-            m_MaterialEditor = materialEditor;
-            Material material = materialEditor.target as Material;
-            ShaderPropertiesGUI(material);
-        }
-
-        protected void ShaderOptionsGUI()
-        {
-            EditorGUI.indentLevel++;
-            GUILayout.Label(Styles.OptionText, EditorStyles.boldLabel);
-            SurfaceTypePopup();
-            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
-            {
-                BlendModePopup();
-            }
-            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, Styles.alphaCutoffEnableText.text);
-            if (alphaCutoffEnable.floatValue == 1.0)
-            {
-                m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text);
-            }
-            m_MaterialEditor.ShaderProperty(doubleSidedMode, Styles.doubleSidedModeText.text);
-
-            EditorGUI.indentLevel--;
-        }
-
-        protected void ShaderInputOptionsGUI()
+        override protected void ShaderInputOptionsGUI()
         {
             EditorGUI.indentLevel++;
             GUILayout.Label(Styles.InputsOptionsText, EditorStyles.boldLabel);
             EditorGUI.indentLevel--;
         }
 
-        protected void ShaderInputGUI()
+        override protected void ShaderInputGUI()
         {
             EditorGUI.indentLevel++;
             bool smoothnessInAlbedoAlpha = (SmoothnessMapChannel)smoothnessMapChannel.floatValue == SmoothnessMapChannel.AlbedoAlpha;
             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)
             {
             EditorGUI.indentLevel--;
         }
 
-        public void ShaderPropertiesGUI(Material material)
-        {
-            // Use default labelWidth
-            EditorGUIUtility.labelWidth = 0f;
-
-            // Detect any changes to the material
-            EditorGUI.BeginChangeCheck();
-            {
-                ShaderOptionsGUI();
-                EditorGUILayout.Space();
-
-                ShaderInputOptionsGUI();
-
-                EditorGUILayout.Space();
-                ShaderInputGUI();
-            }
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                foreach (var obj in m_MaterialEditor.targets)
-                    SetupMaterial((Material)obj);
-            }
-        }
-
         // TODO: try to setup minimun value to fall back to standard shaders and reverse
         public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
         {
-        void SurfaceTypePopup()
-        {
-            EditorGUI.showMixedValue = surfaceType.hasMixedValue;
-            var mode = (SurfaceType)surfaceType.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (SurfaceType)EditorGUILayout.Popup(Styles.SurfaceTypeText, (int)mode, Styles.surfaceTypeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Surface Type");
-                surfaceType.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        }
-
-        void BlendModePopup()
-        {
-            EditorGUI.showMixedValue = blendMode.hasMixedValue;
-            var mode = (BlendMode)blendMode.floatValue;
-
-            EditorGUI.BeginChangeCheck();
-            mode = (BlendMode)EditorGUILayout.Popup(Styles.BlendModeText, (int)mode, Styles.blendModeNames);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_MaterialEditor.RegisterPropertyChangeUndo("Blend Mode");
-                blendMode.floatValue = (float)mode;
-            }
-
-            EditorGUI.showMixedValue = false;
-        }
-
         protected virtual void SetupKeywordsForInputMaps(Material material)
         {
             SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); // With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for ir
             }
         }
 
-        protected void SetupMaterial(Material material)
+        override protected void SetupInputMaterial(Material material)
-
-            bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) == 1.0;
-            SurfaceType surfaceType = (SurfaceType)material.GetFloat(kSurfaceType);
-            BlendMode blendMode = (BlendMode)material.GetFloat(kBlendMode);
-            DoubleSidedMode doubleSidedMode = (DoubleSidedMode)material.GetFloat(kDoubleSidedMode);
-
-            if (surfaceType == SurfaceType.Opaque)
-            {
-                material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : "");
-                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
-            }
-            else
-            {
-                material.SetOverrideTag("RenderType", "Transparent");
-                material.SetInt("_ZWrite", 0);
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
-
-                switch (blendMode)
-                {
-                    case BlendMode.Lerp:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-
-                    case BlendMode.Add:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.SoftAdd:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        break;
-
-                    case BlendMode.Multiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
-                        break;
-
-                    case BlendMode.Premultiply:
-                        material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
-                        material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
-                        break;
-                }
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.None)
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back);
-            }
-            else
-            {
-                material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Off);
-            }
-
-            if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingFlip)
-            {
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else if (doubleSidedMode == DoubleSidedMode.DoubleSidedLightingMirror)
-            {
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.EnableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-            else
-            {
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_FLIP");
-                material.DisableKeyword("_DOUBLESIDED_LIGHTING_MIRROR");
-            }
-
-            SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable);
             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);
             */
 
             return true;
-        }
-
-        protected void SetKeyword(Material m, string keyword, bool state)
-        {
-            if (state)
-                m.EnableKeyword(keyword);
-            else
-                m.DisableKeyword(keyword);
         }
     }
 } // namespace UnityEditor

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/Utilities.cs

 #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/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
 
 #define MERGE_NAME(X, Y) X##Y
 

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
 //-----------------------------------------------------------------------------

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/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: