more property conversions, light intensity conversion, shader LOD toggle, sample shader (WIP), standard specular conversion (WIP)

Assets/ScriptableRenderLoop/Editor/MaterialUpgrader.cs

 using System;
 
 namespace UnityEditor.Experimental.ScriptableRenderLoop
-{	
-	public class MaterialUpgrader
-	{
-		string m_OldShader;
-		string m_NewShader;
+{
+    public class MaterialUpgrader
+    {
+        string m_OldShader;
+        string m_NewShader;
-		Dictionary<string, string> m_TextureRename = new Dictionary<string, string>();
-		Dictionary<string, string> m_FloatRename = new Dictionary<string, string>();
-		Dictionary<string, string> m_ColorRename = new Dictionary<string, string>();
+        Dictionary<string, string> m_TextureRename = new Dictionary<string, string>();
+        Dictionary<string, string> m_FloatRename = new Dictionary<string, string>();
+        Dictionary<string, string> m_ColorRename = new Dictionary<string, string>();
-		[Flags]
-		public enum UpgradeFlags
-		{
-			None = 0,
-			LogErrorOnNonExistingProperty = 1,
-			CleanupNonUpgradedProperties = 2,
-		}
+        [Flags]
+        public enum UpgradeFlags
+        {
+            None = 0,
+            LogErrorOnNonExistingProperty = 1,
+            CleanupNonUpgradedProperties = 2,
+        }
-		public void Upgrade(Material material, UpgradeFlags flags)
-		{
-			Material newMaterial;
-			if ((flags & UpgradeFlags.CleanupNonUpgradedProperties) != 0)
-			{
-				newMaterial = new Material(Shader.Find (m_NewShader));
-			}
-			else
-			{
-				newMaterial = UnityEngine.Object.Instantiate(material) as Material;
-				newMaterial.shader = Shader.Find (m_NewShader);
-			}
+        public void Upgrade(Material material, UpgradeFlags flags)
+        {
+            Material newMaterial;
+            if ((flags & UpgradeFlags.CleanupNonUpgradedProperties) != 0)
+            {
+                newMaterial = new Material(Shader.Find(m_NewShader));
+            }
+            else
+            {
+                newMaterial = UnityEngine.Object.Instantiate(material) as Material;
+                newMaterial.shader = Shader.Find(m_NewShader);
+            }
-			Convert(material, newMaterial);
+            Convert(material, newMaterial);
-			material.shader = Shader.Find (m_NewShader);
-			material.CopyPropertiesFromMaterial (newMaterial);
-			UnityEngine.Object.DestroyImmediate (newMaterial);
-		}
+            material.shader = Shader.Find(m_NewShader);
+            material.CopyPropertiesFromMaterial(newMaterial);
+            UnityEngine.Object.DestroyImmediate(newMaterial);
+        }
-		// Overridable function to implement custom material upgrading functionality
-		public virtual void Convert(Material srcMaterial, Material dstMaterial)
-		{
-		    foreach (var t in m_TextureRename)
-		    {
-		        dstMaterial.SetTextureScale(t.Value, srcMaterial.GetTextureScale(t.Key));
-		        dstMaterial.SetTextureOffset(t.Value, srcMaterial.GetTextureOffset(t.Key));
-		        dstMaterial.SetTexture(t.Value, srcMaterial.GetTexture(t.Key));
-		    }
+        // Overridable function to implement custom material upgrading functionality
+        public virtual void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            foreach (var t in m_TextureRename)
+            {
+                dstMaterial.SetTextureScale(t.Value, srcMaterial.GetTextureScale(t.Key));
+                dstMaterial.SetTextureOffset(t.Value, srcMaterial.GetTextureOffset(t.Key));
+                dstMaterial.SetTexture(t.Value, srcMaterial.GetTexture(t.Key));
+            }
-		    foreach (var t in m_FloatRename)
-				dstMaterial.SetFloat (t.Value, srcMaterial.GetFloat(t.Key));
+            foreach (var t in m_FloatRename)
+                dstMaterial.SetFloat(t.Value, srcMaterial.GetFloat(t.Key));
-			foreach (var t in m_ColorRename)
-				dstMaterial.SetColor (t.Value, srcMaterial.GetColor(t.Key));
-		}
+            foreach (var t in m_ColorRename)
+                dstMaterial.SetColor(t.Value, srcMaterial.GetColor(t.Key));
+        }
-		public void RenameShader(string oldName, string newName)
-		{
-			m_OldShader = oldName;
-			m_NewShader = newName;
-		}
+        public void RenameShader(string oldName, string newName)
+        {
+            m_OldShader = oldName;
+            m_NewShader = newName;
+        }
-		public void RenameTexture(string oldName, string newName)
-		{
-			m_TextureRename[oldName] = newName;
-		}
+        public void RenameTexture(string oldName, string newName)
+        {
+            m_TextureRename[oldName] = newName;
+        }
-		public void RenameFloat(string oldName, string newName)
-		{
-			m_FloatRename[oldName] = newName;				
-		}
+        public void RenameFloat(string oldName, string newName)
+        {
+            m_FloatRename[oldName] = newName;
+        }
-		public void RenameColor(string oldName, string newName)
-		{
-			m_ColorRename[oldName] = newName;
-		}
+        public void RenameColor(string oldName, string newName)
+        {
+            m_ColorRename[oldName] = newName;
+        }
-		static bool IsMaterialPath(string path)
-		{
-			return path.EndsWith (".mat", StringComparison.OrdinalIgnoreCase);
-		}
+        static bool IsMaterialPath(string path)
+        {
+            return path.EndsWith(".mat", StringComparison.OrdinalIgnoreCase);
+        }
-		static MaterialUpgrader GetUpgrader(List<MaterialUpgrader> upgraders, Material material)
-		{
-			if (material == null || material.shader == null)
-				return null;
+        static MaterialUpgrader GetUpgrader(List<MaterialUpgrader> upgraders, Material material)
+        {
+            if (material == null || material.shader == null)
+                return null;
-			string shaderName = material.shader.name;
-			for (int i = 0;i != upgraders.Count;i++)
-			{
-				if (upgraders[i].m_OldShader == shaderName)
-					return upgraders[i];
-			}
+            string shaderName = material.shader.name;
+            for (int i = 0; i != upgraders.Count; i++)
+            {
+                if (upgraders[i].m_OldShader == shaderName)
+                    return upgraders[i];
+            }
-			return null;
-		}
+            return null;
+        }
-		//@TODO: Only do this when it exceeds memory consumption...
-		static void SaveAssetsAndFreeMemory()
-		{
-			AssetDatabase.SaveAssets();
-			GC.Collect();
-			EditorUtility.UnloadUnusedAssetsImmediate();
-			AssetDatabase.Refresh();
-		}
+        //@TODO: Only do this when it exceeds memory consumption...
+        static void SaveAssetsAndFreeMemory()
+        {
+            AssetDatabase.SaveAssets();
+            GC.Collect();
+            EditorUtility.UnloadUnusedAssetsImmediate();
+            AssetDatabase.Refresh();
+        }
-		static public void UpgradeProjectFolder(List<MaterialUpgrader> upgraders, string progressBarName)
-		{
-			int totalMaterialCount = 0;
-			foreach ( string s in UnityEditor.AssetDatabase.GetAllAssetPaths() )
-			{
-				if (IsMaterialPath(s))
-					totalMaterialCount++;
-			}
+        public static void UpgradeProjectFolder(List<MaterialUpgrader> upgraders, string progressBarName)
+        {
+            int totalMaterialCount = 0;
+            foreach (string s in UnityEditor.AssetDatabase.GetAllAssetPaths())
+            {
+                if (IsMaterialPath(s))
+                    totalMaterialCount++;
+            }
-			int materialIndex = 0;
-			foreach ( string path in UnityEditor.AssetDatabase.GetAllAssetPaths() )
-			{
-				if (IsMaterialPath(path))
-				{
-					materialIndex++;
-					if ( UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format( "({0} of {1}) {2}", materialIndex, totalMaterialCount, path ), ( float )materialIndex / ( float )totalMaterialCount ) )
-						break;
+            int materialIndex = 0;
+            foreach (string path in UnityEditor.AssetDatabase.GetAllAssetPaths())
+            {
+                if (IsMaterialPath(path))
+                {
+                    materialIndex++;
+                    if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", materialIndex, totalMaterialCount, path), (float)materialIndex / (float)totalMaterialCount))
+                        break;
-					Material m = UnityEditor.AssetDatabase.LoadMainAssetAtPath( path ) as Material;
-					Upgrade (m, upgraders, UpgradeFlags.None);
+                    Material m = UnityEditor.AssetDatabase.LoadMainAssetAtPath(path) as Material;
+                    Upgrade(m, upgraders, UpgradeFlags.None);
-					//SaveAssetsAndFreeMemory();
-				}
-			}
+                    //SaveAssetsAndFreeMemory();
+                }
+            }
-			UnityEditor.EditorUtility.ClearProgressBar();
-		}
+            UnityEditor.EditorUtility.ClearProgressBar();
+        }
-		public static void Upgrade(Material material, MaterialUpgrader upgrader, UpgradeFlags flags)
-		{
-			var upgraders = new List<MaterialUpgrader> ();
-			upgraders.Add (upgrader);
-			Upgrade (material, upgraders, flags);
-		}
+        public static void Upgrade(Material material, MaterialUpgrader upgrader, UpgradeFlags flags)
+        {
+            var upgraders = new List<MaterialUpgrader>();
+            upgraders.Add(upgrader);
+            Upgrade(material, upgraders, flags);
+        }
-		public static void Upgrade(Material material, List<MaterialUpgrader> upgraders, UpgradeFlags flags)
-		{
-			var upgrader = GetUpgrader (upgraders, material);
-			if (upgrader != null)
-				upgrader.Upgrade (material, flags);
-		}
+        public static void Upgrade(Material material, List<MaterialUpgrader> upgraders, UpgradeFlags flags)
+        {
+            var upgrader = GetUpgrader(upgraders, material);
+            if (upgrader != null)
+                upgrader.Upgrade(material, flags);
+        }
-		public static void UpgradeSelection(List<MaterialUpgrader> upgraders, string progressBarName)
-		{
-			string lastMaterialName = "";
-			var selection = Selection.objects;
-			for (int i = 0; i < selection.Length;i++)
-			{
+        public static void UpgradeSelection(List<MaterialUpgrader> upgraders, string progressBarName)
+        {
+            string lastMaterialName = "";
+            var selection = Selection.objects;
+            for (int i = 0; i < selection.Length; i++)
+            {
-				if ( UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format( "({0} of {1}) {2}", i, selection.Length, lastMaterialName ), ( float )i / ( float )selection.Length ) )
-					break;
+                if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", i, selection.Length, lastMaterialName), (float)i / (float)selection.Length))
+                    break;
-				var material = selection[i] as Material;
-				Upgrade (material, upgraders, UpgradeFlags.None);
-				if (material != null)
-					lastMaterialName = material.name;
-			}
+                var material = selection[i] as Material;
+                Upgrade(material, upgraders, UpgradeFlags.None);
+                if (material != null)
+                    lastMaterialName = material.name;
+            }
-			UnityEditor.EditorUtility.ClearProgressBar();
-		}
-	}	
+            UnityEditor.EditorUtility.ClearProgressBar();
+        }
+    }
 }

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/UpgradeStandardShaderMaterials.cs

 		{
 			var upgraders = new List<MaterialUpgrader> ();
 			upgraders.Add(new StandardToHDLitMaterialUpgrader ());
-			return upgraders;
+            upgraders.Add(new StandardSpecularToHDLitMaterialUpgrader());
+            return upgraders;
 		}
 
 		[MenuItem("HDRenderLoop/Upgrade Materials - Project")]
 		{
 			MaterialUpgrader.UpgradeSelection (GetHDUpgraders(), "Upgrade to HD Material");
 		}
+
+	    [MenuItem("HDRenderLoop/Modify Light Intensity for Upgrade - Scene Only")]
+	    static void UpgradeLights()
+	    {
+	        Light[] lights = Light.GetLights(LightType.Directional, 0);
+	        foreach (var l in lights)
+	        {
+	            l.intensity *= Mathf.PI;
+	        }
+	    }
 	}
 }

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

 	{
 		public StandardToHDLitMaterialUpgrader()
 		{
-			RenameShader("Standard", "HDRenderLoop/Lit");
-			
-			RenameTexture("_MainTex", "_BaseColorMap");
-			RenameColor("_Color", "_BaseColor");
+			RenameShader("Standard", "HDRenderLoop/LitLegacySupport");
+
+            RenameTexture("_MainTex", "_BaseColorMap");
+            RenameColor("_Color", "_BaseColor");
+            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
-			//@Seb: Bumpmap scale doesn't exist in new shader
-			//_BumpScale("Scale", Float) = 1.0
+            // the HD renderloop packs detail albedo and detail normals into a single texture.
+            // mapping the detail normal map, if any, to the detail map, should do the right thing if
+            // there is no detail albedo.
+            RenameTexture("_DetailNormalMap", "_DetailMap");
-			// Metallic uses [Gamma] attribute in standard shader but not in Lit. 
-			// @Seb: Should we convert?
-			RenameFloat("_Metallic", "_Metallic");
+            //@Seb: Bumpmap scale doesn't exist in new shader
+            //_BumpScale("Scale", Float) = 1.0
+
+            // Metallic uses [Gamma] attribute in standard shader but not in Lit. 
+            // @Seb: Should we convert?
+            RenameFloat("_Metallic", "_Metallic");
 
 			//@TODO: Seb. Why do we multiply color by intensity
 			//       in shader when we can just store a color?
 		[Test]
 		public void UpgradeMaterial()
 		{
-			var newShader = Shader.Find("HDRenderLoop/Lit");
+			var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
-			var color = Color.red;
+            var normals = new Texture2D(1, 1);
+            var baseScale = new Vector2(1, 1);
+            var color = Color.red;
+            mat.SetTexture("_BumpMap", normals);
+            mat.SetTextureScale("_MainTex", baseScale);
+
-			MaterialUpgrader.Upgrade(mat, new StandardToHDLitMaterialUpgrader (), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+            MaterialUpgrader.Upgrade(mat, new StandardToHDLitMaterialUpgrader (), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
-		}
+		    Assert.AreEqual (baseScale, mat.GetTextureScale("_BaseColorMap"));
+            Assert.AreEqual (normals, mat.GetTexture("_NormalMap"));
+        }
 	}
 }
 

Assets/ScriptableRenderLoop/ScriptableRenderLoopPicker.cs

         [SerializeField]
         private ScriptableRenderLoop m_RenderLoop;
 
+        // TEMPORARY
+        public int legacyRenderLoopMaxShaderLOD = int.MaxValue;
+
         void OnEnable()
         {
             RenderLoop.renderLoopDelegate += Render;
 
         void SyncRenderingFeatures()
         {
+            if (m_RenderLoop != null && isActiveAndEnabled)
+                Shader.globalMaximumLOD = int.MaxValue; 
+
 #if UNITY_EDITOR
             if (m_RenderLoop != null && isActiveAndEnabled)
                 UnityEditor.SupportedRenderingFeatures.active = m_RenderLoop.GetSupportedRenderingFeatures();
         void OnDisable()
         {
             RenderLoop.renderLoopDelegate -= Render;
+            Shader.globalMaximumLOD = legacyRenderLoopMaxShaderLOD;
-            #if UNITY_EDITOR
+#if UNITY_EDITOR
             UnityEditor.SupportedRenderingFeatures.active = UnityEditor.SupportedRenderingFeatures.Default;
             #endif
         }

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy.meta

+fileFormatVersion: 2
+guid: 61a83edb80b70af40ba34e9ba32fbe13
+folderAsset: yes
+timeCreated: 1479834220
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace UnityEditor.Experimental.ScriptableRenderLoop
+{
+    class StandardSpecularToHDLitMaterialUpgrader : MaterialUpgrader
+    {
+        public StandardSpecularToHDLitMaterialUpgrader()
+        {
+            RenameShader("Standard (Specular setup)", "HDRenderLoop/LitLegacySupport");
+
+            RenameTexture("_MainTex", "_BaseColorMap");
+            RenameColor("_Color", "_BaseColor");
+            RenameFloat("_Glossiness", "_Smoothness");
+            RenameTexture("_BumpMap", "_NormalMap");
+            RenameColor("_EmissionColor", "_EmissiveColor");
+            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+            RenameTexture("_DetailNormalMap", "_DetailMap");
+
+            //@Seb: Bumpmap scale doesn't exist in new shader
+            //_BumpScale("Scale", Float) = 1.0
+
+            // Anything reasonable that can be done here?
+            //RenameFloat("_SpecColor", ...);
+
+            //@TODO: Seb. Why do we multiply color by intensity
+            //       in shader when we can just store a color?
+            // builtinData.emissiveColor * builtinData.emissiveIntensity
+        }
+
+        public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            base.Convert(srcMaterial, dstMaterial);
+            //@TODO: Find a good way of setting up keywords etc from properties. 
+            // Code should be shared with material UI code.
+        }
+
+        [Test]
+        public void UpgradeMaterial()
+        {
+            var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
+            var mat = new Material(Shader.Find("Standard (Specular setup)"));
+            var albedo = new Texture2D(1, 1);
+            var normals = new Texture2D(1, 1);
+            var baseScale = new Vector2(1, 1);
+            var color = Color.red;
+            mat.mainTexture = albedo;
+            mat.SetTexture("_BumpMap", normals);
+            mat.color = color;
+            mat.SetTextureScale("_MainTex", baseScale);
+
+            MaterialUpgrader.Upgrade(mat, new StandardSpecularToHDLitMaterialUpgrader(), MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
+
+            Assert.AreEqual(newShader, mat.shader);
+            Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
+            Assert.AreEqual(color, mat.GetColor("_BaseColor"));
+            Assert.AreEqual(baseScale, mat.GetTextureScale("_BaseColorMap"));
+            Assert.AreEqual(normals, mat.GetTexture("_NormalMap"));
+        }
+    }
+}
+

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Editor/StandardSpecularToHDLitMaterialUpgrader.cs.meta

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

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitLegacySupport.shader

+Shader "HDRenderLoop/LitLegacySupport"
+{
+    Properties
+    {
+        // Following set of parameters represent the parameters node inside the MaterialGraph.
+        // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
+
+        // Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear
+        _BaseColor("BaseColor", Color) = (1,1,1,1)
+        _BaseColorMap("BaseColorMap", 2D) = "white" {}
+
+        _Metallic("_Metallic", Range(0.0, 1.0)) = 0
+        _Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
+        _MaskMap("MaskMap", 2D) = "white" {}
+
+        _SpecularOcclusionMap("SpecularOcclusion", 2D) = "white" {}
+
+        _NormalMap("NormalMap", 2D) = "bump" { }
+        [Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0
+
+        _HeightMap("HeightMap", 2D) = "black" {}
+        _HeightScale("Height Scale", Float) = 1
+        _HeightBias("Height Bias", Float) = 0
+        [Enum(Parallax, 0, Displacement, 1)] _HeightMapMode("Heightmap usage", Float) = 0
+
+        _TangentMap("TangentMap", 2D) = "bump" {}
+        _Anisotropy("Anisotropy", Range(0.0, 1.0)) = 0
+        _AnisotropyMap("AnisotropyMap", 2D) = "white" {}
+
+        _DetailMap("DetailMap", 2D) = "black" {}
+        _DetailMask("DetailMask", 2D) = "white" {}
+        _DetailAlbedoScale("_DetailAlbedoScale", Range(-2.0, 2.0)) = 1
+        _DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1
+        _DetailSmoothnessScale("_DetailSmoothnessScale", Range(-2.0, 2.0)) = 1
+        _DetailHeightScale("_DetailHeightScale", Range(-2.0, 2.0)) = 1
+        _DetailAOScale("_DetailAOScale", Range(-2.0, 2.0)) = 1
+        [Enum(UV0, 0, UV1, 1)] _UVDetail("UV Set for detailMap", Float) = 0
+
+        _SubSurfaceRadius("SubSurfaceRadius", Range(0.0, 1.0)) = 0
+        _SubSurfaceRadiusMap("SubSurfaceRadiusMap", 2D) = "white" {}
+        //_Thickness("Thickness", Range(0.0, 1.0)) = 0
+        //_ThicknessMap("ThicknessMap", 2D) = "white" {}
+        //_SubSurfaceProfile("SubSurfaceProfile", Float) = 0
+
+        //_CoatCoverage("CoatCoverage", Range(0.0, 1.0)) = 0
+        //_CoatCoverageMap("CoatCoverageMapMap", 2D) = "white" {}
+
+        //_CoatRoughness("CoatRoughness", Range(0.0, 1.0)) = 0
+        //_CoatRoughnessMap("CoatRoughnessMap", 2D) = "white" {}
+
+        // _DistortionVectorMap("DistortionVectorMap", 2D) = "white" {}
+        // _DistortionBlur("DistortionBlur", Range(0.0, 1.0)) = 0
+
+        // Following options are for the GUI inspector and different from the input parameters above
+        // These option below will cause different compilation flag.
+
+        _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
+        _EmissiveColorMap("EmissiveColorMap", 2D) = "white" {}
+        _EmissiveIntensity("EmissiveIntensity", Float) = 0
+
+        [ToggleOff]     _DistortionOnly("Distortion Only", Float) = 0.0
+        [ToggleOff]     _DistortionDepthTest("Distortion Only", Float) = 0.0
+
+        [ToggleOff]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
+        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        // Blending state
+        [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0
+        [HideInInspector] _BlendMode ("__blendmode", Float) = 0.0
+        [HideInInspector] _SrcBlend ("__src", Float) = 1.0
+        [HideInInspector] _DstBlend ("__dst", Float) = 0.0
+        [HideInInspector] _ZWrite ("__zw", Float) = 1.0
+        [HideInInspector] _CullMode("__cullmode", Float) = 2.0
+        // Material Id
+        [HideInInspector] _MaterialId("_MaterialId", FLoat) = 0
+
+        [Enum(Mask Alpha, 0, BaseColor Alpha, 1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 1
+        [Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1
+        [Enum(None, 0, DoubleSided, 1, DoubleSidedLigthingFlip, 2, DoubleSidedLigthingMirror, 3)] _DoubleSidedMode("Double sided mode", Float) = 0
+        [Enum(DetailMapNormal, 0, DetailMapAOHeight, 1)] _DetailMapMode("DetailMap mode", Float) = 0
+
+
+		// LEGACY SUPPORT
+		_Color("Color", Color) = (1,1,1,1)
+		_MainTex("Albedo", 2D) = "white" {}
+		
+		_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
+		_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
+		[Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0
+
+		//[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
+		_MetallicGlossMap("Metallic", 2D) = "white" {}
+
+		[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
+		[ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
+
+		_BumpScale("Scale", Float) = 1.0
+		_BumpMap("Normal Map", 2D) = "bump" {}
+
+		_Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
+		_ParallaxMap ("Height Map", 2D) = "black" {}
+
+		_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
+		_OcclusionMap("Occlusion", 2D) = "white" {}
+
+		_EmissionColor("Color", Color) = (0,0,0)
+		_EmissionMap("Emission", 2D) = "white" {}
+		
+		//_DetailMask("Detail Mask", 2D) = "white" {}
+
+		_DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
+		_DetailNormalMapScale("Scale", Float) = 1.0
+		_DetailNormalMap("Normal Map", 2D) = "bump" {}
+
+		[Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0
+
+
+		// Blending state
+		[HideInInspector] _Mode ("__mode", Float) = 0.0
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _ZWrite ("__zw", Float) = 1.0
+    }
+
+	CGINCLUDE
+		#define UNITY_SETUP_BRDF_INPUT MetallicSetup
+	ENDCG
+
+    HLSLINCLUDE
+
+    #pragma target 5.0
+    #pragma only_renderers d3d11 // TEMP: unitl we go futher in dev
+
+    //-------------------------------------------------------------------------------------
+    // Variant
+    //-------------------------------------------------------------------------------------
+
+    #pragma shader_feature _ALPHATEST_ON
+    #pragma shader_feature _ _DOUBLESIDED_LIGHTING_FLIP _DOUBLESIDED_LIGHTING_MIRROR
+    #pragma shader_feature _NORMALMAP
+    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
+    #pragma shader_feature _MASKMAP
+    #pragma shader_feature _SPECULAROCCLUSIONMAP
+    #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    #pragma shader_feature _EMISSIVE_COLOR
+    #pragma shader_feature _EMISSIVE_COLOR_MAP
+    #pragma shader_feature _HEIGHTMAP
+    #pragma shader_feature _HEIGHTMAP_AS_DISPLACEMENT
+    #pragma shader_feature _TANGENTMAP
+    #pragma shader_feature _ANISOTROPYMAP
+    #pragma shader_feature _DETAIL_MAP
+    #pragma shader_feature _DETAIL_MAP_WITH_NORMAL
+
+    #pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+    #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED
+    #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+    // TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ?
+    //#pragma multi_compile VELOCITYOUTPUT_OFF VELOCITYOUTPUT_ON 
+
+    //-------------------------------------------------------------------------------------
+    // Define
+    //-------------------------------------------------------------------------------------
+
+    #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+
+    //-------------------------------------------------------------------------------------
+    // Include
+    //-------------------------------------------------------------------------------------
+    
+    #include "common.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Material/Attributes.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderPass/ShaderPass.cs.hlsl"
+
+    //-------------------------------------------------------------------------------------
+    // variable declaration
+    //-------------------------------------------------------------------------------------
+
+    // Set of users variables
+    float4 _BaseColor;
+    TEXTURE2D(_BaseColorMap);
+    SAMPLER2D(sampler_BaseColorMap);
+
+    float _Metallic;
+    float _Smoothness;
+    TEXTURE2D(_MaskMap);
+    SAMPLER2D(sampler_MaskMap);
+    TEXTURE2D(_SpecularOcclusionMap);
+    SAMPLER2D(sampler_SpecularOcclusionMap);
+
+    TEXTURE2D(_NormalMap);
+    SAMPLER2D(sampler_NormalMap);
+
+    TEXTURE2D(_DetailMask);
+    SAMPLER2D(sampler_DetailMask);
+    TEXTURE2D(_DetailMap);
+    SAMPLER2D(sampler_DetailMap);
+    float4  _DetailMap_ST;
+    float _UVDetail;
+    float _DetailAlbedoScale;
+    float _DetailNormalScale;
+    float _DetailSmoothnessScale;
+    float _DetailHeightScale;
+    float _DetailAOScale;
+
+    TEXTURE2D(_HeightMap);
+    SAMPLER2D(sampler_HeightMap);
+
+    float _HeightScale;
+    float _HeightBias;
+
+    TEXTURE2D(_TangentMap);
+    SAMPLER2D(sampler_TangentMap);
+
+    float _Anisotropy;
+    TEXTURE2D(_AnisotropyMap);
+    SAMPLER2D(sampler_AnisotropyMap);
+
+    TEXTURE2D(_DiffuseLightingMap);
+    SAMPLER2D(sampler_DiffuseLightingMap);
+
+    float3 _EmissiveColor;
+    TEXTURE2D(_EmissiveColorMap);
+    SAMPLER2D(sampler_EmissiveColorMap);
+
+    float _EmissiveIntensity;
+
+    float _SubSurfaceRadius;
+    TEXTURE2D(_SubSurfaceRadiusMap);
+    SAMPLER2D(sampler_SubSurfaceRadiusMap);
+
+    // float _Thickness;
+    //TEXTURE2D(_ThicknessMap);
+    //SAMPLER2D(sampler_ThicknessMap);
+
+    // float _CoatCoverage;
+    //TEXTURE2D(_CoatCoverageMap);
+    //SAMPLER2D(sampler_CoatCoverageMap);
+
+    // float _CoatRoughness;
+    //TEXTURE2D(_CoatRoughnessMap);
+    //SAMPLER2D(sampler_CoatRoughnessMap);
+ 
+    float _AlphaCutoff;
+
+    ENDHLSL
+
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+        LOD 300
+
+        Pass
+        {
+            Name "GBuffer"  // Name is not used
+            Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index
+
+            Cull  [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_GBUFFER
+            #include "../../Material/Material.hlsl"
+            #include "LitData.hlsl"
+            #include "LitSharePass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassGBuffer.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "Debug"
+            Tags { "LightMode" = "DebugViewMaterial" }
+
+            Cull[_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEBUG_VIEW_MATERIAL
+            #include "../../Material/Material.hlsl"
+            #include "LitData.hlsl"
+            #include "LitSharePass.hlsl"
+            
+            #include "../../ShaderPass/ShaderPassDebugViewMaterial.hlsl"
+
+            ENDHLSL
+        }
+
+        // Extracts information for lightmapping, GI (emission, albedo, ...)
+        // This pass it not used during regular rendering.
+        Pass
+        {
+            Name "META"
+            Tags{ "LightMode" = "Meta" }
+
+            Cull Off
+
+            HLSLPROGRAM
+
+            // Lightmap memo
+            // DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, 
+            // both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON.
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
+            #include "../../Material/Material.hlsl"
+            #include "LitData.hlsl"
+            #include "LitMetaPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassLightTransport.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "ShadowCaster"
+            Tags{ "LightMode" = "ShadowCaster" }
+
+            Cull[_CullMode]
+
+            ZWrite On ZTest LEqual
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../Material/Material.hlsl"            
+            #include "LitData.hlsl"
+            #include "LitDepthPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "DepthOnly"
+            Tags{ "LightMode" = "DepthOnly" }
+
+            Cull[_CullMode]
+
+            ZWrite On ZTest LEqual
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_DEPTH_ONLY
+            #include "../../Material/Material.hlsl"            
+            #include "LitData.hlsl"
+            #include "LitDepthPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassDepthOnly.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "Motion Vectors"
+            Tags{ "LightMode" = "MotionVectors" } // Caution, this need to be call like this to setup the correct parameters by C++ (legacy Unity)
+
+            Cull[_CullMode]
+
+            ZTest LEqual
+            ZWrite Off // TODO: Test Z equal here.
+
+            HLSLPROGRAM
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_VELOCITY
+            #include "../../Material/Material.hlsl"         
+            #include "LitData.hlsl"
+            #include "LitVelocityPass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassVelocity.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "Forward" // Name is not used
+            Tags { "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index
+
+            Blend [_SrcBlend] [_DstBlend]
+            ZWrite [_ZWrite]
+            Cull [_CullMode]
+
+            HLSLPROGRAM
+
+            #pragma vertex VertDefault
+            #pragma fragment Frag
+
+            #define SHADERPASS SHADERPASS_FORWARD
+            // TEMP until pragma work in include
+            // #include "../../Lighting/Forward.hlsl"
+            #pragma multi_compile LIGHTLOOP_SINGLE_PASS
+            //#pragma multi_compile SHADOWFILTERING_FIXED_SIZE_PCF
+
+            #include "../../Lighting/Lighting.hlsl"
+            #include "LitData.hlsl"
+            #include "LitSharePass.hlsl"
+
+            #include "../../ShaderPass/ShaderPassForward.hlsl"
+
+            ENDHLSL
+        }
+	}
+
+	SubShader
+	{
+		Tags{ "RenderType" = "Opaque" "PerformanceChecks" = "False" }
+		LOD 150
+
+		// ------------------------------------------------------------------
+		//  Base forward pass (directional light, emission, lightmaps, ...)
+		Pass
+		{
+			Name "FORWARD"
+			Tags{ "LightMode" = "ForwardBase" }
+
+			Blend[_SrcBlend][_DstBlend]
+			ZWrite[_ZWrite]
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdbase
+			#pragma multi_compile_fog
+
+			#pragma vertex vertBase
+			#pragma fragment fragBase
+
+			#include "PatchStandardShaderToNewNamingConvention.cginc"
+			#include "../Legacy/UnityStandardCoreForward.cginc"
+
+			ENDCG
+		}
+
+		// ------------------------------------------------------------------
+		//  Additive forward pass (one light per pass)
+		Pass
+		{
+			Name "FORWARD_DELTA"
+			Tags { "LightMode" = "ForwardAdd" }
+			Blend [_SrcBlend] One
+			Fog { Color (0,0,0,0) } // in additive pass fog should be black
+			ZWrite Off
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdadd_fullshadows
+			#pragma multi_compile_fog
+
+
+			#pragma vertex vertAdd
+			#pragma fragment fragAdd
+
+			#include "PatchStandardShaderToNewNamingConvention.cginc"
+			#include "../Legacy/UnityStandardCoreForward.cginc"
+
+			ENDCG
+		}
+
+		// ------------------------------------------------------------------
+		//  Shadow rendering pass
+		Pass {
+			Name "ShadowCaster"
+			Tags { "LightMode" = "ShadowCaster" }
+
+			ZWrite On ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _PARALLAXMAP
+			#pragma multi_compile_shadowcaster
+
+			#pragma vertex vertShadowCaster
+			#pragma fragment fragShadowCaster
+
+			#include "PatchStandardShaderToNewNamingConvention.cginc"
+			#include "../Legacy/UnityStandardShadow.cginc"
+
+			ENDCG
+		}
+    }
+
+    CustomEditor "LitGUI"
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/LitLegacySupport.shader.meta

+fileFormatVersion: 2
+guid: 906fa6b9787318e478cbaeed40f42313
+timeCreated: 1479905674
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc

+// NOTE: For performing a project upgrade where you temporarily support both old and new renderloops
+//       in the same sahder
+// 
+// The basic approach is:
+// Upgrade all your shaders to the new naming convention, using a SubShader that also contains the legacy // renderloop code.
+//             
+// 1. Copy HDRenderloop Lit.shader into your project
+// 2. Add a SubShader and copy old Standard shader passes into it.
+// 2. Set LOD on subshader to make Unity pick at runtime to use new renderloop shaders or 
+// legacy standard shaders based on if SRL is enabled or not.
+// In the legacy standard shader section add
+// #include "PatchStandardShaderToNewNamingConvention.cginc"
+
+// List of name remaps
+#define _MainTex _BaseColorMap 
+#define _MainTex_ST _BaseColorMap_ST
+#define _BumpMap _NormalMap
+#define _ParallaxMap _HeightMap
+#define _Parallax _HeightScale
+#define _Glossiness _Smoothness

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/PatchStandardShaderToNewNamingConvention.cginc.meta

+fileFormatVersion: 2
+guid: a9b4e2b7ef9a45f49834b052e7722acb
+timeCreated: 1480085057
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/AutoLight.cginc

+#ifndef AUTOLIGHT_INCLUDED
+#define AUTOLIGHT_INCLUDED
+
+#include "HLSLSupport.cginc"
+#include "UnityShadowLibrary.cginc"
+
+#define unityShadowCoord float
+#define unityShadowCoord2 float2
+#define unityShadowCoord3 float3
+#define unityShadowCoord4 float4
+#define unityShadowCoord4x4 float4x4
+
+// ----------------
+//  Shadow helpers
+// ----------------
+
+// ---- Screen space shadows
+#if defined (SHADOWS_SCREEN)
+
+
+#define SHADOW_COORDS(idx1) unityShadowCoord4 _ShadowCoord : TEXCOORD##idx1;
+
+#if defined(UNITY_NO_SCREENSPACE_SHADOWS)
+
+UNITY_DECLARE_SHADOWMAP(_ShadowMapTexture);
+#define TRANSFER_SHADOW(a) a._ShadowCoord = mul( unity_WorldToShadow[0], mul( unity_ObjectToWorld, v.vertex ) );
+
+inline fixed unitySampleShadow (unityShadowCoord4 shadowCoord)
+{
+	#if defined(SHADOWS_NATIVE)
+
+	fixed shadow = UNITY_SAMPLE_SHADOW(_ShadowMapTexture, shadowCoord.xyz);
+	shadow = _LightShadowData.r + shadow * (1-_LightShadowData.r);
+	return shadow;
+
+	#else
+
+	unityShadowCoord dist = SAMPLE_DEPTH_TEXTURE(_ShadowMapTexture, shadowCoord.xy);
+
+	// tegra is confused if we use _LightShadowData.x directly
+	// with "ambiguous overloaded function reference max(mediump float, float)"
+	unityShadowCoord lightShadowDataX = _LightShadowData.x;
+	unityShadowCoord threshold = shadowCoord.z;
+	return max(dist > threshold, lightShadowDataX);
+
+	#endif
+}
+
+#else // UNITY_NO_SCREENSPACE_SHADOWS
+
+UNITY_DECLARE_SCREENSPACE_SHADOWMAP(_ShadowMapTexture);
+
+#define TRANSFER_SHADOW(a) a._ShadowCoord = ComputeScreenPos(a.pos);
+
+inline fixed unitySampleShadow (unityShadowCoord4 shadowCoord)
+{
+	fixed shadow = UNITY_SAMPLE_SCREEN_SHADOW(_ShadowMapTexture, shadowCoord);
+	return shadow;
+}
+
+#endif
+
+#define SHADOW_ATTENUATION(a) unitySampleShadow(a._ShadowCoord)
+
+#endif
+
+
+// ---- Spot light shadows
+#if defined (SHADOWS_DEPTH) && defined (SPOT)
+	#define SHADOW_COORDS(idx1) unityShadowCoord4 _ShadowCoord : TEXCOORD##idx1;
+	#define TRANSFER_SHADOW(a) a._ShadowCoord = mul (unity_WorldToShadow[0], mul(unity_ObjectToWorld,v.vertex));
+	#define SHADOW_ATTENUATION(a) UnitySampleShadowmap(a._ShadowCoord)
+#endif
+
+
+// ---- Point light shadows
+#if defined (SHADOWS_CUBE)
+	#define SHADOW_COORDS(idx1) unityShadowCoord3 _ShadowCoord : TEXCOORD##idx1;
+	#define TRANSFER_SHADOW(a) a._ShadowCoord = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz;
+	#define SHADOW_ATTENUATION(a) UnitySampleShadowmap(a._ShadowCoord)
+#endif
+
+// ---- Shadows off
+#if !defined (SHADOWS_SCREEN) && !defined (SHADOWS_DEPTH) && !defined (SHADOWS_CUBE)
+	#define SHADOW_COORDS(idx1)
+	#define TRANSFER_SHADOW(a)
+	#define SHADOW_ATTENUATION(a) 1.0
+#endif
+
+
+// ------------------------------
+//  Light helpers (5.0+ version)
+// ------------------------------
+
+// This version depends on having worldPos available in the fragment shader and using that to compute light coordinates.
+
+// If none of the keywords are defined, assume directional?
+#if !defined(POINT) && !defined(SPOT) && !defined(DIRECTIONAL) && !defined(POINT_COOKIE) && !defined(DIRECTIONAL_COOKIE)
+#define DIRECTIONAL
+#endif
+
+
+#ifdef POINT
+sampler2D _LightTexture0;
+unityShadowCoord4x4 unity_WorldToLight;
+#define UNITY_LIGHT_ATTENUATION(destName, input, worldPos) \
+	unityShadowCoord3 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)).xyz; \
+	fixed destName = (tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL * SHADOW_ATTENUATION(input));
+#endif
+
+#ifdef SPOT
+sampler2D _LightTexture0;
+unityShadowCoord4x4 unity_WorldToLight;
+sampler2D _LightTextureB0;
+inline fixed UnitySpotCookie(unityShadowCoord4 LightCoord)
+{
+	return tex2D(_LightTexture0, LightCoord.xy / LightCoord.w + 0.5).w;
+}
+inline fixed UnitySpotAttenuate(unityShadowCoord3 LightCoord)
+{
+	return tex2D(_LightTextureB0, dot(LightCoord, LightCoord).xx).UNITY_ATTEN_CHANNEL;
+}
+#define UNITY_LIGHT_ATTENUATION(destName, input, worldPos) \
+	unityShadowCoord4 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)); \
+	fixed destName = (lightCoord.z > 0) * UnitySpotCookie(lightCoord) * UnitySpotAttenuate(lightCoord.xyz) * SHADOW_ATTENUATION(input);
+#endif
+
+
+#ifdef DIRECTIONAL
+	#define UNITY_LIGHT_ATTENUATION(destName, input, worldPos)	fixed destName = SHADOW_ATTENUATION(input);
+#endif
+
+
+#ifdef POINT_COOKIE
+samplerCUBE _LightTexture0;
+unityShadowCoord4x4 unity_WorldToLight;
+sampler2D _LightTextureB0;
+#define UNITY_LIGHT_ATTENUATION(destName, input, worldPos) \
+	unityShadowCoord3 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)).xyz; \
+	fixed destName = tex2D(_LightTextureB0, dot(lightCoord, lightCoord).rr).UNITY_ATTEN_CHANNEL * texCUBE(_LightTexture0, lightCoord).w * SHADOW_ATTENUATION(input);
+#endif
+
+#ifdef DIRECTIONAL_COOKIE
+sampler2D _LightTexture0;
+unityShadowCoord4x4 unity_WorldToLight;
+#define UNITY_LIGHT_ATTENUATION(destName, input, worldPos) \
+	unityShadowCoord2 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)).xy; \
+	fixed destName = tex2D(_LightTexture0, lightCoord).w * SHADOW_ATTENUATION(input);
+#endif
+
+
+// -----------------------------
+//  Light helpers (4.x version)
+// -----------------------------
+
+// This version computes light coordinates in the vertex shader and passes them to the fragment shader.
+
+#ifdef POINT
+#define LIGHTING_COORDS(idx1,idx2) unityShadowCoord3 _LightCoord : TEXCOORD##idx1; SHADOW_COORDS(idx2)
+#define TRANSFER_VERTEX_TO_FRAGMENT(a) a._LightCoord = mul(unity_WorldToLight, mul(unity_ObjectToWorld, v.vertex)).xyz; TRANSFER_SHADOW(a)
+#define LIGHT_ATTENUATION(a)	(tex2D(_LightTexture0, dot(a._LightCoord,a._LightCoord).rr).UNITY_ATTEN_CHANNEL * SHADOW_ATTENUATION(a))
+#endif
+
+#ifdef SPOT
+#define LIGHTING_COORDS(idx1,idx2) unityShadowCoord4 _LightCoord : TEXCOORD##idx1; SHADOW_COORDS(idx2)
+#define TRANSFER_VERTEX_TO_FRAGMENT(a) a._LightCoord = mul(unity_WorldToLight, mul(unity_ObjectToWorld, v.vertex)); TRANSFER_SHADOW(a)
+#define LIGHT_ATTENUATION(a)	( (a._LightCoord.z > 0) * UnitySpotCookie(a._LightCoord) * UnitySpotAttenuate(a._LightCoord.xyz) * SHADOW_ATTENUATION(a) )
+#endif
+
+#ifdef DIRECTIONAL
+	#define LIGHTING_COORDS(idx1,idx2) SHADOW_COORDS(idx1)
+	#define TRANSFER_VERTEX_TO_FRAGMENT(a) TRANSFER_SHADOW(a)
+	#define LIGHT_ATTENUATION(a)	SHADOW_ATTENUATION(a)
+#endif
+
+#ifdef POINT_COOKIE
+#define LIGHTING_COORDS(idx1,idx2) unityShadowCoord3 _LightCoord : TEXCOORD##idx1; SHADOW_COORDS(idx2)
+#define TRANSFER_VERTEX_TO_FRAGMENT(a) a._LightCoord = mul(unity_WorldToLight, mul(unity_ObjectToWorld, v.vertex)).xyz; TRANSFER_SHADOW(a)
+#define LIGHT_ATTENUATION(a)	(tex2D(_LightTextureB0, dot(a._LightCoord,a._LightCoord).rr).UNITY_ATTEN_CHANNEL * texCUBE(_LightTexture0, a._LightCoord).w * SHADOW_ATTENUATION(a))
+#endif
+
+#ifdef DIRECTIONAL_COOKIE
+#define LIGHTING_COORDS(idx1,idx2) unityShadowCoord2 _LightCoord : TEXCOORD##idx1; SHADOW_COORDS(idx2)
+#define TRANSFER_VERTEX_TO_FRAGMENT(a) a._LightCoord = mul(unity_WorldToLight, mul(unity_ObjectToWorld, v.vertex)).xy; TRANSFER_SHADOW(a)
+#define LIGHT_ATTENUATION(a)	(tex2D(_LightTexture0, a._LightCoord).w * SHADOW_ATTENUATION(a))
+#endif
+
+
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/AutoLight.cginc.meta

+fileFormatVersion: 2
+guid: 799500dcef64b1544b4a392c4b239709
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/HLSLSupport.cginc

+#ifndef HLSL_SUPPORT_INCLUDED
+#define HLSL_SUPPORT_INCLUDED
+
+// Define the underlying compiler being used. Skips this step if the compiler is already specified,
+// which may happen during development of new shader compiler for certain platform
+#if !defined(UNITY_COMPILER_CG) && !defined(UNITY_COMPILER_HLSL) && !defined(UNITY_COMPILER_HLSL2GLSL) && !defined(UNITY_COMPILER_HLSLCC)
+	#if defined(SHADER_TARGET_SURFACE_ANALYSIS)
+		// Cg is used for surface shader analysis step
+		#define UNITY_COMPILER_CG
+	#elif defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN)
+		// N.B. For Metal, the correct flags are set during internal shader compiler setup
+		#define UNITY_COMPILER_HLSL
+		#define UNITY_COMPILER_HLSLCC
+	#elif defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_D3D9) || defined(SHADER_API_XBOXONE)
+		#define UNITY_COMPILER_HLSL
+	#elif defined(SHADER_TARGET_GLSL) || defined(SHADER_API_WIIU)
+		#define UNITY_COMPILER_HLSL2GLSL
+	#else
+		#define UNITY_COMPILER_CG
+	#endif
+#endif
+
+#if defined(UNITY_FRAMEBUFFER_FETCH_AVAILABLE) && defined(UNITY_FRAMEBUFFER_FETCH_ENABLED) && defined(UNITY_COMPILER_HLSLCC)
+// In the fragment shader, setting inout <type> var : SV_Target would result to
+// compiler error, unless SV_Target is defined to COLOR semantic for compatibility
+// reasons. Unfortunately, we still need to have a clear distinction between
+// vertex shader COLOR output and SV_Target, so the following workaround abuses
+// the fact that semantic names are case insensitive and preprocessor macros
+// are not. The resulting HLSL bytecode has semantics in case preserving form,
+// helps code generator to do extra work required for framebuffer fetch
+
+// You should always declare color inouts against SV_Target
+#define SV_Target CoLoR
+#define SV_Target0 CoLoR0
+#define SV_Target1 CoLoR1
+#define SV_Target2 CoLoR2
+#define SV_Target3 CoLoR3
+
+#define COLOR VCOLOR
+#define COLOR0 VCOLOR0
+#define COLOR1 VCOLOR1
+#define COLOR2 VCOLOR2
+#define COLOR3 VCOLOR3
+#endif
+
+// SV_Target[n] / SV_Depth defines, if not defined by compiler already
+#if !defined(SV_Target)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Target COLOR
+#	endif
+#endif
+#if !defined(SV_Target0)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Target0 COLOR0
+#	endif
+#endif
+#if !defined(SV_Target1)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Target1 COLOR1
+#	endif
+#endif
+#if !defined(SV_Target2)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Target2 COLOR2
+#	endif
+#endif
+#if !defined(SV_Target3)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Target3 COLOR3
+#	endif
+#endif
+#if !defined(SV_Depth)
+#	if !defined(SHADER_API_XBOXONE)
+#		define SV_Depth DEPTH
+#	endif
+#endif
+
+
+// Disable warnings we aren't interested in
+#if defined(UNITY_COMPILER_HLSL)
+#pragma warning (disable : 3205) // conversion of larger type to smaller
+#pragma warning (disable : 3568) // unknown pragma ignored
+#pragma warning (disable : 3571) // "pow(f,e) will not work for negative f"; however in majority of our calls to pow we know f is not negative
+#pragma warning (disable : 3206) // implicit truncation of vector type
+#endif
+
+
+// Define "fixed" precision to be half on non-GLSL platforms,
+// and sampler*_prec to be just simple samplers.
+#if !defined(SHADER_TARGET_GLSL) && !defined(SHADER_API_PSSL) && !defined(SHADER_API_GLES3) && !defined(SHADER_API_VULKAN) && !(defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
+#define fixed half
+#define fixed2 half2
+#define fixed3 half3
+#define fixed4 half4
+#define fixed4x4 half4x4
+#define fixed3x3 half3x3
+#define fixed2x2 half2x2
+#define sampler2D_half sampler2D
+#define sampler2D_float sampler2D
+#define samplerCUBE_half samplerCUBE
+#define samplerCUBE_float samplerCUBE
+#endif
+
+#if defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || (defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
+// GLES3 and later via HLSLcc, use DX11.1 partial precision for translation
+// we specifically define fixed to be float16 (same as half) as all new GPUs seems to agree on float16 being minimal precision float
+#define fixed min16float
+#define fixed2 min16float2
+#define fixed3 min16float3
+#define fixed4 min16float4
+#define fixed4x4 min16float4x4
+#define fixed3x3 min16float3x3
+#define fixed2x2 min16float2x2
+#define half min16float
+#define half2 min16float2
+#define half3 min16float3
+#define half4 min16float4
+#define half2x2 min16float2x2
+#define half3x3 min16float3x3
+#define half4x4 min16float4x4
+#endif // defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN)
+
+
+// Define min16float/min10float to be half/fixed on non-D3D11 platforms.
+// This allows people to use min16float and friends in their shader code if they
+// really want to (making that will make shaders not load before DX11.1, e.g. on Win7,
+// but if they target WSA/WP exclusively that's fine).
+#if !defined(SHADER_API_D3D11) && !defined(SHADER_API_D3D11_9X) && !defined(SHADER_API_GLES3) && !defined(SHADER_API_VULKAN) && !(defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
+#define min16float half
+#define min16float2 half2
+#define min16float3 half3
+#define min16float4 half4
+#define min10float fixed
+#define min10float2 fixed2
+#define min10float3 fixed3
+#define min10float4 fixed4
+#endif
+
+#if defined(SHADER_API_PSP2)
+// The PSP2 cg compiler does not define uint<N>
+#define uint2 unsigned int2
+#define uint3 unsigned int3
+#define uint4 unsigned int4
+#endif
+
+// specifically for samplers that are provided as arguments to entry functions
+#if defined(SHADER_API_PSSL)
+#define SAMPLER_UNIFORM uniform
+#define SHADER_UNIFORM 
+#else
+#define SAMPLER_UNIFORM
+#endif
+
+#if defined(SHADER_API_PSSL)
+#define CBUFFER_START(name) ConstantBuffer name {
+#define CBUFFER_END };
+#elif defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X)
+#define CBUFFER_START(name) cbuffer name {
+#define CBUFFER_END };
+#else
+// On specific platforms, like OpenGL and GLES3, constant buffers may still be used for instancing
+#define CBUFFER_START(name)
+#define CBUFFER_END
+#endif
+
+
+#if defined(SHADER_API_PSP2)
+	// For tex2Dproj the PSP2 cg compiler doesn't like casting half3/4 to
+	// float3/4 with swizzle (optimizer generates invalid assembly), so declare
+	// explicit versions for half3/4
+	half4 tex2Dproj(sampler2D s, in half3 t)		{ return tex2D(s, t.xy / t.z); }
+	half4 tex2Dproj(sampler2D s, in half4 t)		{ return tex2D(s, t.xy / t.w); }
+
+	// As above but for sampling from single component textures, e.g. depth textures.
+	// NOTE that hardware PCF does not work with these versions, currently we have to ensure
+	// that tex coords for shadow sampling use float, not half; and for some reason casting half
+	// to float and using tex2Dproj also does not work.
+	half4 tex2DprojShadow(sampler2D s, in half3 t)		{ return tex2D<float>(s, t.xy / t.z); }
+	half4 tex2DprojShadow(sampler2D s, in half4 t)		{ return tex2D<float>(s, t.xy / t.w); }
+
+	// ...and versions of tex2DprojShadow for float uv.
+	half4 tex2DprojShadow(sampler2D s, in float3 t)		{ return tex2Dproj<float>(s, t); }
+	half4 tex2DprojShadow(sampler2D s, in float4 t)		{ return tex2Dproj<float>(s, t); }
+#endif
+
+
+#if defined(SHADER_API_PSP2)
+#define UNITY_BUGGY_TEX2DPROJ4
+#define UNITY_PROJ_COORD(a) (a).xyw
+#else
+#define UNITY_PROJ_COORD(a) a
+#endif
+
+
+// Depth texture sampling helpers.
+// On most platforms you can just sample them, but some (e.g. PSP2) need special handling.
+//
+// SAMPLE_DEPTH_TEXTURE(sampler,uv): returns scalar depth
+// SAMPLE_DEPTH_TEXTURE_PROJ(sampler,uv): projected sample
+// SAMPLE_DEPTH_TEXTURE_LOD(sampler,uv): sample with LOD level
+
+#if defined(SHADER_API_PSP2) && !defined(SHADER_API_PSM)
+#	define SAMPLE_DEPTH_TEXTURE(sampler, uv) (tex2D<float>(sampler, uv))
+#	define SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2DprojShadow(sampler, uv))
+#	define SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod<float>(sampler, uv))
+#	define SAMPLE_RAW_DEPTH_TEXTURE(sampler, uv) SAMPLE_DEPTH_TEXTURE(sampler, uv)
+#	define SAMPLE_RAW_DEPTH_TEXTURE_PROJ(sampler, uv) SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv)
+#	define SAMPLE_RAW_DEPTH_TEXTURE_LOD(sampler, uv) SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv)
+#else
+	// Sample depth, just the red component.
+#	define SAMPLE_DEPTH_TEXTURE(sampler, uv) (tex2D(sampler, uv).r)
+#	define SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2Dproj(sampler, uv).r)
+#	define SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod(sampler, uv).r)
+	// Sample depth, all components.
+#	define SAMPLE_RAW_DEPTH_TEXTURE(sampler, uv) (tex2D(sampler, uv))
+#	define SAMPLE_RAW_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2Dproj(sampler, uv))
+#	define SAMPLE_RAW_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod(sampler, uv))
+#endif
+
+// Deprecated; use SAMPLE_DEPTH_TEXTURE & SAMPLE_DEPTH_TEXTURE_PROJ instead
+#if defined(SHADER_API_PSP2)
+#	define UNITY_SAMPLE_DEPTH(value) (value).r
+#else
+#	define UNITY_SAMPLE_DEPTH(value) (value).r
+#endif
+
+
+// Macros to declare and sample shadow maps.
+//
+// UNITY_DECLARE_SHADOWMAP declares a shadowmap.
+// UNITY_SAMPLE_SHADOW samples with a float3 coordinate (UV in xy, Z in z) and returns 0..1 scalar result.
+// UNITY_SAMPLE_SHADOW_PROJ samples with a projected coordinate (UV and Z divided by w).
+
+
+#if !defined(SHADER_API_GLES)
+	// all platforms except GLES2.0 have built-in shadow comparison samplers
+	#define SHADOWS_NATIVE
+#elif defined(SHADER_API_GLES) && defined(UNITY_ENABLE_NATIVE_SHADOW_LOOKUPS)
+	// GLES2.0 also has built-in shadow comparison samplers, but only on platforms where we pass UNITY_ENABLE_NATIVE_SHADOW_LOOKUPS from the editor
+	#define SHADOWS_NATIVE
+#endif
+
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(UNITY_COMPILER_HLSLCC)
+	// DX11 & hlslcc platforms: built-in PCF
+	#if defined(SHADER_API_D3D11_9X)
+		// FL9.x has some bug where the runtime really wants resource & sampler to be bound to the same slot,
+		// otherwise it is skipping draw calls that use shadowmap sampling. Let's bind to #15
+		// and hope all works out.
+		#define UNITY_DECLARE_SHADOWMAP(tex) Texture2D tex : register(t15); SamplerComparisonState sampler##tex : register(s15)
+	#else
+		#define UNITY_DECLARE_SHADOWMAP(tex) Texture2D tex; SamplerComparisonState sampler##tex
+	#endif
+	#define UNITY_SAMPLE_SHADOW(tex,coord) tex.SampleCmpLevelZero (sampler##tex,(coord).xy,(coord).z)
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex.SampleCmpLevelZero (sampler##tex,(coord).xy/(coord).w,(coord).z/(coord).w)
+#elif defined(UNITY_COMPILER_HLSL2GLSL) && defined(SHADOWS_NATIVE)
+	// OpenGL-like hlsl2glsl platforms: most of them always have built-in PCF
+	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2DShadow tex
+	#define UNITY_SAMPLE_SHADOW(tex,coord) shadow2D (tex,(coord).xyz)
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) shadow2Dproj (tex,coord)
+#elif defined(SHADER_API_D3D9)
+	// D3D9: Native shadow maps FOURCC "driver hack", looks just like a regular
+	// texture sample. Have to always do a projected sample
+	// so that HLSL compiler doesn't try to be too smart and mess up swizzles
+	// (thinking that Z is unused).
+	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D tex
+	#define UNITY_SAMPLE_SHADOW(tex,coord) tex2Dproj (tex,float4((coord).xyz,1)).r
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex2Dproj (tex,coord).r
+#elif defined(SHADER_API_PSSL)
+	// PS4: built-in PCF
+	#define UNITY_DECLARE_SHADOWMAP(tex)		Texture2D tex; SamplerComparisonState sampler##tex
+	#define UNITY_SAMPLE_SHADOW(tex,coord)		tex.SampleCmpLOD0(sampler##tex,(coord).xy,(coord).z)
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord)	tex.SampleCmpLOD0(sampler##tex,(coord).xy/(coord).w,(coord).z/(coord).w)
+#elif defined(SHADER_API_PSP2)
+	// Vita
+	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D tex
+	// tex2d shadow comparison on Vita returns 0 instead of 1 when shadowCoord.z >= 1 causing artefacts in some tests.
+	// Clamping Z to the range 0.0 <= Z < 1.0 solves this.
+	#define UNITY_SAMPLE_SHADOW(tex,coord) tex2D<float>(tex, float3((coord).xy, clamp((coord).z, 0.0, 0.999999)))
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex2DprojShadow(tex, coord)
+#else
+	// Fallback / No built-in shadowmap comparison sampling: regular texture sample and do manual depth comparison
+	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D_float tex
+	#define UNITY_SAMPLE_SHADOW(tex,coord) ((SAMPLE_DEPTH_TEXTURE(tex,(coord).xy) < (coord).z) ? 0.0 : 1.0)
+	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) ((SAMPLE_DEPTH_TEXTURE_PROJ(tex,UNITY_PROJ_COORD(coord)) < ((coord).z/(coord).w)) ? 0.0 : 1.0)
+#endif
+
+
+// Macros to declare textures and samplers, possibly separately. For platforms
+// that have separate samplers & textures (like DX11), and we'd want to conserve
+// the samplers.
+//	- UNITY_DECLARE_TEX*_NOSAMPLER declares a texture, without a sampler.
+//	- UNITY_SAMPLE_TEX*_SAMPLER samples a texture, using sampler from another texture.
+//		That another texture must also be actually used in the current shader, otherwise
+//		the correct sampler will not be set.
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC)
+	// DX11 style HLSL syntax; separate textures and samplers
+	// NB for HLSLcc we have special unity-specific syntax to pass sampler precision information
+
+	// 2D textures
+	#define UNITY_DECLARE_TEX2D(tex) Texture2D tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER(tex) Texture2D tex
+	#define UNITY_SAMPLE_TEX2D(tex,coord) tex.Sample (sampler##tex,coord)
+	#define UNITY_SAMPLE_TEX2D_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+
+#if defined(UNITY_COMPILER_HLSLCC) && !defined(SHADER_API_GLCORE) // GL Core doesn't have the _half mangling, the rest of them do.
+	#define UNITY_DECLARE_TEX2D_HALF(tex) Texture2D_half tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2D_FLOAT(tex) Texture2D_float tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) Texture2D_half tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) Texture2D_float tex
+#else
+	#define UNITY_DECLARE_TEX2D_HALF(tex) Texture2D tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2D_FLOAT(tex) Texture2D tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) Texture2D tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) Texture2D tex
+#endif
+
+	// Cubemaps
+	#define UNITY_DECLARE_TEXCUBE(tex) TextureCube tex; SamplerState sampler##tex
+	#define UNITY_ARGS_TEXCUBE(tex) TextureCube tex, SamplerState sampler##tex
+	#define UNITY_PASS_TEXCUBE(tex) tex, sampler##tex
+	#define UNITY_PASS_TEXCUBE_SAMPLER(tex,samplertex) tex, sampler##samplertex
+	#define UNITY_PASS_TEXCUBE_SAMPLER_LOD(tex, samplertex, lod) tex, sampler##samplertex, lod
+	#define UNITY_DECLARE_TEXCUBE_NOSAMPLER(tex) TextureCube tex
+	#define UNITY_SAMPLE_TEXCUBE(tex,coord) tex.Sample (sampler##tex,coord)
+	#define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
+	#define UNITY_SAMPLE_TEXCUBE_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+	#define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex, samplertex, coord, lod) tex.SampleLevel (sampler##samplertex, coord, lod)
+	// 3D textures
+	#define UNITY_DECLARE_TEX3D(tex) Texture3D tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX3D_NOSAMPLER(tex) Texture3D tex
+	#define UNITY_SAMPLE_TEX3D(tex,coord) tex.Sample (sampler##tex,coord)
+	#define UNITY_SAMPLE_TEX3D_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
+	#define UNITY_SAMPLE_TEX3D_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+	#define UNITY_SAMPLE_TEX3D_SAMPLER_LOD(tex, samplertex, coord, lod) tex.SampleLevel(sampler##samplertex, coord, lod)
+
+	// 2D arrays
+	#define UNITY_DECLARE_TEX2DARRAY(tex) Texture2DArray tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) Texture2DArray tex
+	#define UNITY_ARGS_TEX2DARRAY(tex) Texture2DArray tex, SamplerState sampler##tex
+	#define UNITY_PASS_TEX2DARRAY(tex) tex, sampler##tex
+	#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) tex.Sample (sampler##tex,coord)
+	#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
+	#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+	#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,coord,lod)
+	
+	// Cube arrays
+	#define UNITY_DECLARE_TEXCUBEARRAY(tex) TextureCubeArray tex; SamplerState sampler##tex
+	#define UNITY_DECLARE_TEXCUBEARRAY_NOSAMPLER(tex) TextureCubeArray tex
+	#define UNITY_ARGS_TEXCUBEARRAY(tex) TextureCubeArray tex, SamplerState sampler##tex
+	#define UNITY_PASS_TEXCUBEARRAY(tex) tex, sampler##tex
+	#define UNITY_SAMPLE_TEXCUBEARRAY(tex,coord) tex.Sample (sampler##tex,coord)
+	#define UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
+	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,coord,lod)
+
+	
+#else
+	// DX9 style HLSL syntax; same object for texture+sampler
+	// 2D textures
+	#define UNITY_DECLARE_TEX2D(tex) sampler2D tex
+	#define UNITY_DECLARE_TEX2D_HALF(tex) sampler2D_half tex
+	#define UNITY_DECLARE_TEX2D_FLOAT(tex) sampler2D_float tex
+
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER(tex) sampler2D tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) sampler2D_half tex
+	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) sampler2D_float tex
+
+	#define UNITY_SAMPLE_TEX2D(tex,coord) tex2D (tex,coord)
+	#define UNITY_SAMPLE_TEX2D_SAMPLER(tex,samplertex,coord) tex2D (tex,coord)
+	// Cubemaps
+	#define UNITY_DECLARE_TEXCUBE(tex) samplerCUBE tex
+	#define UNITY_ARGS_TEXCUBE(tex) samplerCUBE tex
+	#define UNITY_PASS_TEXCUBE(tex) tex
+	#define UNITY_PASS_TEXCUBE_SAMPLER(tex,samplertex) tex
+	#define UNITY_DECLARE_TEXCUBE_NOSAMPLER(tex) samplerCUBE tex
+	#define UNITY_SAMPLE_TEXCUBE(tex,coord) texCUBE (tex,coord)
+
+	// DX9 with SM2.0, and DX11 FL 9.x do not have texture LOD sampling.
+	// We will approximate that with mip bias (very poor approximation, but not much we can do)
+	#if ((SHADER_TARGET < 25) && defined(SHADER_API_D3D9)) || defined(SHADER_API_D3D11_9X)
+	#	define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) texCUBEbias(tex, half4(coord, lod))
+	#	define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex,samplertex,coord,lod) UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod)
+	#else
+	#	define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) texCUBElod (tex, half4(coord, lod))
+	#	define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex,samplertex,coord,lod) UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod)
+	#endif
+	#define UNITY_SAMPLE_TEXCUBE_SAMPLER(tex,samplertex,coord) texCUBE (tex,coord)
+
+	// 3D textures
+	#define UNITY_DECLARE_TEX3D(tex) sampler3D tex
+	#define UNITY_DECLARE_TEX3D_NOSAMPLER(tex) sampler3D tex
+	#define UNITY_SAMPLE_TEX3D(tex,coord) tex3D (tex,coord)
+	#define UNITY_SAMPLE_TEX3D_LOD(tex,coord,lod) tex3D (tex,float4(coord,lod))
+	#define UNITY_SAMPLE_TEX3D_SAMPLER(tex,samplertex,coord) tex3D (tex,coord)
+	#define UNITY_SAMPLE_TEX3D_SAMPLER_LOD(tex,samplertex,coord,lod) tex3D (tex,float4(coord,lod))
+
+	// 2D array syntax for hlsl2glsl and surface shader analysis
+	#if defined(UNITY_COMPILER_HLSL2GLSL) || defined(SHADER_TARGET_SURFACE_ANALYSIS)
+		#define UNITY_DECLARE_TEX2DARRAY(tex) sampler2DArray tex
+		#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) sampler2DArray tex
+		#define UNITY_ARGS_TEX2DARRAY(tex) sampler2DArray tex
+		#define UNITY_PASS_TEX2DARRAY(tex) tex
+		#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) tex2DArray (tex,coord)
+		#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) tex2DArraylod (tex, float4(coord,lod))
+		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER(tex,samplertex,coord) tex2DArray (tex,coord)
+		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex2DArraylod (tex, float4(coord,lod))
+	#endif
+	// 2D/Cube array syntax for PS4
+	#if defined(SHADER_API_PSSL)
+		// 2D arrays
+		#define UNITY_DECLARE_TEX2DARRAY(tex) Texture2D_Array tex; SamplerState sampler##tex
+		#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) Texture2D_Array tex
+		#define UNITY_ARGS_TEX2DARRAY(tex) Texture2D_Array tex, SamplerState sampler##tex
+		#define UNITY_PASS_TEX2DARRAY(tex) tex, sampler##tex
+		#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) tex.Sample (sampler##tex,coord)
+		#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
+		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
+		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,coord,lod)		
+		// Cube arrays
+		#define UNITY_DECLARE_TEXCUBEARRAY(tex) TextureCube_Array tex; SamplerState sampler##tex
+		#define UNITY_DECLARE_TEXCUBEARRAY_NOSAMPLER(tex) TextureCube_Array tex
+		#define UNITY_ARGS_TEXCUBEARRAY(tex) TextureCube_Array tex, SamplerState sampler##tex
+		#define UNITY_PASS_TEXCUBEARRAY(tex) tex, sampler##tex
+		// round the layer index to get DX11-like behaviour (otherwise fractional indices result in mixed up cubemap faces)
+		#define UNITY_SAMPLE_TEXCUBEARRAY(tex,coord) tex.Sample (sampler##tex,float4((coord).xyz, round((coord).w)))
+		#define UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,float4((coord).xyz, round((coord).w)), lod)
+		#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,float4((coord).xyz, round((coord).w)))
+		#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,float4((coord).xyz, round((coord).w)), lod)		
+
+	#endif
+
+	// surface shader analysis; just pretend that 2D arrays are cubemaps
+	#if defined(SHADER_TARGET_SURFACE_ANALYSIS)
+		#define sampler2DArray samplerCUBE
+		#define tex2DArray texCUBE
+		#define tex2DArraylod texCUBElod
+	#endif
+
+#endif
+
+// For backwards compatibility, so we won't accidentally break shaders written by user
+#define SampleCubeReflection(env, dir, lod) UNITY_SAMPLE_TEXCUBE_LOD(env, dir, lod)
+
+
+#define samplerRECT sampler2D
+#define texRECT tex2D
+#define texRECTlod tex2Dlod
+#define texRECTbias tex2Dbias
+#define texRECTproj tex2Dproj
+
+#if defined(SHADER_API_PSSL)
+#define VPOS			S_POSITION
+#elif defined(UNITY_COMPILER_CG)
+// Cg seems to use WPOS instead of VPOS semantic?
+#define VPOS WPOS
+// Cg does not have tex2Dgrad and friends, but has tex2D overload that
+// can take the derivatives
+#define tex2Dgrad tex2D
+#define texCUBEgrad texCUBE
+#define tex3Dgrad tex3D
+#endif
+
+
+// Data type to be used for "screen space position" pixel shader input semantic;
+// D3D9 needs it to be float2, unlike all other platforms.
+#if defined(SHADER_API_D3D9)
+#define UNITY_VPOS_TYPE float2
+#else
+#define UNITY_VPOS_TYPE float4
+#endif
+
+
+
+#if defined(UNITY_COMPILER_HLSL) || defined (SHADER_TARGET_GLSL)
+#define FOGC FOG
+#endif
+
+// Use VFACE pixel shader input semantic in your shaders to get front-facing scalar value.
+// Requires shader model 3.0 or higher.
+#if defined(UNITY_COMPILER_CG)
+#define VFACE FACE
+#endif
+#if defined(UNITY_COMPILER_HLSL2GLSL)
+#define FACE VFACE
+#endif
+#if defined(SHADER_API_PSSL)
+#define VFACE S_FRONT_FACE
+#endif
+// Is VFACE affected by flipped projection?
+#if defined(SHADER_API_D3D9) || defined(SHADER_API_PSSL)
+#define UNITY_VFACE_AFFECTED_BY_PROJECTION 1
+#endif
+
+
+#if !defined(SHADER_API_D3D11) && !defined(SHADER_API_D3D11_9X) && !defined(UNITY_COMPILER_HLSLCC) && !defined(SHADER_API_PSSL)
+#define SV_POSITION POSITION
+#endif
+
+
+#if defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_PSSL)
+#define UNITY_ATTEN_CHANNEL r
+#else
+#define UNITY_ATTEN_CHANNEL a
+#endif
+
+#if defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_PSSL) || defined(SHADER_API_METAL) || defined(SHADER_API_WIIU) || defined(SHADER_API_VULKAN)
+#define UNITY_UV_STARTS_AT_TOP 1
+#endif
+
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_PSSL) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_METAL) || defined(SHADER_API_VULKAN)
+#define UNITY_REVERSED_Z 1
+#endif
+
+#if defined(UNITY_REVERSED_Z)
+#define UNITY_NEAR_CLIP_VALUE (1.0)
+#elif defined(SHADER_API_D3D9)  || defined(SHADER_API_WIIU) || defined(SHADER_API_D3D11_9X)
+#define UNITY_NEAR_CLIP_VALUE (0.0)
+#else
+#define UNITY_NEAR_CLIP_VALUE (-1.0)
+#endif
+
+// "platform caps" defines that were moved to editor, so they are set automatically when compiling shader
+// UNITY_NO_DXT5nm				- no DXT5NM support, so normal maps will encoded in rgb
+// UNITY_NO_RGBM				- no RGBM support, so doubleLDR
+// UNITY_NO_SCREENSPACE_SHADOWS	- no screenspace cascaded shadowmaps
+// UNITY_FRAMEBUFFER_FETCH_AVAILABLE	- framebuffer fetch
+// UNITY_ENABLE_REFLECTION_BUFFERS - render reflection probes in deferred way, when using deferred shading
+
+
+#if defined(SHADER_API_PSP2)
+// To get acceptable precision from the SGX interpolators when decoding RGBM type
+// textures we have to disable sRGB reads and then convert to gamma space in the shader
+// explicitly.
+#define UNITY_FORCE_LINEAR_READ_FOR_RGBM
+#endif
+
+
+// On most platforms, use floating point render targets to store depth of point
+// light shadowmaps. However, on some others they either have issues, or aren't widely
+// supported; in which case fallback to encoding depth into RGBA channels.
+// Make sure this define matches GraphicsCaps.useRGBAForPointShadows.
+#if defined(SHADER_API_GLES) || defined(SHADER_API_GLES3) || defined(SHADER_API_PSP2)
+#define UNITY_USE_RGBA_FOR_POINT_SHADOWS
+#endif
+
+
+// Initialize arbitrary structure with zero values.
+// Not supported on some backends (e.g. Cg-based particularly with nested structs).
+// hlsl2glsl would almost support it, except with structs that have arrays -- so treat as not supported there either :(
+#if defined(UNITY_COMPILER_HLSL) || defined(SHADER_API_PSSL) || defined(UNITY_COMPILER_HLSLCC)
+#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
+#else
+#define UNITY_INITIALIZE_OUTPUT(type,name)
+#endif
+
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE) || defined(SHADER_API_VULKAN) || defined(SHADER_API_PSSL)
+#define UNITY_CAN_COMPILE_TESSELLATION 1
+#	define UNITY_domain					domain
+#	define UNITY_partitioning			partitioning
+#	define UNITY_outputtopology			outputtopology
+#	define UNITY_patchconstantfunc		patchconstantfunc
+#	define UNITY_outputcontrolpoints	outputcontrolpoints
+#endif
+
+// Not really needed anymore, but did ship in Unity 4.0; with D3D11_9X remapping them to .r channel.
+// Now that's not used.
+#define UNITY_SAMPLE_1CHANNEL(x,y) tex2D(x,y).a
+#define UNITY_ALPHA_CHANNEL a
+
+
+// HLSL attributes
+#if defined(UNITY_COMPILER_HLSL)
+	#define UNITY_BRANCH	[branch]
+	#define UNITY_FLATTEN	[flatten]
+	#define UNITY_UNROLL	[unroll]
+	#define UNITY_LOOP		[loop]
+	#define UNITY_FASTOPT	[fastopt]
+#else
+	#define UNITY_BRANCH
+	#define UNITY_FLATTEN
+	#define UNITY_UNROLL
+	#define UNITY_LOOP
+	#define UNITY_FASTOPT
+#endif
+
+
+// Unity 4.x shaders used to mostly work if someone used WPOS semantic,
+// which was accepted by Cg. The correct semantic to use is "VPOS",
+// so define that so that old shaders keep on working.
+#if !defined(UNITY_COMPILER_CG)
+#define WPOS VPOS
+#endif
+
+// define use to identify platform with modern feature like texture 3D with filtering, texture array etc...
+#define UNITY_SM40_PLUS_PLATFORM (!((SHADER_TARGET < 30) || defined (SHADER_API_MOBILE) || defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11_9X) || defined (SHADER_API_PSP2) || defined(SHADER_API_GLES)))
+
+// Ability to manually set descriptor set and binding numbers (Vulkan only)
+#if defined(SHADER_API_VULKAN)
+	#define CBUFFER_START_WITH_BINDING(Name, Set, Binding) CBUFFER_START(Name##Xhlslcc_set_##Set##_bind_##Binding##X)
+	// Sampler / image declaration with set/binding decoration 
+	#define DECL_WITH_BINDING(Type, Name, Set, Binding) Type Name##hlslcc_set_##Set##_bind_##Binding
+#else
+	#define CBUFFER_START_WITH_BINDING(Name, Set, Binding) CBUFFER_START(Name)
+	#define DECL_WITH_BINDING(Type, Name, Set, Binding) Type Name
+#endif
+
+// ---- Shader keyword backwards compatibility
+// We used to have some built-in shader keywords, but they got removed at some point to save on shader keyword count.
+// However some existing shader code might be checking for the old names, so define them as regular
+// macros based on other criteria -- so that existing code keeps on working.
+
+// Unity 5.0 renamed HDR_LIGHT_PREPASS_ON to UNITY_HDR_ON
+#if defined(UNITY_HDR_ON)
+#define HDR_LIGHT_PREPASS_ON 1
+#endif
+
+// UNITY_NO_LINEAR_COLORSPACE was removed in 5.4 when UNITY_COLORSPACE_GAMMA was introduced as a platform keyword and runtime gamma fallback removed.
+#if !defined(UNITY_NO_LINEAR_COLORSPACE) && defined(UNITY_COLORSPACE_GAMMA)
+#define UNITY_NO_LINEAR_COLORSPACE 1
+#endif
+
+#if !defined(DIRLIGHTMAP_OFF) && !defined(DIRLIGHTMAP_SEPARATE) && !defined(DIRLIGHTMAP_COMBINED)
+#define DIRLIGHTMAP_OFF 1
+#endif
+
+#if !defined(LIGHTMAP_OFF) && !defined(LIGHTMAP_ON)
+#define LIGHTMAP_OFF 1
+#endif
+
+#if !defined(DYNAMICLIGHTMAP_OFF) && !defined(DYNAMICLIGHTMAP_ON)
+#define DYNAMICLIGHTMAP_OFF 1
+#endif
+
+
+#if defined (SHADER_API_D3D11) && defined(STEREO_INSTANCING_ON)
+
+	#undef UNITY_DECLARE_DEPTH_TEXTURE
+	#define UNITY_DECLARE_DEPTH_TEXTURE(tex) Texture2DArray tex; SamplerState sampler##tex
+
+	#undef SAMPLE_DEPTH_TEXTURE
+	#define SAMPLE_DEPTH_TEXTURE(tex, uv) UNITY_SAMPLE_TEX2DARRAY(tex, float3(uv.x, uv.y, (float)unity_StereoEyeIndex)).r
+
+	#undef SAMPLE_DEPTH_TEXTURE_PROJ
+	#define SAMPLE_DEPTH_TEXTURE_PROJ(tex, uv) UNITY_SAMPLE_TEX2DARRAY(tex, float3(uv.x/uv.w, uv.y/uv.w, (float)unity_StereoEyeIndex)).r
+
+	#define UNITY_DECLARE_SCREENSPACE_SHADOWMAP UNITY_DECLARE_TEX2DARRAY
+	#define UNITY_SAMPLE_SCREEN_SHADOW(tex, uv) UNITY_SAMPLE_TEX2DARRAY( tex, float3(uv.x/uv.w, uv.y/uv.w, (float)unity_StereoEyeIndex) ).r
+
+#else
+	#define UNITY_DECLARE_DEPTH_TEXTURE(tex) sampler2D_float tex
+	#define UNITY_DECLARE_SCREENSPACE_SHADOWMAP(tex) sampler2D tex
+	#define UNITY_SAMPLE_SCREEN_SHADOW(tex, uv) tex2Dproj( tex, UNITY_PROJ_COORD(uv) ).r
+#endif
+
+#endif // HLSL_SUPPORT_INCLUDED
+
+

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/HLSLSupport.cginc.meta

+fileFormatVersion: 2
+guid: d8e33c5f6e5a398479368b96d142dc72
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/Lighting.cginc

+#ifndef LIGHTING_INCLUDED
+#define LIGHTING_INCLUDED
+
+#include "UnityLightingCommon.cginc"
+#include "UnityGBuffer.cginc"
+#include "UnityGlobalIllumination.cginc"
+
+struct SurfaceOutput {
+	fixed3 Albedo;
+	fixed3 Normal;
+	fixed3 Emission;
+	half Specular;
+	fixed Gloss;
+	fixed Alpha;
+};
+
+#ifndef USING_DIRECTIONAL_LIGHT
+#if defined (DIRECTIONAL_COOKIE) || defined (DIRECTIONAL)
+#define USING_DIRECTIONAL_LIGHT
+#endif
+#endif
+
+#if defined(UNITY_SHOULD_SAMPLE_SH) || defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
+	#define UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
+#endif
+
+inline fixed4 UnityLambertLight (SurfaceOutput s, UnityLight light)
+{
+	fixed diff = max (0, dot (s.Normal, light.dir));
+	
+	fixed4 c;
+	c.rgb = s.Albedo * light.color * diff;
+	c.a = s.Alpha;
+	return c;
+}
+
+inline fixed4 LightingLambert (SurfaceOutput s, UnityGI gi)
+{
+	fixed4 c;
+	c = UnityLambertLight (s, gi.light);
+
+	#if defined(DIRLIGHTMAP_SEPARATE)
+		#ifdef LIGHTMAP_ON
+			c += UnityLambertLight (s, gi.light2);
+		#endif
+		#ifdef DYNAMICLIGHTMAP_ON
+			c += UnityLambertLight (s, gi.light3);
+		#endif
+	#endif
+
+	#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
+		c.rgb += s.Albedo * gi.indirect.diffuse;
+	#endif
+
+	return c;
+}
+
+inline half4 LightingLambert_Deferred (SurfaceOutput s, UnityGI gi, out half4 outGBuffer0, out half4 outGBuffer1, out half4 outGBuffer2)
+{
+	UnityStandardData data;
+	data.diffuseColor	= s.Albedo;
+	data.occlusion		= 1;		
+	data.specularColor	= 0;
+	data.smoothness		= 0;	
+	data.normalWorld	= s.Normal;
+
+	UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
+
+	half4 emission = half4(s.Emission, 1);
+
+	#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
+		emission.rgb += s.Albedo * gi.indirect.diffuse;
+	#endif
+
+	return emission;
+}
+
+inline void LightingLambert_GI (
+	SurfaceOutput s,
+	UnityGIInput data,
+	inout UnityGI gi)
+{
+	gi = UnityGlobalIllumination (data, 1.0, s.Normal);
+}
+
+inline fixed4 LightingLambert_PrePass (SurfaceOutput s, half4 light)
+{
+	fixed4 c;
+	c.rgb = s.Albedo * light.rgb;
+	c.a = s.Alpha;
+	return c;
+}
+
+// NOTE: some intricacy in shader compiler on some GLES2.0 platforms (iOS) needs 'viewDir' & 'h'
+// to be mediump instead of lowp, otherwise specular highlight becomes too bright.
+inline fixed4 UnityBlinnPhongLight (SurfaceOutput s, half3 viewDir, UnityLight light)
+{
+	half3 h = normalize (light.dir + viewDir);
+	
+	fixed diff = max (0, dot (s.Normal, light.dir));
+	
+	float nh = max (0, dot (s.Normal, h));
+	float spec = pow (nh, s.Specular*128.0) * s.Gloss;
+	
+	fixed4 c;
+	c.rgb = s.Albedo * light.color * diff + light.color * _SpecColor.rgb * spec;
+	c.a = s.Alpha;
+
+	return c;
+}
+
+inline fixed4 LightingBlinnPhong (SurfaceOutput s, half3 viewDir, UnityGI gi)
+{
+	fixed4 c;
+	c = UnityBlinnPhongLight (s, viewDir, gi.light);
+
+	#if defined(DIRLIGHTMAP_SEPARATE)
+		#ifdef LIGHTMAP_ON
+			c += UnityBlinnPhongLight (s, viewDir, gi.light2);
+		#endif
+		#ifdef DYNAMICLIGHTMAP_ON
+			c += UnityBlinnPhongLight (s, viewDir, gi.light3);
+		#endif
+	#endif
+
+	#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
+		c.rgb += s.Albedo * gi.indirect.diffuse;
+	#endif
+
+	return c;
+}
+
+inline half4 LightingBlinnPhong_Deferred (SurfaceOutput s, half3 viewDir, UnityGI gi, out half4 outGBuffer0, out half4 outGBuffer1, out half4 outGBuffer2)
+{
+	UnityStandardData data;
+	data.diffuseColor	= s.Albedo;
+	data.occlusion		= 1;		
+	// PI factor come from StandardBDRF (UnityStandardBRDF.cginc:351 for explanation)
+	data.specularColor	= _SpecColor.rgb * s.Gloss * (1/UNITY_PI);
+	data.smoothness		= s.Specular;	
+	data.normalWorld	= s.Normal;
+
+	UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
+
+	half4 emission = half4(s.Emission, 1);
+
+	#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT
+		emission.rgb += s.Albedo * gi.indirect.diffuse;
+	#endif
+	
+	return emission;
+}
+
+inline void LightingBlinnPhong_GI (
+	SurfaceOutput s,
+	UnityGIInput data,
+	inout UnityGI gi)
+{
+	gi = UnityGlobalIllumination (data, 1.0, s.Normal);
+}
+
+inline fixed4 LightingBlinnPhong_PrePass (SurfaceOutput s, half4 light)
+{
+	fixed spec = light.a * s.Gloss;
+	
+	fixed4 c;
+	c.rgb = (s.Albedo * light.rgb + light.rgb * _SpecColor.rgb * spec);
+	c.a = s.Alpha;
+	return c;
+}
+
+#ifdef UNITY_CAN_COMPILE_TESSELLATION
+struct UnityTessellationFactors {
+    float edge[3] : SV_TessFactor;
+    float inside : SV_InsideTessFactor;
+};
+#endif // UNITY_CAN_COMPILE_TESSELLATION
+
+// Deprecated, kept around for existing user shaders.
+#define UNITY_DIRBASIS \
+const half3x3 unity_DirBasis = half3x3( \
+  half3( 0.81649658,  0.0,        0.57735027), \
+  half3(-0.40824830,  0.70710678, 0.57735027), \
+  half3(-0.40824830, -0.70710678, 0.57735027) \
+);
+
+// Deprecated, kept around for existing user shaders. Only sampling the flat lightmap now.
+half3 DirLightmapDiffuse(in half3x3 dirBasis, fixed4 color, fixed4 scale, half3 normal, bool surfFuncWritesNormal, out half3 scalePerBasisVector)
+{
+	return DecodeLightmap (color);
+}
+
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/Lighting.cginc.meta

+fileFormatVersion: 2
+guid: d399d19ccbe4efa4cb504f19ef373d16
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityCG.cginc.meta

+fileFormatVersion: 2
+guid: 2e802e901bde25c4e954099932c626cb
+timeCreated: 1479834220
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityCG.glslinc

+#ifndef UNITY_CG_INCLUDED
+#define UNITY_CG_INCLUDED
+
+// -------------------------------------------------------------------
+// Common functions
+
+float saturate(float x) 
+{ 
+	return max(0.0, min(1.0, x)); 
+}
+
+
+// -------------------------------------------------------------------
+//  builtin values exposed from Unity
+
+// Time values from Unity
+uniform vec4 _Time;
+uniform vec4 _SinTime;
+uniform vec4 _CosTime;
+
+// x = 1 or -1 (-1 if projection is flipped)
+// y = near plane
+// z = far plane
+// w = 1/far plane
+uniform vec4 _ProjectionParams;
+
+// x = width
+// y = height
+// z = 1 + 1.0/width
+// w = 1 + 1.0/height
+uniform vec4 _ScreenParams;
+
+uniform vec3 _WorldSpaceCameraPos;
+uniform vec4 _WorldSpaceLightPos0;
+
+uniform mat4 unity_ObjectToWorld, unity_WorldToObject;
+
+uniform vec4 _LightPositionRange; // xyz = pos, w = 1/range
+
+// -------------------------------------------------------------------
+//  helper functions and macros used in many standard shaders
+
+#if defined DIRECTIONAL || defined DIRECTIONAL_COOKIE
+#define USING_DIRECTIONAL_LIGHT
+#endif
+
+#if defined DIRECTIONAL || defined DIRECTIONAL_COOKIE || defined POINT || defined SPOT || defined POINT_NOATT || defined POINT_COOKIE
+#define USING_LIGHT_MULTI_COMPILE
+#endif
+
+
+#ifdef VERTEX
+
+// Computes world space light direction
+vec3 WorldSpaceLightDir( vec4 v )
+{
+	vec3 worldPos = (unity_ObjectToWorld * v).xyz;
+	#ifndef USING_LIGHT_MULTI_COMPILE
+		return _WorldSpaceLightPos0.xyz - worldPos * _WorldSpaceLightPos0.w;
+	#else
+		#ifndef USING_DIRECTIONAL_LIGHT
+		return _WorldSpaceLightPos0.xyz - worldPos;
+		#else
+		return _WorldSpaceLightPos0.xyz;
+		#endif
+	#endif
+}
+
+// Computes object space light direction
+vec3 ObjSpaceLightDir( vec4 v )
+{
+	vec3 objSpaceLightPos = (unity_WorldToObject * _WorldSpaceLightPos0).xyz;
+	#ifndef USING_LIGHT_MULTI_COMPILE
+		return objSpaceLightPos.xyz - v.xyz * _WorldSpaceLightPos0.w;
+	#else
+		#ifndef USING_DIRECTIONAL_LIGHT
+		return objSpaceLightPos.xyz - v.xyz;
+		#else
+		return objSpaceLightPos.xyz;
+		#endif
+	#endif
+}
+
+// Computes world space view direction
+vec3 WorldSpaceViewDir( vec4 v )
+{
+	return _WorldSpaceCameraPos.xyz - (unity_ObjectToWorld * v).xyz;
+}
+
+// Computes object space view direction
+vec3 ObjSpaceViewDir( vec4 v )
+{
+	vec3 objSpaceCameraPos = (unity_WorldToObject * vec4(_WorldSpaceCameraPos.xyz, 1.0)).xyz;
+	return objSpaceCameraPos - v.xyz;
+}
+
+// Declares 3x3 matrix 'rotation', filled with tangent space basis
+// Do not use multiline define here, nVidia OpenGL drivers are buggy in parsing that.
+#define TANGENT_SPACE_ROTATION vec3 binormal = cross( gl_Normal.xyz, Tangent.xyz ) * Tangent.w; mat3 rotation = mat3( Tangent.x, binormal.x, gl_Normal.x, Tangent.y, binormal.y, gl_Normal.y, Tangent.z, binormal.z, gl_Normal.z );
+
+
+// Transforms float2 UV by scale/bias property (new method)
+#define TRANSFORM_TEX(tex,name) (tex.xy * name##_ST.xy + name##_ST.zw)
+
+// Deprecated. Used to transform 4D UV by a fixed function texture matrix. Now just returns the passed UV.
+#define TRANSFORM_UV(idx) (gl_TexCoord[0].xy)
+
+#endif // VERTEX
+
+
+
+// Calculates UV offset for parallax bump mapping
+vec2 ParallaxOffset( float h, float height, vec3 viewDir )
+{
+	h = h * height - height/2.0;
+	vec3 v = normalize(viewDir);
+	v.z += 0.42;
+	return h * (v.xy / v.z);
+}
+
+
+// Converts color to luminance (grayscale)
+float Luminance( vec3 c )
+{
+	return dot( c, vec3(0.22, 0.707, 0.071) );
+}
+
+
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityCG.glslinc.meta

+fileFormatVersion: 2
+guid: 7821bea8ea0e7e94f97a2ae2aa7d1c24
+timeCreated: 1479834220
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardBRDF.cginc

+#ifndef UNITY_STANDARD_BRDF_INCLUDED
+#define UNITY_STANDARD_BRDF_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityStandardConfig.cginc"
+#include "UnityLightingCommon.cginc"
+
+//-----------------------------------------------------------------------------
+// Helper to convert smoothness to roughness
+//-----------------------------------------------------------------------------
+
+half PerceptualRoughnessToRoughness(half perceptualRoughness)
+{
+	return perceptualRoughness * perceptualRoughness;
+}
+
+half RoughnessToPerceptualRoughness(half roughness)
+{
+	return sqrt(roughness);
+}
+
+// Smoothness is the user facing name
+// it should be perceptualSmoothness but we don't want the user to have to deal with this name
+half SmoothnessToRoughness(half smoothness)
+{
+	return (1 - smoothness) * (1 - smoothness);
+}
+
+half SmoothnessToPerceptualRoughness(half smoothness)
+{
+	return (1 - smoothness);
+}
+
+//-------------------------------------------------------------------------------------
+
+inline half Pow4 (half x)
+{
+	return x*x*x*x;
+}
+
+inline half2 Pow4 (half2 x)
+{
+	return x*x*x*x;
+}
+
+inline half3 Pow4 (half3 x)
+{
+	return x*x*x*x;
+}
+
+inline half4 Pow4 (half4 x)
+{
+	return x*x*x*x;
+}
+
+// Pow5 uses the same amount of instructions as generic pow(), but has 2 advantages:
+// 1) better instruction pipelining
+// 2) no need to worry about NaNs
+inline half Pow5 (half x)
+{
+	return x*x * x*x * x;
+}
+
+inline half2 Pow5 (half2 x)
+{
+	return x*x * x*x * x;
+}
+
+inline half3 Pow5 (half3 x)
+{
+	return x*x * x*x * x;
+}
+
+inline half4 Pow5 (half4 x)
+{
+	return x*x * x*x * x;
+}
+
+inline half3 FresnelTerm (half3 F0, half cosA)
+{
+	half t = Pow5 (1 - cosA);	// ala Schlick interpoliation
+	return F0 + (1-F0) * t;
+}
+inline half3 FresnelLerp (half3 F0, half3 F90, half cosA)
+{
+	half t = Pow5 (1 - cosA);	// ala Schlick interpoliation
+	return lerp (F0, F90, t);
+}
+// approximage Schlick with ^4 instead of ^5
+inline half3 FresnelLerpFast (half3 F0, half3 F90, half cosA)
+{
+	half t = Pow4 (1 - cosA);
+	return lerp (F0, F90, t);
+}
+
+// Note: Disney diffuse must be multiply by diffuseAlbedo / PI. This is done outside of this function.
+half DisneyDiffuse(half NdotV, half NdotL, half LdotH, half perceptualRoughness)
+{
+	half fd90 = 0.5 + 2 * LdotH * LdotH * perceptualRoughness;
+	// Two schlick fresnel term
+	half lightScatter	= (1 + (fd90 - 1) * Pow5(1 - NdotL));
+	half viewScatter	= (1 + (fd90 - 1) * Pow5(1 - NdotV));
+
+	return lightScatter * viewScatter;
+}
+
+// NOTE: Visibility term here is the full form from Torrance-Sparrow model, it includes Geometric term: V = G / (N.L * N.V)
+// This way it is easier to swap Geometric terms and more room for optimizations (except maybe in case of CookTorrance geom term)
+
+// Generic Smith-Schlick visibility term
+inline half SmithVisibilityTerm (half NdotL, half NdotV, half k)
+{
+	half gL = NdotL * (1-k) + k;
+	half gV = NdotV * (1-k) + k;
+	return 1.0 / (gL * gV + 1e-5f); // This function is not intended to be running on Mobile,
+									// therefore epsilon is smaller than can be represented by half
+}
+
+// Smith-Schlick derived for Beckmann
+inline half SmithBeckmannVisibilityTerm (half NdotL, half NdotV, half roughness)
+{
+	half c = 0.797884560802865h; // c = sqrt(2 / Pi)
+	half k = roughness * c;
+	return SmithVisibilityTerm (NdotL, NdotV, k) * 0.25f; // * 0.25 is the 1/4 of the visibility term
+}
+
+// Ref: http://jcgt.org/published/0003/02/03/paper.pdf
+inline half SmithJointGGXVisibilityTerm (half NdotL, half NdotV, half roughness)
+{
+#if 0
+	// Original formulation:
+	//	lambda_v	= (-1 + sqrt(a2 * (1 - NdotL2) / NdotL2 + 1)) * 0.5f;
+	//	lambda_l	= (-1 + sqrt(a2 * (1 - NdotV2) / NdotV2 + 1)) * 0.5f;
+	//	G			= 1 / (1 + lambda_v + lambda_l);
+
+	// Reorder code to be more optimal
+	half a			= roughness;
+	half a2			= a * a;
+
+	half lambdaV	= NdotL * sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
+	half lambdaL	= NdotV * sqrt((-NdotL * a2 + NdotL) * NdotL + a2);
+
+	// Simplify visibility term: (2.0f * NdotL * NdotV) /  ((4.0f * NdotL * NdotV) * (lambda_v + lambda_l + 1e-5f));
+	return 0.5f / (lambdaV + lambdaL + 1e-5f);	// This function is not intended to be running on Mobile,
+												// therefore epsilon is smaller than can be represented by half
+#else
+    // Approximation of the above formulation (simplify the sqrt, not mathematically correct but close enough)
+	half a = roughness;
+	half lambdaV = NdotL * (NdotV * (1 - a) + a);
+	half lambdaL = NdotV * (NdotL * (1 - a) + a);
+
+	return 0.5f / (lambdaV + lambdaL + 1e-5f);
+#endif
+}
+
+inline half GGXTerm (half NdotH, half roughness)
+{
+	half a2 = roughness * roughness;
+	half d = (NdotH * a2 - NdotH) * NdotH + 1.0f; // 2 mad
+	return UNITY_INV_PI * a2 / (d * d + 1e-7f); // This function is not intended to be running on Mobile,
+											// therefore epsilon is smaller than what can be represented by half
+}
+
+inline half PerceptualRoughnessToSpecPower (half perceptualRoughness)
+{
+	half m = PerceptualRoughnessToRoughness(perceptualRoughness);	// m is the true academic roughness.
+	half sq = max(1e-4f, m*m);
+	half n = (2.0 / sq) - 2.0;							// https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
+	n = max(n, 1e-4f);									// prevent possible cases of pow(0,0), which could happen when roughness is 1.0 and NdotH is zero
+	return n;
+}
+
+// BlinnPhong normalized as normal distribution function (NDF)
+// for use in micro-facet model: spec=D*G*F
+// eq. 19 in https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
+inline half NDFBlinnPhongNormalizedTerm (half NdotH, half n)
+{
+	// norm = (n+2)/(2*pi)
+	half normTerm = (n + 2.0) * (0.5/UNITY_PI);
+
+	half specTerm = pow (NdotH, n);
+	return specTerm * normTerm;
+}
+
+//-------------------------------------------------------------------------------------
+/*
+// https://s3.amazonaws.com/docs.knaldtech.com/knald/1.0.0/lys_power_drops.html
+
+const float k0 = 0.00098, k1 = 0.9921;
+// pass this as a constant for optimization
+const float fUserMaxSPow = 100000; // sqrt(12M)
+const float g_fMaxT = ( exp2(-10.0/fUserMaxSPow) - k0)/k1;
+float GetSpecPowToMip(float fSpecPow, int nMips)
+{
+   // Default curve - Inverse of TB2 curve with adjusted constants
+   float fSmulMaxT = ( exp2(-10.0/sqrt( fSpecPow )) - k0)/k1;
+   return float(nMips-1)*(1.0 - clamp( fSmulMaxT/g_fMaxT, 0.0, 1.0 ));
+}
+
+	//float specPower = PerceptualRoughnessToSpecPower(perceptualRoughness);
+	//float mip = GetSpecPowToMip (specPower, 7);
+*/
+
+inline half3 Unity_SafeNormalize(half3 inVec)
+{
+	half dp3 = max(0.001f, dot(inVec, inVec));
+	return inVec * rsqrt(dp3);
+}
+
+//-------------------------------------------------------------------------------------
+
+// Note: BRDF entry points use smoothness and oneMinusReflectivity for optimization
+// purposes, mostly for DX9 SM2.0 level. Most of the math is being done on these (1-x) values, and that saves
+// a few precious ALU slots.
+
+
+// Main Physically Based BRDF
+// Derived from Disney work and based on Torrance-Sparrow micro-facet model
+//
+//   BRDF = kD / pi + kS * (D * V * F) / 4
+//   I = BRDF * NdotL
+//
+// * NDF (depending on UNITY_BRDF_GGX):
+//  a) Normalized BlinnPhong
+//  b) GGX
+// * Smith for Visiblity term
+// * Schlick approximation for Fresnel
+half4 BRDF1_Unity_PBS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half smoothness,
+	half3 normal, half3 viewDir,
+	UnityLight light, UnityIndirect gi)
+{
+	half perceptualRoughness = SmoothnessToPerceptualRoughness (smoothness);
+	half3 halfDir = Unity_SafeNormalize (light.dir + viewDir);
+
+// NdotV should not be negative for visible pixels, but it can happen due to perspective projection and normal mapping
+// In this case normal should be modified to become valid (i.e facing camera) and not cause weird artifacts.
+// but this operation adds few ALU and users may not want it. Alternative is to simply take the abs of NdotV (less correct but works too).
+// Following define allow to control this. Set it to 0 if ALU is critical on your platform.
+// This correction is interesting for GGX with SmithJoint visibility function because artifacts are more visible in this case due to highlight edge of rough surface
+// Edit: Disable this code by default for now as it is not compatible with two sided lighting used in SpeedTree.
+#define UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV 0 
+
+#if UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV
+	// The amount we shift the normal toward the view vector is defined by the dot product.
+	half shiftAmount = dot(normal, viewDir);
+	normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
+	// A re-normalization should be applied here but as the shift is small we don't do it to save ALU.
+	//normal = normalize(normal);
+
+	half nv = saturate(dot(normal, viewDir)); // TODO: this saturate should no be necessary here
+#else
+	half nv = abs(dot(normal, viewDir));	// This abs allow to limit artifact
+#endif
+
+	half nl = saturate(dot(normal, light.dir));
+	half nh = saturate(dot(normal, halfDir));
+
+	half lv = saturate(dot(light.dir, viewDir));
+	half lh = saturate(dot(light.dir, halfDir));
+
+	// Diffuse term
+	half diffuseTerm = DisneyDiffuse(nv, nl, lh, perceptualRoughness) * nl;
+	diffuseTerm *= 1.0f / UNITY_PI;
+
+	// Specular term
+	// HACK: theoretically we should divide diffuseTerm by Pi and not multiply specularTerm!
+	// BUT 1) that will make shader look significantly darker than Legacy ones
+	// and 2) on engine side "Non-important" lights have to be divided by Pi too in cases when they are injected into ambient SH
+	half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+#if UNITY_BRDF_GGX
+	half V = SmithJointGGXVisibilityTerm (nl, nv, roughness);
+	half D = GGXTerm (nh, roughness);
+#else
+	// Legacy
+	half V = SmithBeckmannVisibilityTerm (nl, nv, roughness);
+	half D = NDFBlinnPhongNormalizedTerm (nh, PerceptualRoughnessToSpecPower(perceptualRoughness));
+#endif
+
+	half specularTerm = V*D * UNITY_PI; // Torrance-Sparrow model, Fresnel is applied later
+
+#	ifdef UNITY_COLORSPACE_GAMMA
+		specularTerm = sqrt(max(1e-4h, specularTerm));
+#	endif
+
+	// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
+	specularTerm = max(0, specularTerm * nl);
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+	specularTerm = 0.0;
+#endif
+
+	// surfaceReduction = Int D(NdotH) * NdotH * Id(NdotL>0) dH = 1/(roughness^2+1)
+	half surfaceReduction;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		surfaceReduction = 1.0-0.28*roughness*perceptualRoughness;		// 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
+#	else
+		surfaceReduction = 1.0 / (roughness*roughness + 1.0);			// fade \in [0.5;1]
+#	endif
+
+	// To provide true Lambert lighting, we need to be able to kill specular completely.
+	specularTerm *= any(specColor) ? 1.0 : 0.0;
+
+	half grazingTerm = saturate(smoothness + (1-oneMinusReflectivity));
+    half3 color =	diffColor * (gi.diffuse + light.color * diffuseTerm)
+                    + specularTerm * light.color * FresnelTerm (specColor, lh)
+					+ surfaceReduction * gi.specular * FresnelLerp (specColor, grazingTerm, nv);
+
+	return half4(color, 1);
+}
+
+// Based on Minimalist CookTorrance BRDF
+// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
+//
+// * NDF (depending on UNITY_BRDF_GGX):
+//  a) BlinnPhong
+//  b) [Modified] GGX
+// * Modified Kelemen and Szirmay-​Kalos for Visibility term
+// * Fresnel approximated with 1/LdotH
+half4 BRDF2_Unity_PBS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half smoothness,
+	half3 normal, half3 viewDir,
+	UnityLight light, UnityIndirect gi)
+{
+	half3 halfDir = Unity_SafeNormalize (light.dir + viewDir);
+
+	half nl = saturate(dot(normal, light.dir));
+	half nh = saturate(dot(normal, halfDir));
+	half nv = saturate(dot(normal, viewDir));
+	half lh = saturate(dot(light.dir, halfDir));
+
+	// Specular term
+	half perceptualRoughness = SmoothnessToPerceptualRoughness (smoothness);
+	half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+
+#if UNITY_BRDF_GGX
+
+	// GGX Distribution multiplied by combined approximation of Visibility and Fresnel
+	// See "Optimizing PBR for Mobile" from Siggraph 2015 moving mobile graphics course
+	// https://community.arm.com/events/1155
+	half a = roughness;
+	half a2 = a*a;
+
+	half d = nh * nh * (a2 - 1.h) + 1.00001h;
+#ifdef UNITY_COLORSPACE_GAMMA
+	// Tighter approximation for Gamma only rendering mode!
+	// DVF = sqrt(DVF);
+	// DVF = (a * sqrt(.25)) / (max(sqrt(0.1), lh)*sqrt(roughness + .5) * d);
+	half specularTerm = a / (max(0.32h, lh) * (1.5h + roughness) * d);
+#else
+	half specularTerm = a2 / (max(0.1h, lh*lh) * (roughness + 0.5h) * (d * d) * 4);
+#endif
+
+	// on mobiles (where half actually means something) denominator have risk of overflow
+	// clamp below was added specifically to "fix" that, but dx compiler (we convert bytecode to metal/gles)
+	// sees that specularTerm have only non-negative terms, so it skips max(0,..) in clamp (leaving only min(100,...))
+#if defined (SHADER_API_MOBILE)
+	specularTerm = specularTerm - 1e-4h;
+#endif
+
+#else
+
+	// Legacy
+	half specularPower = PerceptualRoughnessToSpecPower(perceptualRoughness);
+	// Modified with approximate Visibility function that takes roughness into account
+	// Original ((n+1)*N.H^n) / (8*Pi * L.H^3) didn't take into account roughness 
+	// and produced extremely bright specular at grazing angles
+
+	half invV = lh * lh * smoothness + perceptualRoughness * perceptualRoughness; // approx ModifiedKelemenVisibilityTerm(lh, perceptualRoughness);
+	half invF = lh;
+
+	half specularTerm = ((specularPower + 1) * pow (nh, specularPower)) / (8 * invV * invF + 1e-4h);
+
+#ifdef UNITY_COLORSPACE_GAMMA
+	specularTerm = sqrt(max(1e-4h, specularTerm));
+#endif
+
+#endif
+
+#if defined (SHADER_API_MOBILE)
+	specularTerm = clamp(specularTerm, 0.0, 100.0);	// Prevent FP16 overflow on mobiles
+#endif
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+	specularTerm = 0.0;
+#endif
+
+	// surfaceReduction = Int D(NdotH) * NdotH * Id(NdotL>0) dH = 1/(realRoughness^2+1)
+
+	// 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
+	// 1-x^3*(0.6-0.08*x)   approximation for 1/(x^4+1)
+#ifdef UNITY_COLORSPACE_GAMMA
+	half surfaceReduction = 0.28;
+#else
+	half surfaceReduction = (0.6-0.08*perceptualRoughness);
+#endif
+
+	surfaceReduction = 1.0 - roughness*perceptualRoughness*surfaceReduction;
+
+	half grazingTerm = saturate(smoothness + (1-oneMinusReflectivity));
+	half3 color =	(diffColor + specularTerm * specColor) * light.color * nl
+					+ gi.diffuse * diffColor
+					+ surfaceReduction * gi.specular * FresnelLerpFast (specColor, grazingTerm, nv);
+
+	return half4(color, 1);
+}
+
+sampler2D unity_NHxRoughness;
+half3 BRDF3_Direct(half3 diffColor, half3 specColor, half rlPow4, half smoothness)
+{
+	half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp
+	// Lookup texture to save instructions
+	half specular = tex2D(unity_NHxRoughness, half2(rlPow4, SmoothnessToPerceptualRoughness(smoothness))).UNITY_ATTEN_CHANNEL * LUT_RANGE;
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+	specular = 0.0;
+#endif
+
+	return diffColor + specular * specColor;
+}
+
+half3 BRDF3_Indirect(half3 diffColor, half3 specColor, UnityIndirect indirect, half grazingTerm, half fresnelTerm)
+{
+	half3 c = indirect.diffuse * diffColor;
+	c += indirect.specular * lerp (specColor, grazingTerm, fresnelTerm);
+	return c;
+}
+
+// Old school, not microfacet based Modified Normalized Blinn-Phong BRDF
+// Implementation uses Lookup texture for performance
+//
+// * Normalized BlinnPhong in RDF form
+// * Implicit Visibility term
+// * No Fresnel term
+//
+// TODO: specular is too weak in Linear rendering mode
+half4 BRDF3_Unity_PBS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half smoothness,
+	half3 normal, half3 viewDir,
+	UnityLight light, UnityIndirect gi)
+{
+	half3 reflDir = reflect (viewDir, normal);
+
+	half nl = saturate(dot(normal, light.dir));
+	half nv = saturate(dot(normal, viewDir));
+
+	// Vectorize Pow4 to save instructions
+	half2 rlPow4AndFresnelTerm = Pow4 (half2(dot(reflDir, light.dir), 1-nv));  // use R.L instead of N.H to save couple of instructions
+	half rlPow4 = rlPow4AndFresnelTerm.x; // power exponent must match kHorizontalWarpExp in NHxRoughness() function in GeneratedTextures.cpp
+	half fresnelTerm = rlPow4AndFresnelTerm.y;
+
+	half grazingTerm = saturate(smoothness + (1-oneMinusReflectivity));
+
+	half3 color = BRDF3_Direct(diffColor, specColor, rlPow4, smoothness);
+	color *= light.color * nl;
+	color += BRDF3_Indirect(diffColor, specColor, gi, grazingTerm, fresnelTerm);
+
+	return half4(color, 1);
+}
+
+// Include deprecated function
+#define INCLUDE_UNITY_STANDARD_BRDF_DEPRECATED
+#include "UnityDeprecated.cginc"
+#undef INCLUDE_UNITY_STANDARD_BRDF_DEPRECATED
+
+#endif // UNITY_STANDARD_BRDF_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardBRDF.cginc.meta

+fileFormatVersion: 2
+guid: 88cd0ea4826264247a5ad99c01fc54f6
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardConfig.cginc

+#ifndef UNITY_STANDARD_CONFIG_INCLUDED
+#define UNITY_STANDARD_CONFIG_INCLUDED
+
+// Define Specular cubemap constants
+#ifndef UNITY_SPECCUBE_LOD_EXPONENT
+#define UNITY_SPECCUBE_LOD_EXPONENT (1.5)
+#endif
+#ifndef UNITY_SPECCUBE_LOD_STEPS
+#define UNITY_SPECCUBE_LOD_STEPS (6)
+#endif
+
+// Energy conservation for Specular workflow is Monochrome. For instance: Red metal will make diffuse Black not Cyan
+#ifndef UNITY_CONSERVE_ENERGY
+#define UNITY_CONSERVE_ENERGY 1
+#endif
+#ifndef UNITY_CONSERVE_ENERGY_MONOCHROME
+#define UNITY_CONSERVE_ENERGY_MONOCHROME 1
+#endif
+
+// "platform caps" defines: they are controlled from TierSettings (Editor will determine values and pass them to compiler)
+// UNITY_SPECCUBE_BOX_PROJECTION:					TierSettings.reflectionProbeBoxProjection
+// UNITY_SPECCUBE_BLENDING:							TierSettings.reflectionProbeBlending
+// UNITY_ENABLE_DETAIL_NORMALMAP:					TierSettings.detailNormalMap
+// UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS:	TierSettings.semitransparentShadows
+
+// disregarding what is set in TierSettings, some features have hardware restrictions
+// so we still add safety net, otherwise we might end up with shaders failing to compile
+
+#if SHADER_TARGET < 30
+	#undef UNITY_SPECCUBE_BOX_PROJECTION
+	#undef UNITY_SPECCUBE_BLENDING
+	#undef UNITY_ENABLE_DETAIL_NORMALMAP
+#endif
+#if (SHADER_TARGET < 30) || defined(SHADER_API_GLES) || defined(SHADER_API_D3D11_9X) || defined (SHADER_API_PSP2)
+	#undef UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS
+#endif
+
+#ifndef UNITY_SAMPLE_FULL_SH_PER_PIXEL
+//If this is enabled then we should consider Light Probe Proxy Volumes(SHEvalLinearL0L1_SampleProbeVolume) in ShadeSH9
+#define UNITY_SAMPLE_FULL_SH_PER_PIXEL 0
+#endif
+
+#ifndef UNITY_BRDF_GGX
+#define UNITY_BRDF_GGX 1
+#endif
+
+// Orthnormalize Tangent Space basis per-pixel
+// Necessary to support high-quality normal-maps. Compatible with Maya and Marmoset.
+// However xNormal expects oldschool non-orthnormalized basis - essentially preventing good looking normal-maps :(
+// Due to the fact that xNormal is probably _the most used tool to bake out normal-maps today_ we have to stick to old ways for now.
+// 
+// Disabled by default, until xNormal has an option to bake proper normal-maps.
+#ifndef UNITY_TANGENT_ORTHONORMALIZE
+#define UNITY_TANGENT_ORTHONORMALIZE 0
+#endif
+
+
+// Some extra optimizations
+
+// On PVR GPU there is an extra cost for dependent texture readback, especially hitting texCUBElod
+// These defines should be set as keywords or smth (at runtime depending on GPU).
+// for now we keep the code but disable it, as we want more optimization/cleanup passes
+
+#ifndef UNITY_OPTIMIZE_TEXCUBELOD
+	#define UNITY_OPTIMIZE_TEXCUBELOD 0
+#endif
+
+// Simplified Standard Shader is off by default and should not be used for Legacy Shaders
+#ifndef UNITY_STANDARD_SIMPLE
+	#define UNITY_STANDARD_SIMPLE 0
+#endif
+
+// Setup a new define with meaniful name to know if we require world pos in fragment shader
+#define UNITY_REQUIRE_FRAG_WORLDPOS (defined(UNITY_SPECCUBE_BOX_PROJECTION) || UNITY_LIGHT_PROBE_PROXY_VOLUME)
+
+#endif // UNITY_STANDARD_CONFIG_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardConfig.cginc.meta

+fileFormatVersion: 2
+guid: b5851d94d3bc71a4d9c58ba132fe876e
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCore.cginc

+#ifndef UNITY_STANDARD_CORE_INCLUDED
+#define UNITY_STANDARD_CORE_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityShaderVariables.cginc"
+#include "UnityInstancing.cginc"
+#include "UnityStandardConfig.cginc"
+#include "UnityStandardInput.cginc"
+#include "UnityPBSLighting.cginc"
+#include "UnityStandardUtils.cginc"
+#include "UnityGBuffer.cginc"
+#include "UnityStandardBRDF.cginc"
+
+#include "AutoLight.cginc"
+//-------------------------------------------------------------------------------------
+// counterpart for NormalizePerPixelNormal
+// skips normalization per-vertex and expects normalization to happen per-pixel
+half3 NormalizePerVertexNormal (float3 n) // takes float to avoid overflow
+{
+    #if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+        return normalize(n);
+    #else
+        return n; // will normalize per-pixel instead
+    #endif
+}
+
+half3 NormalizePerPixelNormal (half3 n)
+{
+	#if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+		return n;
+	#else
+		return normalize(n);
+	#endif
+}
+
+//-------------------------------------------------------------------------------------
+UnityLight MainLight ()
+{
+	UnityLight l;
+	#if !defined(LIGHTMAP_ON)
+		l.color = _LightColor0.rgb;
+		l.dir = _WorldSpaceLightPos0.xyz;
+		l.ndotl = 0; // Not used
+	#else
+		// no light specified by the engine
+		// analytical light might be extracted from Lightmap data later on in the shader depending on the Lightmap type
+		// Should be ResetUnityLight() call but can't move the function to a UnityLightingCommon.cginc header because it break UBER shader on asset store...
+		l.color = half3(0, 0, 0);
+		l.dir = half3(0, 1, 0); // Irrelevant direction, just not null
+		l.ndotl = 0; // Not used
+	#endif
+
+	return l;
+}
+
+UnityLight AdditiveLight (half3 lightDir, half atten)
+{
+	UnityLight l;
+
+	l.color = _LightColor0.rgb;
+	l.dir = lightDir;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		l.dir = NormalizePerPixelNormal(l.dir);
+	#endif
+
+	// shadow the light
+	l.color *= atten;
+	return l;
+}
+
+UnityLight DummyLight ()
+{
+	UnityLight l;
+	l.color = 0;
+	l.dir = half3 (0,1,0);
+	return l;
+}
+
+UnityIndirect ZeroIndirect ()
+{
+	UnityIndirect ind;
+	ind.diffuse = 0;
+	ind.specular = 0;
+	return ind;
+}
+
+//-------------------------------------------------------------------------------------
+// Common fragment setup
+
+// deprecated
+half3 WorldNormal(half4 tan2world[3])
+{
+	return normalize(tan2world[2].xyz);
+}
+
+// deprecated
+#ifdef _TANGENT_TO_WORLD
+	half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
+	{
+		half3 t = tan2world[0].xyz;
+		half3 b = tan2world[1].xyz;
+		half3 n = tan2world[2].xyz;
+
+	#if UNITY_TANGENT_ORTHONORMALIZE
+		n = NormalizePerPixelNormal(n);
+
+		// ortho-normalize Tangent
+		t = normalize (t - n * dot(t, n));
+
+		// recalculate Binormal
+		half3 newB = cross(n, t);
+		b = newB * sign (dot (newB, b));
+	#endif
+
+		return half3x3(t, b, n);
+	}
+#else
+	half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
+	{
+		return half3x3(0,0,0,0,0,0,0,0,0);
+	}
+#endif
+
+half3 PerPixelWorldNormal(float4 i_tex, half4 tangentToWorld[3])
+{
+#ifdef _NORMALMAP
+	half3 tangent = tangentToWorld[0].xyz;
+	half3 binormal = tangentToWorld[1].xyz;
+	half3 normal = tangentToWorld[2].xyz;
+
+	#if UNITY_TANGENT_ORTHONORMALIZE
+		normal = NormalizePerPixelNormal(normal);
+
+		// ortho-normalize Tangent
+		tangent = normalize (tangent - normal * dot(tangent, normal));
+
+		// recalculate Binormal
+		half3 newB = cross(normal, tangent);
+		binormal = newB * sign (dot (newB, binormal));
+	#endif
+
+	half3 normalTangent = NormalInTangentSpace(i_tex);
+	half3 normalWorld = NormalizePerPixelNormal(tangent * normalTangent.x + binormal * normalTangent.y + normal * normalTangent.z); // @TODO: see if we can squeeze this normalize on SM2.0 as well
+#else
+	half3 normalWorld = normalize(tangentToWorld[2].xyz);
+#endif
+	return normalWorld;
+}
+
+#ifdef _PARALLAXMAP
+	#define IN_VIEWDIR4PARALLAX(i) NormalizePerPixelNormal(half3(i.tangentToWorldAndParallax[0].w,i.tangentToWorldAndParallax[1].w,i.tangentToWorldAndParallax[2].w))
+	#define IN_VIEWDIR4PARALLAX_FWDADD(i) NormalizePerPixelNormal(i.viewDirForParallax.xyz)
+#else
+	#define IN_VIEWDIR4PARALLAX(i) half3(0,0,0)
+	#define IN_VIEWDIR4PARALLAX_FWDADD(i) half3(0,0,0)
+#endif
+
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	#define IN_WORLDPOS(i) i.posWorld
+#else
+	#define IN_WORLDPOS(i) half3(0,0,0)
+#endif
+
+#define IN_LIGHTDIR_FWDADD(i) half3(i.tangentToWorldAndLightDir[0].w, i.tangentToWorldAndLightDir[1].w, i.tangentToWorldAndLightDir[2].w)
+
+#define FRAGMENT_SETUP(x) FragmentCommonData x = \
+	FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX(i), i.tangentToWorldAndParallax, IN_WORLDPOS(i));
+
+#define FRAGMENT_SETUP_FWDADD(x) FragmentCommonData x = \
+	FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX_FWDADD(i), i.tangentToWorldAndLightDir, half3(0,0,0));
+
+struct FragmentCommonData
+{
+	half3 diffColor, specColor;
+	// Note: smoothness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level.
+	// Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots.
+	half oneMinusReflectivity, smoothness;
+	half3 normalWorld, eyeVec, posWorld;
+	half alpha;
+
+#if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE
+	half3 reflUVW;
+#endif
+
+#if UNITY_STANDARD_SIMPLE
+	half3 tangentSpaceNormal;
+#endif
+};
+
+#ifndef UNITY_SETUP_BRDF_INPUT
+	#define UNITY_SETUP_BRDF_INPUT SpecularSetup
+#endif
+
+inline FragmentCommonData SpecularSetup (float4 i_tex)
+{
+	half4 specGloss = SpecularGloss(i_tex.xy);
+	half3 specColor = specGloss.rgb;
+	half smoothness = specGloss.a;
+
+	half oneMinusReflectivity;
+	half3 diffColor = EnergyConservationBetweenDiffuseAndSpecular (Albedo(i_tex), specColor, /*out*/ oneMinusReflectivity);
+	
+	FragmentCommonData o = (FragmentCommonData)0;
+	o.diffColor = diffColor;
+	o.specColor = specColor;
+	o.oneMinusReflectivity = oneMinusReflectivity;
+	o.smoothness = smoothness;
+	return o;
+}
+
+inline FragmentCommonData MetallicSetup (float4 i_tex)
+{
+	half2 metallicGloss = MetallicGloss(i_tex.xy);
+	half metallic = metallicGloss.x;
+	half smoothness = metallicGloss.y; // this is 1 minus the square root of real roughness m.
+
+	half oneMinusReflectivity;
+	half3 specColor;
+	half3 diffColor = DiffuseAndSpecularFromMetallic (Albedo(i_tex), metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
+
+	FragmentCommonData o = (FragmentCommonData)0;
+	o.diffColor = diffColor;
+	o.specColor = specColor;
+	o.oneMinusReflectivity = oneMinusReflectivity;
+	o.smoothness = smoothness;
+	return o;
+} 
+
+inline FragmentCommonData FragmentSetup (float4 i_tex, half3 i_eyeVec, half3 i_viewDirForParallax, half4 tangentToWorld[3], half3 i_posWorld)
+{
+	i_tex = Parallax(i_tex, i_viewDirForParallax);
+
+	half alpha = Alpha(i_tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData o = UNITY_SETUP_BRDF_INPUT (i_tex);
+	o.normalWorld = PerPixelWorldNormal(i_tex, tangentToWorld);
+	o.eyeVec = NormalizePerPixelNormal(i_eyeVec);
+	o.posWorld = i_posWorld;
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	o.diffColor = PreMultiplyAlpha (o.diffColor, alpha, o.oneMinusReflectivity, /*out*/ o.alpha);
+	return o;
+}
+
+inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light, bool reflections)
+{
+	UnityGIInput d;
+	d.light = light;
+	d.worldPos = s.posWorld;
+	d.worldViewDir = -s.eyeVec;
+	d.atten = atten;
+	#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
+		d.ambient = 0;
+		d.lightmapUV = i_ambientOrLightmapUV;
+	#else
+		d.ambient = i_ambientOrLightmapUV.rgb;
+		d.lightmapUV = 0;
+	#endif
+
+	d.probeHDR[0] = unity_SpecCube0_HDR;
+	d.probeHDR[1] = unity_SpecCube1_HDR;
+	#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION
+	  d.boxMin[0] = unity_SpecCube0_BoxMin; // .w holds lerp value for blending
+	#endif
+	#if UNITY_SPECCUBE_BOX_PROJECTION
+	  d.boxMax[0] = unity_SpecCube0_BoxMax;
+	  d.probePosition[0] = unity_SpecCube0_ProbePosition;
+	  d.boxMax[1] = unity_SpecCube1_BoxMax;
+	  d.boxMin[1] = unity_SpecCube1_BoxMin;
+	  d.probePosition[1] = unity_SpecCube1_ProbePosition;
+	#endif
+
+	if(reflections)
+	{
+		Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.smoothness, -s.eyeVec, s.normalWorld, s.specColor);
+		// Replace the reflUVW if it has been compute in Vertex shader. Note: the compiler will optimize the calcul in UnityGlossyEnvironmentSetup itself
+		#if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE
+			g.reflUVW = s.reflUVW;
+		#endif
+
+		return UnityGlobalIllumination (d, occlusion, s.normalWorld, g);
+	}
+	else
+	{
+		return UnityGlobalIllumination (d, occlusion, s.normalWorld);
+	}
+}
+
+inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light)
+{
+	return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, true);
+}
+
+
+//-------------------------------------------------------------------------------------
+half4 OutputForward (half4 output, half alphaFromSurface)
+{
+	#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
+		output.a = alphaFromSurface;
+	#else
+		UNITY_OPAQUE_ALPHA(output.a);
+	#endif
+	return output;
+}
+
+inline half4 VertexGIForward(VertexInput v, float3 posWorld, half3 normalWorld)
+{
+	half4 ambientOrLightmapUV = 0;
+	// Static lightmaps
+	#ifdef LIGHTMAP_ON
+		ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
+		ambientOrLightmapUV.zw = 0;
+	// Sample light probe for Dynamic objects only (no static or dynamic lightmaps)
+	#elif UNITY_SHOULD_SAMPLE_SH
+		#ifdef VERTEXLIGHT_ON
+			// Approximated illumination from non-important point lights
+			ambientOrLightmapUV.rgb = Shade4PointLights (
+				unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
+				unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,
+				unity_4LightAtten0, posWorld, normalWorld);
+		#endif
+
+		ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, ambientOrLightmapUV.rgb);		
+	#endif
+
+	#ifdef DYNAMICLIGHTMAP_ON
+		ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+	#endif
+
+	return ambientOrLightmapUV;
+}
+
+// ------------------------------------------------------------------
+//  Base forward pass (directional light, emission, lightmaps, ...)
+
+struct VertexOutputForwardBase
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndParallax[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:viewDirForParallax]
+	half4 ambientOrLightmapUV			: TEXCOORD5;	// SH or Lightmap UV
+	SHADOW_COORDS(6)
+	UNITY_FOG_COORDS(7)
+
+	// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		float3 posWorld					: TEXCOORD8;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		#if UNITY_REQUIRE_FRAG_WORLDPOS
+			half3 reflUVW				: TEXCOORD9;
+		#else
+			half3 reflUVW				: TEXCOORD8;
+		#endif
+	#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutputForwardBase vertForwardBase (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputForwardBase o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardBase, o);
+	UNITY_TRANSFER_INSTANCE_ID(v, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		o.posWorld = posWorld.xyz;
+	#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+		
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndParallax[0].xyz = 0;
+		o.tangentToWorldAndParallax[1].xyz = 0;
+		o.tangentToWorldAndParallax[2].xyz = normalWorld;
+	#endif
+	//We need this for shadow receving
+	TRANSFER_SHADOW(o);
+
+	o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
+	
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+		o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
+		o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
+		o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		o.reflUVW 		= reflect(o.eyeVec, normalWorld);
+	#endif
+
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+half4 fragForwardBaseInternal (VertexOutputForwardBase i)
+{
+	FRAGMENT_SETUP(s)
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW		= i.reflUVW;
+#endif
+	
+	UNITY_SETUP_INSTANCE_ID(i);
+
+	UnityLight mainLight = MainLight ();
+	half atten = SHADOW_ATTENUATION(i);
+
+
+	half occlusion = Occlusion(i.tex.xy);
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
+
+	half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
+	c.rgb += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+	c.rgb += Emission(i.tex.xy);
+
+	UNITY_APPLY_FOG(i.fogCoord, c.rgb);
+	return OutputForward (c, s.alpha);
+}
+
+half4 fragForwardBase (VertexOutputForwardBase i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardBaseInternal(i);
+}
+
+// ------------------------------------------------------------------
+//  Additive forward pass (one light per pass)
+
+struct VertexOutputForwardAdd
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndLightDir[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:lightDir]
+	LIGHTING_COORDS(5,6)
+	UNITY_FOG_COORDS(7)
+
+	// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
+#if defined(_PARALLAXMAP)
+	half3 viewDirForParallax			: TEXCOORD8;
+#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutputForwardAdd vertForwardAdd (VertexInput v)
+{
+	VertexOutputForwardAdd o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAdd, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	o.pos = UnityObjectToClipPos(v.vertex);
+
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndLightDir[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndLightDir[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndLightDir[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndLightDir[0].xyz = 0;
+		o.tangentToWorldAndLightDir[1].xyz = 0;
+		o.tangentToWorldAndLightDir[2].xyz = normalWorld;
+	#endif
+	//We need this for shadow receiving
+	TRANSFER_VERTEX_TO_FRAGMENT(o);
+
+	float3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		lightDir = NormalizePerVertexNormal(lightDir);
+	#endif
+	o.tangentToWorldAndLightDir[0].w = lightDir.x;
+	o.tangentToWorldAndLightDir[1].w = lightDir.y;
+	o.tangentToWorldAndLightDir[2].w = lightDir.z;
+
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		o.viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+	#endif
+	
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+half4 fragForwardAddInternal (VertexOutputForwardAdd i)
+{
+	FRAGMENT_SETUP_FWDADD(s)
+
+	UnityLight light = AdditiveLight (IN_LIGHTDIR_FWDADD(i), LIGHT_ATTENUATION(i));
+	UnityIndirect noIndirect = ZeroIndirect ();
+
+	half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, light, noIndirect);
+	
+	UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
+	return OutputForward (c, s.alpha);
+}
+
+half4 fragForwardAdd (VertexOutputForwardAdd i) : SV_Target		// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardAddInternal(i);
+}
+
+// ------------------------------------------------------------------
+//  Deferred pass
+
+struct VertexOutputDeferred
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndParallax[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:viewDirForParallax]
+	half4 ambientOrLightmapUV			: TEXCOORD5;	// SH or Lightmap UVs
+
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		float3 posWorld						: TEXCOORD6;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		#if UNITY_REQUIRE_FRAG_WORLDPOS
+			half3 reflUVW				: TEXCOORD7;
+		#else
+			half3 reflUVW				: TEXCOORD6;
+		#endif
+	#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+
+VertexOutputDeferred vertDeferred (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputDeferred o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputDeferred, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		o.posWorld = posWorld;
+	#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndParallax[0].xyz = 0;
+		o.tangentToWorldAndParallax[1].xyz = 0;
+		o.tangentToWorldAndParallax[2].xyz = normalWorld;
+	#endif
+
+	o.ambientOrLightmapUV = 0;
+	#ifdef LIGHTMAP_ON
+		o.ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
+	#elif UNITY_SHOULD_SAMPLE_SH
+		o.ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, o.ambientOrLightmapUV.rgb);
+	#endif
+	#ifdef DYNAMICLIGHTMAP_ON
+		o.ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+	#endif
+	
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+		o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
+		o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
+		o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		o.reflUVW		= reflect(o.eyeVec, normalWorld);
+	#endif
+
+	return o;
+}
+
+void fragDeferred (
+	VertexOutputDeferred i,
+	out half4 outGBuffer0 : SV_Target0,
+	out half4 outGBuffer1 : SV_Target1,
+	out half4 outGBuffer2 : SV_Target2,
+	out half4 outEmission : SV_Target3			// RT3: emission (rgb), --unused-- (a)
+)
+{
+	#if (SHADER_TARGET < 30)
+		outGBuffer0 = 1;
+		outGBuffer1 = 1;
+		outGBuffer2 = 0;
+		outEmission = 0;
+		return;
+	#endif
+
+	FRAGMENT_SETUP(s)
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW		= i.reflUVW;
+#endif
+
+	// no analytic lights in this pass
+	UnityLight dummyLight = DummyLight ();
+	half atten = 1;
+
+	// only GI
+	half occlusion = Occlusion(i.tex.xy);
+#if UNITY_ENABLE_REFLECTION_BUFFERS
+	bool sampleReflectionsInDeferred = false;
+#else
+	bool sampleReflectionsInDeferred = true;
+#endif
+
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, dummyLight, sampleReflectionsInDeferred);
+
+	half3 emissiveColor = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb;
+	emissiveColor += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+
+	#ifdef _EMISSION
+		emissiveColor += Emission (i.tex.xy);
+	#endif
+
+	#ifndef UNITY_HDR_ON
+		emissiveColor.rgb = exp2(-emissiveColor.rgb);
+	#endif
+
+	UnityStandardData data;
+	data.diffuseColor	= s.diffColor;
+	data.occlusion		= occlusion;		
+	data.specularColor	= s.specColor;
+	data.smoothness		= s.smoothness;	
+	data.normalWorld	= s.normalWorld;
+
+	UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
+
+	// Emisive lighting buffer
+	outEmission = half4(emissiveColor, 1);
+}
+
+
+//
+// Old FragmentGI signature. Kept only for backward compatibility and will be removed soon
+//
+
+inline UnityGI FragmentGI(
+	float3 posWorld,
+	half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
+	UnityLight light,
+	bool reflections)
+{
+	// we init only fields actually used
+	FragmentCommonData s = (FragmentCommonData)0;
+	s.smoothness = smoothness;
+	s.normalWorld = normalWorld;
+	s.eyeVec = eyeVec;
+	s.posWorld = posWorld;
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW = reflect(eyeVec, normalWorld);
+#endif
+	return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, reflections);
+}
+inline UnityGI FragmentGI (
+	float3 posWorld,
+	half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
+	UnityLight light)
+{
+	return FragmentGI (posWorld, occlusion, i_ambientOrLightmapUV, atten, smoothness, normalWorld, eyeVec, light, true);
+}
+
+#endif // UNITY_STANDARD_CORE_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCore.cginc.meta

+fileFormatVersion: 2
+guid: d9211ce30812ca24a9312d8cbd44065e
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCoreForward.cginc

+#ifndef UNITY_STANDARD_CORE_FORWARD_INCLUDED
+#define UNITY_STANDARD_CORE_FORWARD_INCLUDED
+
+#if defined(UNITY_NO_FULL_STANDARD_SHADER)
+#	define UNITY_STANDARD_SIMPLE 1
+#endif
+
+#include "UnityStandardConfig.cginc"
+
+#if UNITY_STANDARD_SIMPLE
+	#include "UnityStandardCoreForwardSimple.cginc"
+	VertexOutputBaseSimple vertBase (VertexInput v) { return vertForwardBaseSimple(v); }
+	VertexOutputForwardAddSimple vertAdd (VertexInput v) { return vertForwardAddSimple(v); }
+	half4 fragBase (VertexOutputBaseSimple i) : SV_Target { return fragForwardBaseSimpleInternal(i); }
+	half4 fragAdd (VertexOutputForwardAddSimple i) : SV_Target { return fragForwardAddSimpleInternal(i); }
+#else
+	#include "UnityStandardCore.cginc"
+	VertexOutputForwardBase vertBase (VertexInput v) { return vertForwardBase(v); }
+	VertexOutputForwardAdd vertAdd (VertexInput v) { return vertForwardAdd(v); }
+	half4 fragBase (VertexOutputForwardBase i) : SV_Target { return fragForwardBaseInternal(i); }
+	half4 fragAdd (VertexOutputForwardAdd i) : SV_Target { return fragForwardAddInternal(i); }
+#endif
+
+#endif // UNITY_STANDARD_CORE_FORWARD_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCoreForward.cginc.meta

+fileFormatVersion: 2
+guid: 8181a6a9f521bae49a913611fd994f28
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCoreForwardSimple.cginc

+#ifndef UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
+#define UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
+
+#include "UnityStandardCore.cginc"
+
+//  Does not support: _PARALLAXMAP, DIRLIGHTMAP_COMBINED, DIRLIGHTMAP_SEPARATE
+#define GLOSSMAP (defined(_SPECGLOSSMAP) || defined(_METALLICGLOSSMAP))
+
+#ifndef SPECULAR_HIGHLIGHTS
+	#define SPECULAR_HIGHLIGHTS (!defined(_SPECULAR_HIGHLIGHTS_OFF))
+#endif
+
+struct VertexOutputBaseSimple
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half4 eyeVec 						: TEXCOORD1; // w: grazingTerm
+
+	half4 ambientOrLightmapUV			: TEXCOORD2; // SH or Lightmap UV
+	SHADOW_COORDS(3)
+	UNITY_FOG_COORDS_PACKED(4, half4) // x: fogCoord, yzw: reflectVec
+
+	half4 normalWorld					: TEXCOORD5; // w: fresnelTerm
+
+#ifdef _NORMALMAP
+	half3 tangentSpaceLightDir			: TEXCOORD6;
+	#if SPECULAR_HIGHLIGHTS
+		half3 tangentSpaceEyeVec		: TEXCOORD7;
+	#endif
+#endif
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	float3 posWorld						: TEXCOORD8;
+#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+// UNIFORM_REFLECTIVITY(): workaround to get (uniform) reflecivity based on UNITY_SETUP_BRDF_INPUT
+half MetallicSetup_Reflectivity()
+{
+	return 1.0h - OneMinusReflectivityFromMetallic(_Metallic);
+}
+
+half SpecularSetup_Reflectivity()
+{
+	return SpecularStrength(_SpecColor.rgb);
+}
+
+#define JOIN2(a, b) a##b
+#define JOIN(a, b) JOIN2(a,b)
+#define UNIFORM_REFLECTIVITY JOIN(UNITY_SETUP_BRDF_INPUT, _Reflectivity)
+
+
+#ifdef _NORMALMAP
+
+half3 TransformToTangentSpace(half3 tangent, half3 binormal, half3 normal, half3 v)
+{
+	// Mali400 shader compiler prefers explicit dot product over using a half3x3 matrix
+	return half3(dot(tangent, v), dot(binormal, v), dot(normal, v));
+}
+
+void TangentSpaceLightingInput(half3 normalWorld, half4 vTangent, half3 lightDirWorld, half3 eyeVecWorld, out half3 tangentSpaceLightDir, out half3 tangentSpaceEyeVec)
+{
+	half3 tangentWorld = UnityObjectToWorldDir(vTangent.xyz);
+	half sign = half(vTangent.w) * half(unity_WorldTransformParams.w);
+	half3 binormalWorld = cross(normalWorld, tangentWorld) * sign;
+	tangentSpaceLightDir = TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, lightDirWorld);
+	#if SPECULAR_HIGHLIGHTS
+		tangentSpaceEyeVec = normalize(TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, eyeVecWorld));
+	#else
+		tangentSpaceEyeVec = 0;
+	#endif
+}
+
+#endif // _NORMALMAP
+
+VertexOutputBaseSimple vertForwardBaseSimple (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputBaseSimple o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputBaseSimple, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	o.posWorld = posWorld.xyz;
+#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.tex = TexCoords(v);
+	
+	half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
+	half3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	
+	o.normalWorld.xyz = normalWorld;
+	o.eyeVec.xyz = eyeVec;
+
+	#ifdef _NORMALMAP
+		half3 tangentSpaceEyeVec;
+		TangentSpaceLightingInput(normalWorld, v.tangent, _WorldSpaceLightPos0.xyz, eyeVec, o.tangentSpaceLightDir, tangentSpaceEyeVec);
+		#if SPECULAR_HIGHLIGHTS
+			o.tangentSpaceEyeVec = tangentSpaceEyeVec;
+		#endif
+	#endif
+
+	//We need this for shadow receiving
+	TRANSFER_SHADOW(o);
+
+	o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
+
+	o.fogCoord.yzw = reflect(eyeVec, normalWorld);
+
+	o.normalWorld.w = Pow4(1 - saturate(dot(normalWorld, -eyeVec))); // fresnel term
+	#if !GLOSSMAP
+		o.eyeVec.w = saturate(_Glossiness + UNIFORM_REFLECTIVITY()); // grazing term
+	#endif
+
+	UNITY_TRANSFER_FOG(o, o.pos);
+	return o;
+}
+
+
+FragmentCommonData FragmentSetupSimple(VertexOutputBaseSimple i)
+{
+	half alpha = Alpha(i.tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
+
+	s.normalWorld = i.normalWorld.xyz;
+	s.eyeVec = i.eyeVec.xyz;
+	s.posWorld = IN_WORLDPOS(i);
+	s.reflUVW = i.fogCoord.yzw;
+
+	#ifdef _NORMALMAP
+		s.tangentSpaceNormal =  NormalInTangentSpace(i.tex);
+	#else
+		s.tangentSpaceNormal =  0;
+	#endif
+
+	return s;
+}
+
+UnityLight MainLightSimple(VertexOutputBaseSimple i, FragmentCommonData s)
+{
+	UnityLight mainLight = MainLight();
+	return mainLight;
+}
+
+half PerVertexGrazingTerm(VertexOutputBaseSimple i, FragmentCommonData s)
+{
+	#if GLOSSMAP
+		return saturate(s.smoothness + (1-s.oneMinusReflectivity));
+	#else
+		return i.eyeVec.w;
+	#endif
+}
+
+half PerVertexFresnelTerm(VertexOutputBaseSimple i)
+{
+	return i.normalWorld.w;
+}
+
+#if !SPECULAR_HIGHLIGHTS
+#	define REFLECTVEC_FOR_SPECULAR(i, s) half3(0, 0, 0)
+#elif defined(_NORMALMAP)
+#	define REFLECTVEC_FOR_SPECULAR(i, s) reflect(i.tangentSpaceEyeVec, s.tangentSpaceNormal)
+#else
+#	define REFLECTVEC_FOR_SPECULAR(i, s) s.reflUVW
+#endif
+
+half3 LightDirForSpecular(VertexOutputBaseSimple i, UnityLight mainLight)
+{
+	#if SPECULAR_HIGHLIGHTS && defined(_NORMALMAP)
+		return i.tangentSpaceLightDir;
+	#else
+		return mainLight.dir;
+	#endif
+}
+
+half3 BRDF3DirectSimple(half3 diffColor, half3 specColor, half smoothness, half rl)
+{
+	#if SPECULAR_HIGHLIGHTS
+		return BRDF3_Direct(diffColor, specColor, Pow4(rl), smoothness);
+	#else
+		return diffColor;
+	#endif
+}
+
+half4 fragForwardBaseSimpleInternal (VertexOutputBaseSimple i)
+{
+	FragmentCommonData s = FragmentSetupSimple(i);
+
+	UnityLight mainLight = MainLightSimple(i, s);
+	
+	#if !defined(LIGHTMAP_ON) && defined(_NORMALMAP)
+	half ndotl = saturate(dot(s.tangentSpaceNormal, i.tangentSpaceLightDir));
+	#else
+	half ndotl = saturate(dot(s.normalWorld, mainLight.dir));
+	#endif
+	
+	half atten = SHADOW_ATTENUATION(i);
+	
+	half occlusion = Occlusion(i.tex.xy);
+	half rl = dot(REFLECTVEC_FOR_SPECULAR(i, s), LightDirForSpecular(i, mainLight));
+	
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
+	half3 attenuatedLightColor = gi.light.color * ndotl;
+
+	half3 c = BRDF3_Indirect(s.diffColor, s.specColor, gi.indirect, PerVertexGrazingTerm(i, s), PerVertexFresnelTerm(i));
+	c += BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, rl) * attenuatedLightColor;
+	c += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+	c += Emission(i.tex.xy);
+
+	UNITY_APPLY_FOG(i.fogCoord, c);
+	
+	return OutputForward (half4(c, 1), s.alpha);
+}
+
+half4 fragForwardBaseSimple (VertexOutputBaseSimple i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardBaseSimpleInternal(i);
+}
+
+struct VertexOutputForwardAddSimple
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+
+	LIGHTING_COORDS(1,2)
+
+#if !defined(_NORMALMAP) && SPECULAR_HIGHLIGHTS
+	UNITY_FOG_COORDS_PACKED(3, half4) // x: fogCoord, yzw: reflectVec
+#else
+	UNITY_FOG_COORDS_PACKED(3, half1)
+#endif
+
+	half3 lightDir						: TEXCOORD4;
+
+#if defined(_NORMALMAP)
+	#if SPECULAR_HIGHLIGHTS
+		half3 tangentSpaceEyeVec		: TEXCOORD5;
+	#endif
+#else
+	half3 normalWorld					: TEXCOORD5;
+#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutputForwardAddSimple vertForwardAddSimple (VertexInput v)
+{
+	VertexOutputForwardAddSimple o;
+	UNITY_SETUP_INSTANCE_ID(v);
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAddSimple, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.tex = TexCoords(v);
+
+	//We need this for shadow receiving
+	TRANSFER_VERTEX_TO_FRAGMENT(o);
+
+	half3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		lightDir = NormalizePerVertexNormal(lightDir);
+	#endif
+
+	#if SPECULAR_HIGHLIGHTS
+		half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
+	#endif
+
+	half3 normalWorld = UnityObjectToWorldNormal(v.normal);
+
+	#ifdef _NORMALMAP
+		#if SPECULAR_HIGHLIGHTS
+			TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, eyeVec, o.lightDir, o.tangentSpaceEyeVec);
+		#else
+			half3 ignore;
+			TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, 0, o.lightDir, ignore);
+		#endif
+	#else
+		o.lightDir = lightDir;
+		o.normalWorld = normalWorld;
+		#if SPECULAR_HIGHLIGHTS
+			o.fogCoord.yzw = reflect(eyeVec, normalWorld);
+		#endif
+	#endif
+
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+FragmentCommonData FragmentSetupSimpleAdd(VertexOutputForwardAddSimple i)
+{
+	half alpha = Alpha(i.tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
+
+	s.eyeVec = 0;
+	s.posWorld = 0;
+
+	#ifdef _NORMALMAP
+		s.tangentSpaceNormal = NormalInTangentSpace(i.tex);
+		s.normalWorld = 0;
+	#else
+		s.tangentSpaceNormal = 0;
+		s.normalWorld = i.normalWorld;
+	#endif
+
+	#if SPECULAR_HIGHLIGHTS && !defined(_NORMALMAP)
+		s.reflUVW = i.fogCoord.yzw;
+	#else
+		s.reflUVW = 0;
+	#endif
+
+	return s;
+}
+
+half3 LightSpaceNormal(VertexOutputForwardAddSimple i, FragmentCommonData s)
+{
+	#ifdef _NORMALMAP
+		return s.tangentSpaceNormal;
+	#else
+		return i.normalWorld;
+	#endif
+}
+
+half4 fragForwardAddSimpleInternal (VertexOutputForwardAddSimple i)
+{
+	FragmentCommonData s = FragmentSetupSimpleAdd(i);
+
+	half3 c = BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, dot(REFLECTVEC_FOR_SPECULAR(i, s), i.lightDir));
+
+	#if SPECULAR_HIGHLIGHTS // else diffColor has premultiplied light color
+		c *= _LightColor0.rgb;
+	#endif
+
+	c *= LIGHT_ATTENUATION(i) * saturate(dot(LightSpaceNormal(i, s), i.lightDir));
+	
+	UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
+	return OutputForward (half4(c, 1), s.alpha);
+}
+
+half4 fragForwardAddSimple (VertexOutputForwardAddSimple i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardAddSimpleInternal(i);
+}
+
+#endif // UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardCoreForwardSimple.cginc.meta

+fileFormatVersion: 2
+guid: 55b67da802f90f74888e841bea68ded5
+timeCreated: 1479834220
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardInput.cginc

+#ifndef UNITY_STANDARD_INPUT_INCLUDED
+#define UNITY_STANDARD_INPUT_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityShaderVariables.cginc"
+#include "UnityInstancing.cginc"
+#include "UnityStandardConfig.cginc"
+#include "UnityPBSLighting.cginc" // TBD: remove
+#include "UnityStandardUtils.cginc"
+
+//---------------------------------------
+// Directional lightmaps & Parallax require tangent space too
+#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || DIRLIGHTMAP_SEPARATE || _PARALLAXMAP)
+	#define _TANGENT_TO_WORLD 1 
+#endif
+
+#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP)
+	#define _DETAIL 1
+#endif
+
+//---------------------------------------
+half4		_Color;
+half		_Cutoff;
+
+sampler2D	_MainTex;
+float4		_MainTex_ST;
+
+sampler2D	_DetailAlbedoMap;
+float4		_DetailAlbedoMap_ST;
+
+sampler2D	_BumpMap;
+half		_BumpScale;
+
+sampler2D	_DetailMask;
+sampler2D	_DetailNormalMap;
+half		_DetailNormalMapScale;
+
+sampler2D	_SpecGlossMap;
+sampler2D	_MetallicGlossMap;
+half		_Metallic;
+half		_Glossiness;
+half		_GlossMapScale;
+
+sampler2D	_OcclusionMap;
+half		_OcclusionStrength;
+
+sampler2D	_ParallaxMap;
+half		_Parallax;
+half		_UVSec;
+
+half4 		_EmissionColor;
+sampler2D	_EmissionMap;
+
+//-------------------------------------------------------------------------------------
+// Input functions
+
+struct VertexInput
+{
+	float4 vertex	: POSITION;
+	half3 normal	: NORMAL;
+	float2 uv0		: TEXCOORD0;
+	float2 uv1		: TEXCOORD1;
+#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
+	float2 uv2		: TEXCOORD2;
+#endif
+#ifdef _TANGENT_TO_WORLD
+	half4 tangent	: TANGENT;
+#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+float4 TexCoords(VertexInput v)
+{
+	float4 texcoord;
+	texcoord.xy = TRANSFORM_TEX(v.uv0, _MainTex); // Always source from uv0
+	texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
+	return texcoord;
+}		
+
+half DetailMask(float2 uv)
+{
+	return tex2D (_DetailMask, uv).a;
+}
+
+half3 Albedo(float4 texcoords)
+{
+	half3 albedo = _Color.rgb * tex2D (_MainTex, texcoords.xy).rgb;
+#if _DETAIL
+	#if (SHADER_TARGET < 30)
+		// SM20: instruction count limitation
+		// SM20: no detail mask
+		half mask = 1; 
+	#else
+		half mask = DetailMask(texcoords.xy);
+	#endif
+	half3 detailAlbedo = tex2D (_DetailAlbedoMap, texcoords.zw).rgb;
+	#if _DETAIL_MULX2
+		albedo *= LerpWhiteTo (detailAlbedo * unity_ColorSpaceDouble.rgb, mask);
+	#elif _DETAIL_MUL
+		albedo *= LerpWhiteTo (detailAlbedo, mask);
+	#elif _DETAIL_ADD
+		albedo += detailAlbedo * mask;
+	#elif _DETAIL_LERP
+		albedo = lerp (albedo, detailAlbedo, mask);
+	#endif
+#endif
+	return albedo;
+}
+
+half Alpha(float2 uv)
+{
+#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+	return _Color.a;
+#else
+	return tex2D(_MainTex, uv).a * _Color.a;
+#endif
+}		
+
+half Occlusion(float2 uv)
+{
+#if (SHADER_TARGET < 30)
+	// SM20: instruction count limitation
+	// SM20: simpler occlusion
+	return tex2D(_OcclusionMap, uv).g;
+#else
+	half occ = tex2D(_OcclusionMap, uv).g;
+	return LerpOneTo (occ, _OcclusionStrength);
+#endif
+}
+
+half4 SpecularGloss(float2 uv)
+{
+	half4 sg;
+#ifdef _SPECGLOSSMAP
+	#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+		sg.rgb = tex2D(_SpecGlossMap, uv).rgb;
+		sg.a = tex2D(_MainTex, uv).a;
+	#else
+		sg = tex2D(_SpecGlossMap, uv);
+	#endif
+	sg.a *= _GlossMapScale;
+#else
+	sg.rgb = _SpecColor.rgb;
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		sg.a = tex2D(_MainTex, uv).a * _GlossMapScale;
+	#else
+		sg.a = _Glossiness;
+	#endif
+#endif
+	return sg;
+}
+
+half2 MetallicGloss(float2 uv)
+{
+	half2 mg;
+	
+#ifdef _METALLICGLOSSMAP
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		mg.r = tex2D(_MetallicGlossMap, uv).r;
+		mg.g = tex2D(_MainTex, uv).a;
+	#else
+		mg = tex2D(_MetallicGlossMap, uv).ra;
+	#endif
+	mg.g *= _GlossMapScale;
+#else
+	mg.r = _Metallic;
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		mg.g = tex2D(_MainTex, uv).a * _GlossMapScale;
+	#else
+		mg.g = _Glossiness;
+	#endif
+#endif
+	return mg;
+}
+
+half3 Emission(float2 uv)
+{
+#ifndef _EMISSION
+	return 0;
+#else
+	return tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb;
+#endif
+}
+
+#ifdef _NORMALMAP
+half3 NormalInTangentSpace(float4 texcoords)
+{
+	half3 normalTangent = UnpackScaleNormal(tex2D (_BumpMap, texcoords.xy), _BumpScale);
+
+#if _DETAIL && defined(UNITY_ENABLE_DETAIL_NORMALMAP)
+	half mask = DetailMask(texcoords.xy);
+	half3 detailNormalTangent = UnpackScaleNormal(tex2D (_DetailNormalMap, texcoords.zw), _DetailNormalMapScale);
+	#if _DETAIL_LERP
+		normalTangent = lerp(
+			normalTangent,
+			detailNormalTangent,
+			mask);
+	#else
+		normalTangent = lerp(
+			normalTangent,
+			BlendNormals(normalTangent, detailNormalTangent),
+			mask);
+	#endif
+#endif
+
+	return normalTangent;
+}
+#endif
+
+float4 Parallax (float4 texcoords, half3 viewDir)
+{
+// D3D9/SM30 supports up to 16 samplers, skip the parallax map in case we exceed the limit
+#define EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT	(defined(LIGHTMAP_ON) && defined(DIRLIGHTMAP_SEPARATE) && defined(SHADOWS_SCREEN) && defined(_NORMALMAP) && \
+											 defined(_EMISSION) && defined(_DETAIL) && (defined(_METALLICGLOSSMAP) || defined(_SPECGLOSSMAP)))
+
+#if !defined(_PARALLAXMAP) || (SHADER_TARGET < 30) || (defined(SHADER_API_D3D9) && EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT)
+	// SM20: instruction count limitation
+	// SM20: no parallax
+	return texcoords;
+#else
+	half h = tex2D (_ParallaxMap, texcoords.xy).g;
+	float2 offset = ParallaxOffset1Step (h, _Parallax, viewDir);
+	return float4(texcoords.xy + offset, texcoords.zw + offset);
+#endif
+
+#undef EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT
+}
+			
+#endif // UNITY_STANDARD_INPUT_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardInput.cginc.meta

+fileFormatVersion: 2
+guid: c3243dab058b7ec4caef11d3e6cdc52f
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardMeta.cginc

+#ifndef UNITY_STANDARD_META_INCLUDED
+#define UNITY_STANDARD_META_INCLUDED
+
+// Functionality for Standard shader "meta" pass
+// (extracts albedo/emission for lightmapper etc.)
+
+// define meta pass before including other files; they have conditions
+// on that in some places
+#define UNITY_PASS_META 1
+
+#include "UnityCG.cginc"
+#include "UnityStandardInput.cginc"
+#include "UnityMetaPass.cginc"
+#include "UnityStandardCore.cginc"
+
+struct v2f_meta
+{
+	float4 uv		: TEXCOORD0;
+	float4 pos		: SV_POSITION;
+};
+
+v2f_meta vert_meta (VertexInput v)
+{
+	v2f_meta o;
+	o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
+	o.uv = TexCoords(v);
+	return o;
+}
+
+// Albedo for lightmapping should basically be diffuse color.
+// But rough metals (black diffuse) still scatter quite a lot of light around, so
+// we want to take some of that into account too.
+half3 UnityLightmappingAlbedo (half3 diffuse, half3 specular, half smoothness)
+{
+	half roughness = SmoothnessToRoughness(smoothness);
+	half3 res = diffuse;
+	res += specular * roughness * 0.5;
+	return res;
+}
+
+float4 frag_meta (v2f_meta i) : SV_Target
+{
+	// we're interested in diffuse & specular colors,
+	// and surface roughness to produce final albedo.
+	FragmentCommonData data = UNITY_SETUP_BRDF_INPUT (i.uv);
+
+	UnityMetaInput o;
+	UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
+
+#if defined(EDITOR_VISUALIZATION)
+	o.Albedo = data.diffColor;
+#else
+	o.Albedo = UnityLightmappingAlbedo (data.diffColor, data.specColor, data.smoothness);
+#endif
+	o.SpecularColor = data.specColor;
+	o.Emission = Emission(i.uv.xy);
+
+	return UnityMetaFragment(o);
+}
+
+#endif // UNITY_STANDARD_META_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardMeta.cginc.meta

+fileFormatVersion: 2
+guid: 405a71a6302a48b4eb0be3ff1e2fab23
+timeCreated: 1479834220
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardShadow.cginc

+#ifndef UNITY_STANDARD_SHADOW_INCLUDED
+#define UNITY_STANDARD_SHADOW_INCLUDED
+
+// NOTE: had to split shadow functions into separate file,
+// otherwise compiler gives trouble with LIGHTING_COORDS macro (in UnityStandardCore.cginc)
+
+
+#include "UnityCG.cginc"
+#include "UnityShaderVariables.cginc"
+#include "UnityInstancing.cginc"
+#include "UnityStandardConfig.cginc"
+#include "UnityStandardUtils.cginc"
+
+#if (defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)) && defined(UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS)
+	#define UNITY_STANDARD_USE_DITHER_MASK 1
+#endif
+
+// Need to output UVs in shadow caster, since we need to sample texture and do clip/dithering based on it
+#if defined(_ALPHATEST_ON) || defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
+#define UNITY_STANDARD_USE_SHADOW_UVS 1
+#endif
+
+// Has a non-empty shadow caster output struct (it's an error to have empty structs on some platforms...)
+#if !defined(V2F_SHADOW_CASTER_NOPOS_IS_EMPTY) || defined(UNITY_STANDARD_USE_SHADOW_UVS)
+#define UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT 1
+#endif
+
+#ifdef UNITY_STEREO_INSTANCING_ENABLED
+#define UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT 1
+#endif
+
+
+half4		_Color;
+half		_Cutoff;
+sampler2D	_MainTex;
+float4		_MainTex_ST;
+#ifdef UNITY_STANDARD_USE_DITHER_MASK
+sampler3D	_DitherMaskLOD;
+#endif
+
+// Handle PremultipliedAlpha from Fade or Transparent shading mode
+half4		_SpecColor;
+half		_Metallic;
+#ifdef _SPECGLOSSMAP
+sampler2D	_SpecGlossMap;
+#endif
+#ifdef _METALLICGLOSSMAP
+sampler2D	_MetallicGlossMap;
+#endif
+
+#if defined(UNITY_STANDARD_USE_SHADOW_UVS) && defined(_PARALLAXMAP)
+sampler2D	_ParallaxMap;
+half		_Parallax;
+#endif
+
+half MetallicSetup_ShadowGetOneMinusReflectivity(half2 uv)
+{
+	half metallicity = _Metallic;
+	#ifdef _METALLICGLOSSMAP
+		metallicity = tex2D(_MetallicGlossMap, uv).r;
+	#endif
+	return OneMinusReflectivityFromMetallic(metallicity);
+}
+
+half SpecularSetup_ShadowGetOneMinusReflectivity(half2 uv)
+{
+	half3 specColor = _SpecColor.rgb;
+	#ifdef _SPECGLOSSMAP
+		specColor = tex2D(_SpecGlossMap, uv).rgb;
+	#endif
+	return (1 - SpecularStrength(specColor));
+}
+
+// SHADOW_ONEMINUSREFLECTIVITY(): workaround to get one minus reflectivity based on UNITY_SETUP_BRDF_INPUT
+#define SHADOW_JOIN2(a, b) a##b
+#define SHADOW_JOIN(a, b) SHADOW_JOIN2(a,b)
+#define SHADOW_ONEMINUSREFLECTIVITY SHADOW_JOIN(UNITY_SETUP_BRDF_INPUT, _ShadowGetOneMinusReflectivity)
+
+struct VertexInput
+{
+	float4 vertex	: POSITION;
+	float3 normal	: NORMAL;
+	float2 uv0		: TEXCOORD0;
+	#if defined(UNITY_STANDARD_USE_SHADOW_UVS) && defined(_PARALLAXMAP)
+		half4 tangent	: TANGENT;
+	#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
+struct VertexOutputShadowCaster
+{
+	V2F_SHADOW_CASTER_NOPOS
+	#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
+		float2 tex : TEXCOORD1;
+
+		#if defined(_PARALLAXMAP)
+			half4 tangentToWorldAndParallax[3]: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:viewDirForParallax]
+        #endif
+	#endif
+};
+#endif
+
+#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
+struct VertexOutputStereoShadowCaster
+{
+	UNITY_VERTEX_OUTPUT_STEREO 
+};
+#endif
+
+// We have to do these dances of outputting SV_POSITION separately from the vertex shader,
+// and inputting VPOS in the pixel shader, since they both map to "POSITION" semantic on
+// some platforms, and then things don't go well.
+
+
+void vertShadowCaster (VertexInput v,
+	#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
+	out VertexOutputShadowCaster o,
+	#endif
+	#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
+	out VertexOutputStereoShadowCaster os,
+	#endif
+	out float4 opos : SV_POSITION)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
+		UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(os); 
+	#endif
+	TRANSFER_SHADOW_CASTER_NOPOS(o,opos)
+	#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
+		o.tex = TRANSFORM_TEX(v.uv0, _MainTex);
+
+		#ifdef _PARALLAXMAP
+			TANGENT_SPACE_ROTATION;
+			half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+			o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
+			o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
+			o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
+		#endif
+	#endif
+}
+
+half4 fragShadowCaster (
+#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
+	VertexOutputShadowCaster i
+#endif
+#ifdef UNITY_STANDARD_USE_DITHER_MASK
+	, UNITY_VPOS_TYPE vpos : VPOS
+#endif
+	) : SV_Target
+{
+	#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
+		#if defined(_PARALLAXMAP) && (SHADER_TARGET >= 30)
+			//On d3d9 parallax can also be disabled on the fwd pass when too many	 sampler are used. See EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT. Ideally we should account for that here as well.
+			half3 viewDirForParallax = normalize( half3(i.tangentToWorldAndParallax[0].w,i.tangentToWorldAndParallax[1].w,i.tangentToWorldAndParallax[2].w) );
+			fixed h = tex2D (_ParallaxMap, i.tex.xy).g;
+			half2 offset = ParallaxOffset1Step (h, _Parallax, viewDirForParallax);
+			i.tex.xy += offset;
+        #endif
+
+		half alpha = tex2D(_MainTex, i.tex).a * _Color.a;
+		#if defined(_ALPHATEST_ON)
+			clip (alpha - _Cutoff);
+		#endif
+		#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
+			#if defined(_ALPHAPREMULTIPLY_ON)
+				half outModifiedAlpha;
+				PreMultiplyAlpha(half3(0, 0, 0), alpha, SHADOW_ONEMINUSREFLECTIVITY(i.tex), outModifiedAlpha);
+				alpha = outModifiedAlpha;
+			#endif
+			#if defined(UNITY_STANDARD_USE_DITHER_MASK)
+				// Use dither mask for alpha blended shadows, based on pixel position xy
+				// and alpha level. Our dither texture is 4x4x16.
+				half alphaRef = tex3D(_DitherMaskLOD, float3(vpos.xy*0.25,alpha*0.9375)).a;
+				clip (alphaRef - 0.01);
+			#else
+				clip (alpha - _Cutoff);
+			#endif
+		#endif
+	#endif // #if defined(UNITY_STANDARD_USE_SHADOW_UVS)
+
+	SHADOW_CASTER_FRAGMENT(i)
+}			
+
+#endif // UNITY_STANDARD_SHADOW_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardShadow.cginc.meta

+fileFormatVersion: 2
+guid: c32db506fcb289e42952b7d90a5fdefd
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardUtils.cginc

+#ifndef UNITY_STANDARD_UTILS_INCLUDED
+#define UNITY_STANDARD_UTILS_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityStandardConfig.cginc"
+
+// Helper functions, maybe move into UnityCG.cginc
+
+half SpecularStrength(half3 specular)
+{
+	#if (SHADER_TARGET < 30)
+		// SM2.0: instruction count limitation
+		// SM2.0: simplified SpecularStrength
+		return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
+	#else
+		return max (max (specular.r, specular.g), specular.b);
+	#endif
+}
+
+// Diffuse/Spec Energy conservation
+inline half3 EnergyConservationBetweenDiffuseAndSpecular (half3 albedo, half3 specColor, out half oneMinusReflectivity)
+{
+	oneMinusReflectivity = 1 - SpecularStrength(specColor);
+	#if !UNITY_CONSERVE_ENERGY
+		return albedo;
+	#elif UNITY_CONSERVE_ENERGY_MONOCHROME
+		return albedo * oneMinusReflectivity;
+	#else
+		return albedo * (half3(1,1,1) - specColor);
+	#endif
+}
+
+inline half OneMinusReflectivityFromMetallic(half metallic)
+{
+	// We'll need oneMinusReflectivity, so
+	//   1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
+	// store (1-dielectricSpec) in unity_ColorSpaceDielectricSpec.a, then
+	//	 1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) = 
+	//                  = alpha - metallic * alpha
+	half oneMinusDielectricSpec = unity_ColorSpaceDielectricSpec.a;
+	return oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
+}
+
+inline half3 DiffuseAndSpecularFromMetallic (half3 albedo, half metallic, out half3 specColor, out half oneMinusReflectivity)
+{
+	specColor = lerp (unity_ColorSpaceDielectricSpec.rgb, albedo, metallic);
+	oneMinusReflectivity = OneMinusReflectivityFromMetallic(metallic);
+	return albedo * oneMinusReflectivity;
+}
+
+inline half3 PreMultiplyAlpha (half3 diffColor, half alpha, half oneMinusReflectivity, out half outModifiedAlpha)
+{
+	#if defined(_ALPHAPREMULTIPLY_ON)
+		// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+
+		// Transparency 'removes' from Diffuse component
+ 		diffColor *= alpha;
+ 		
+ 		#if (SHADER_TARGET < 30)
+ 			// SM2.0: instruction count limitation
+ 			// Instead will sacrifice part of physically based transparency where amount Reflectivity is affecting Transparency
+ 			// SM2.0: uses unmodified alpha
+ 			outModifiedAlpha = alpha;
+ 		#else
+	 		// Reflectivity 'removes' from the rest of components, including Transparency
+	 		// outAlpha = 1-(1-alpha)*(1-reflectivity) = 1-(oneMinusReflectivity - alpha*oneMinusReflectivity) =
+	 		//          = 1-oneMinusReflectivity + alpha*oneMinusReflectivity
+	 		outModifiedAlpha = 1-oneMinusReflectivity + alpha*oneMinusReflectivity;
+ 		#endif
+ 	#else
+ 		outModifiedAlpha = alpha;
+ 	#endif
+ 	return diffColor;
+}
+
+// Same as ParallaxOffset in Unity CG, except:
+//  *) precision - half instead of float
+half2 ParallaxOffset1Step (half h, half height, half3 viewDir)
+{
+	h = h * height - height/2.0;
+	half3 v = normalize(viewDir);
+	v.z += 0.42;
+	return h * (v.xy / v.z);
+}
+
+half LerpOneTo(half b, half t)
+{
+	half oneMinusT = 1 - t;
+	return oneMinusT + b * t;
+}
+
+half3 LerpWhiteTo(half3 b, half t)
+{
+	half oneMinusT = 1 - t;
+	return half3(oneMinusT, oneMinusT, oneMinusT) + b * t;
+}
+
+half3 UnpackScaleNormal(half4 packednormal, half bumpScale)
+{
+	#if defined(UNITY_NO_DXT5nm)
+		return packednormal.xyz * 2 - 1;
+	#else
+		half3 normal;
+		normal.xy = (packednormal.wy * 2 - 1);
+		#if (SHADER_TARGET >= 30)
+			// SM2.0: instruction count limitation
+			// SM2.0: normal scaler is not supported
+			normal.xy *= bumpScale;
+		#endif
+		normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
+		return normal;
+	#endif
+}		
+
+half3 BlendNormals(half3 n1, half3 n2)
+{
+	return normalize(half3(n1.xy + n2.xy, n1.z*n2.z));
+}
+
+half3x3 CreateTangentToWorldPerVertex(half3 normal, half3 tangent, half tangentSign)
+{
+	// For odd-negative scale transforms we need to flip the sign
+	half sign = tangentSign * unity_WorldTransformParams.w;
+	half3 binormal = cross(normal, tangent) * sign;
+	return half3x3(tangent, binormal, normal);
+}
+
+//-------------------------------------------------------------------------------------
+half3 ShadeSHPerVertex (half3 normal, half3 ambient)
+{
+	#if UNITY_SAMPLE_FULL_SH_PER_PIXEL
+		// Completely per-pixel
+		// nothing to do here
+	#elif (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+		// Completely per-vertex
+		ambient += max(half3(0,0,0), ShadeSH9 (half4(normal, 1.0)));
+	#else
+		// L2 per-vertex, L0..L1 & gamma-correction per-pixel
+
+		// NOTE: SH data is always in Linear AND calculation is split between vertex & pixel
+		// Convert ambient to Linear and do final gamma-correction at the end (per-pixel)
+		#ifdef UNITY_COLORSPACE_GAMMA
+			ambient = GammaToLinearSpace (ambient);
+		#endif
+		ambient += SHEvalLinearL2 (half4(normal, 1.0));		// no max since this is only L2 contribution
+	#endif
+
+	return ambient;
+}
+
+half3 ShadeSHPerPixel (half3 normal, half3 ambient, float3 worldPos)
+{
+	half3 ambient_contrib = 0.0;
+
+	#if UNITY_SAMPLE_FULL_SH_PER_PIXEL
+		// Completely per-pixel
+		ambient_contrib = ShadeSH9 (half4(normal, 1.0));
+		ambient += max(half3(0, 0, 0), ambient_contrib);
+	#elif (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+		// Completely per-vertex
+		// nothing to do here
+	#else
+		// L2 per-vertex, L0..L1 & gamma-correction per-pixel				
+		// Ambient in this case is expected to be always Linear, see ShadeSHPerVertex()
+		#if UNITY_LIGHT_PROBE_PROXY_VOLUME
+			if (unity_ProbeVolumeParams.x == 1.0)
+				ambient_contrib = SHEvalLinearL0L1_SampleProbeVolume (half4(normal, 1.0), worldPos);
+			else
+				ambient_contrib = SHEvalLinearL0L1 (half4(normal, 1.0));
+		#else
+			ambient_contrib = SHEvalLinearL0L1 (half4(normal, 1.0));
+		#endif
+
+		ambient = max(half3(0, 0, 0), ambient+ambient_contrib);		// include L2 contribution in vertex shader before clamp.
+		#ifdef UNITY_COLORSPACE_GAMMA
+			ambient = LinearToGammaSpace (ambient);
+		#endif
+	#endif
+
+	return ambient;
+}
+
+//-------------------------------------------------------------------------------------
+inline half3 BoxProjectedCubemapDirection (half3 worldRefl, float3 worldPos, float4 cubemapCenter, float4 boxMin, float4 boxMax)
+{
+	// Do we have a valid reflection probe?
+	UNITY_BRANCH
+	if (cubemapCenter.w > 0.0)
+	{
+		half3 nrdir = normalize(worldRefl);
+
+		#if 1				
+			half3 rbmax = (boxMax.xyz - worldPos) / nrdir;
+			half3 rbmin = (boxMin.xyz - worldPos) / nrdir;
+
+			half3 rbminmax = (nrdir > 0.0f) ? rbmax : rbmin;
+
+		#else // Optimized version
+			half3 rbmax = (boxMax.xyz - worldPos);
+			half3 rbmin = (boxMin.xyz - worldPos);
+
+			half3 select = step (half3(0,0,0), nrdir);
+			half3 rbminmax = lerp (rbmax, rbmin, select);
+			rbminmax /= nrdir;
+		#endif
+
+		half fa = min(min(rbminmax.x, rbminmax.y), rbminmax.z);
+
+		worldPos -= cubemapCenter.xyz;
+		worldRefl = worldPos + nrdir * fa;
+	}
+	return worldRefl;
+}
+
+
+//-------------------------------------------------------------------------------------
+// Derivative maps
+// http://www.rorydriscoll.com/2012/01/11/derivative-maps/
+// For future use.
+
+// Project the surface gradient (dhdx, dhdy) onto the surface (n, dpdx, dpdy)
+half3 CalculateSurfaceGradient(half3 n, half3 dpdx, half3 dpdy, half dhdx, half dhdy)
+{
+	half3 r1 = cross(dpdy, n);
+	half3 r2 = cross(n, dpdx);
+	return (r1 * dhdx + r2 * dhdy) / dot(dpdx, r1);
+}
+
+// Move the normal away from the surface normal in the opposite surface gradient direction
+half3 PerturbNormal(half3 n, half3 dpdx, half3 dpdy, half dhdx, half dhdy)
+{
+	//TODO: normalize seems to be necessary when scales do go beyond the 2...-2 range, should we limit that?
+	//how expensive is a normalize? Anything cheaper for this case?
+	return normalize(n - CalculateSurfaceGradient(n, dpdx, dpdy, dhdx, dhdy));
+}
+
+// Calculate the surface normal using the uv-space gradient (dhdu, dhdv)
+half3 CalculateSurfaceNormal(half3 position, half3 normal, half2 gradient, half2 uv)
+{
+	half3 dpdx = ddx(position);
+	half3 dpdy = ddy(position);
+
+	half dhdx = dot(gradient, ddx(uv));
+	half dhdy = dot(gradient, ddy(uv));
+
+	return PerturbNormal(normal, dpdx, dpdy, dhdx, dhdy);
+}
+
+
+#endif // UNITY_STANDARD_UTILS_INCLUDED

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Legacy/UnityStandardUtils.cginc.meta

+fileFormatVersion: 2
+guid: 9fb70149140e95d4e91d6e55c967465d
+timeCreated: 1479834221
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: