HDRenderLoop: Rename the directory HDRenderLoop in HDRenderPipeline

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

 public class BasicRenderLoop : RenderPipelineAsset
 {
 #if UNITY_EDITOR
-    [UnityEditor.MenuItem("Renderloop/Create BasicRenderLoop")]
+    [UnityEditor.MenuItem("RenderPipeline/Create BasicRenderLoop")]
     static void CreateBasicRenderLoop()
     {
         var instance = ScriptableObject.CreateInstance<BasicRenderLoop>();

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

     public class FptlLighting : RenderPipelineAsset
     {
 #if UNITY_EDITOR
-        [UnityEditor.MenuItem("Renderloop/CreateRenderLoopFPTL")]
+        [UnityEditor.MenuItem("RenderPipeline/CreateRenderLoopFPTL")]
         static void CreateRenderLoopFPTL()
         {
             var instance = ScriptableObject.CreateInstance<FptlLighting>();

Assets/ShaderGenerator/Editor/ShaderGeneratorMenu.cs

 {
     public class ShaderGeneratorMenu
     {
-        [UnityEditor.MenuItem("Renderloop/Generate Shader Includes")]
+        [UnityEditor.MenuItem("RenderPipeline/Generate Shader Includes")]
         static void GenerateShaderIncludes()
         {
             CSharpToHLSL.GenerateAll();

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Builtin/BuiltinData.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Material/Builtin/BuiltinData.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Builtin/BuiltinData.cs.  Please don't edit by hand.
 //
 
 #ifndef BUILTINDATA_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs.  Please don't edit by hand.
 //
 
 #ifndef LIT_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Resources/PreIntegratedFGD.shader

-Shader "Hidden/HDRenderLoop/PreIntegratedFGD" 
+Shader "Hidden/HDRenderPipeline/PreIntegratedFGD" 
 {
    SubShader {
         Pass {
 
             #include "Common.hlsl"
             #include "ImageBasedLighting.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
 
 
             struct Attributes 

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

-using System;
+using System;
 using NUnit.Framework;
 using UnityEngine;
 
     {
         public StandardSpecularToHDLitMaterialUpgrader()
         {
-            RenameShader("Standard (Specular setup)", "HDRenderLoop/LitLegacySupport");
+            RenameShader("Standard (Specular setup)", "HDRenderPipeline/LitLegacySupport");
 
             RenameTexture("_MainTex", "_BaseColorMap");
             RenameColor("_Color", "_BaseColor");
         [Test]
         public void UpgradeMaterial()
         {
-            var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
+            var newShader = Shader.Find("HDRenderPipeline/LitLegacySupport");
             var mat = new Material(Shader.Find("Standard (Specular setup)"));
             var albedo = new Texture2D(1, 1);
             var normals = new Texture2D(1, 1);

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

-using System;
+using System;
 using NUnit.Framework;
 using UnityEngine;
 
     {
         public StandardToHDLitMaterialUpgrader()
         {
-            RenameShader("Standard", "HDRenderLoop/LitLegacySupport");
+            RenameShader("Standard", "HDRenderPipeline/LitLegacySupport");
 
             RenameTexture("_MainTex", "_BaseColorMap");
             RenameColor("_Color", "_BaseColor");
         [Test]
         public void UpgradeMaterial()
         {
-            var newShader = Shader.Find("HDRenderLoop/LitLegacySupport");
+            var newShader = Shader.Find("HDRenderPipeline/LitLegacySupport");
             var mat = new Material(Shader.Find("Standard"));
             var albedo = new Texture2D(1, 1);
             var normals = new Texture2D(1, 1);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.shader

-Shader "HDRenderLoop/Lit"
+Shader "HDRenderPipeline/Lit"
 {
     Properties
     {
     //-------------------------------------------------------------------------------------
     
     #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"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Attributes.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
 
     //-------------------------------------------------------------------------------------
     // variable declaration

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs

 
             public void Build()
             {
-                m_InitPreFGD = CreateEngineMaterial("Hidden/HDRenderLoop/PreIntegratedFGD");
+                m_InitPreFGD = CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
                 m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGBHalf);
 
                 m_LtcGGXMatrix                    = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMatrixData);

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Attributes.hlsl

 // This structure gather all possible varying/interpolator for this shader.
 //-------------------------------------------------------------------------------------
 
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Debug/DebugViewMaterial.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs.hlsl"
 
 struct FragInputs
 {

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Material/Unlit/Unlit.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.cs.  Please don't edit by hand.
 //
 
 #ifndef UNLIT_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Unlit/Unlit.shader

-Shader "HDRenderLoop/Unlit"
+Shader "HDRenderPipeline/Unlit"
 {
     Properties
     {
     //-------------------------------------------------------------------------------------
 
     #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"    
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Attributes.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl"    
 
     //-------------------------------------------------------------------------------------
     // variable declaration

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/LayeredLit/LayeredLit.shader

-Shader "HDRenderLoop/LayeredLit"
+Shader "HDRenderPipeline/LayeredLit"
 {
     Properties
     {
     //-------------------------------------------------------------------------------------
 
     #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"    
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Attributes.hlsl"
+    #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl"    
 
     //-------------------------------------------------------------------------------------
     // variable declaration

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/ShaderPass/ShaderPass.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADERPASS_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl

 #include "Color.hlsl"
 
 // TODO: This is the max value allowed for emissive (bad name - but keep for now to retrieve it) (It is 8^2.2 (gamma) and 8 is the limit of punctual light slider...), comme from UnityCg.cginc. Fix it!
-// Ask Jesper if this can be change for HDRenderLoop
+// Ask Jesper if this can be change for HDRenderPipeline
 #define EMISSIVE_RGBM_SCALE 97.0
 
 float4 Frag(PackedVaryings packedInput) : SV_Target

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADERCONFIG_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/PostProcess/Resources/FinalPass.shader

 // Final compositing pass, just does gamma correction for now.
-Shader "Hidden/HDRenderLoop/FinalPass"
+Shader "Hidden/HDRenderPipeline/FinalPass"
 {
     Properties
     {
 
             #include "Common.hlsl"
             #include "Color.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
 
   			TEXTURE2D(_MainTex);
 			SAMPLER2D(sampler_MainTex);

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Debug/DebugViewMaterial.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs.  Please don't edit by hand.
 //
 
 #ifndef DEBUGVIEWMATERIAL_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugViewMaterialGBuffer.shader

-Shader "Hidden/HDRenderLoop/DebugViewMaterialGBuffer"
+Shader "Hidden/HDRenderPipeline/DebugViewMaterialGBuffer"
 {
     SubShader
     {
 
             // CAUTION: In case deferred lighting need to support various lighting model statically, we will require to do multicompile with different define like UNITY_MATERIAL_LIT
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Debug/DebugViewMaterial.cs.hlsl"    
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Material/Material.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugViewMaterial.cs.hlsl"    
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Material.hlsl"
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/Resources/DebugViewTiles.shader

-Shader "Hidden/HDRenderLoop/DebugViewTiles"
+Shader "Hidden/HDRenderPipeline/DebugViewTiles"
 {
     SubShader
     {
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
             // the deferred shader will require to use multicompile.
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl" // This include Material.hlsl
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Lighting.hlsl" // This include Material.hlsl
 
             //-------------------------------------------------------------------------------------
             // variable declaration

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderLoopInspector.cs

 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [CustomEditor(typeof(HDRenderPipeline))]
-    public class HDRenderLoopInspector : Editor
+    public class HDRenderPipelineInspector : Editor
     {
         private class Styles
         {

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderLoopMenuItems.cs

 
 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
-    public class HDRenderLoopMenuItems
+    public class HDRenderPipelineMenuItems
-        [UnityEditor.MenuItem("HDRenderLoop/Create Scene Settings")]
+        [UnityEditor.MenuItem("HDRenderPipeline/Create Scene Settings")]
         static void CreateSceneSettings()
         {
             CommonSettings[] settings = Object.FindObjectsOfType(typeof(CommonSettings)) as CommonSettings[];

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/UpgradeStandardShaderMaterials.cs

-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
             return upgraders;
         }
 
-        [MenuItem("HDRenderLoop/Upgrade Materials - Project")]
+        [MenuItem("HDRenderPipeline/Upgrade Materials - Project")]
-        [MenuItem("HDRenderLoop/Upgrade Materials - Selection")]
+        [MenuItem("HDRenderPipeline/Upgrade Materials - Selection")]
-        [MenuItem("HDRenderLoop/Modify Light Intensity for Upgrade - Scene Only")]
+        [MenuItem("HDRenderPipeline/Modify Light Intensity for Upgrade - Scene Only")]
         static void UpgradeLights()
         {
             Light[] lights = Light.GetLights(LightType.Directional, 0);
             }
         }
     }
-}
+}

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderLoop.cs

 
 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
-    public class HDRenderLoopInstance : RenderPipeline
+    public class HDRenderPipelineInstance : RenderPipeline
-        public HDRenderLoopInstance(HDRenderPipeline owner)
+        public HDRenderPipelineInstance(HDRenderPipeline owner)
         {
             m_Owner = owner;
 
     }
 
     [ExecuteInEditMode]
-    // This HDRenderLoop assume linear lighting. Don't work with gamma.
+    // This HDRenderPipeline assume linear lighting. Don't work with gamma.
-        const string k_HDRenderLoopPath = "Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset";
+        const string k_HDRenderPipelinePath = "Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset";
-        [UnityEditor.MenuItem("Renderloop/CreateHDRenderLoop")]
-        static void CreateHDRenderLoop()
+        [UnityEditor.MenuItem("RenderPipeline/CreateHDRenderPipeline")]
+        static void CreateHDRenderPipeline()
-            UnityEditor.AssetDatabase.CreateAsset(instance, k_HDRenderLoopPath);
+            UnityEditor.AssetDatabase.CreateAsset(instance, k_HDRenderPipelinePath);
-        [UnityEditor.MenuItem("HDRenderLoop/Add \"Additional Light Data\" (if not present)")]
+        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light Data\" (if not present)")]
         static void AddAdditionalLightData()
         {
             Light[] lights = FindObjectsOfType(typeof(Light)) as Light[];
 
         protected override IRenderPipeline InternalCreatePipeline()
         {
-            return new HDRenderLoopInstance(this);
+            return new HDRenderPipelineInstance(this);
         }
         
         SkyManager m_SkyManager = new SkyManager();
 
             m_SkyManager.Build();
 
-            m_FinalPassMaterial  = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/FinalPass");
-            m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewMaterialGBuffer");
+            m_FinalPassMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/FinalPass");
+            m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugViewMaterialGBuffer");
 
             m_ShadowPass = new ShadowRenderPass(m_ShadowSettings);
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs.  Please don't edit by hand.
 //
 
 #ifndef LIGHTDEFINITION_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 
                 s_LightList = null;
 
-                m_DeferredDirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredDirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DeferredIndirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredIndirectMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DeferredAllMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_DeferredAllMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
-                m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/DebugViewTiles");
+                m_DebugViewTilesMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugViewTiles");
-                m_SingleDeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Deferred");
+                m_SingleDeferredMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Deferred");
                 m_SingleDeferredMaterial.EnableKeyword("LIGHTLOOP_SINGLE_PASS");
 
                 m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs.  Please don't edit by hand.
 //
 
 #ifndef TILEPASS_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/Resources/shadeopaque.compute

-#pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
-#pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
-
-
-#define LIGHTLOOP_TILE_PASS 1
-#define LIGHTLOOP_TILE_DIRECT 1
-#define LIGHTLOOP_TILE_INDIRECT 1
-#define LIGHTLOOP_TILE_ALL 1
-#define USE_FPTL_LIGHTLIST 1
-
-
-//-------------------------------------------------------------------------------------
-// Include
-//-------------------------------------------------------------------------------------
-
-#include "Common.hlsl"
-
-// Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
-// deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
-// the deferred shader will require to use multicompile.
-#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl" // This include Material.hlsl
-
-//-------------------------------------------------------------------------------------
-// variable declaration
-//-------------------------------------------------------------------------------------
-
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
-
-TEXTURE2D(_CameraDepthTexture);
-SAMPLER2D(sampler_CameraDepthTexture);
-
-RWTexture2D<float4> uavOutput;
-
-[numthreads(TILE_SIZE, TILE_SIZE, 1)]
-void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
-{
-    // input.positionCS is SV_Position
-    uint2 pixelCoord = dispatchThreadId;
-    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw);
-    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, posInput.unPositionSS).x;
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
-    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
-
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    BSDFData bsdfData;
-    float3 bakeDiffuseLighting;
-    DECODE_FROM_GBUFFER(gbuffer, bsdfData, bakeDiffuseLighting);
-
-    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
-
-    float3 diffuseLighting;
-    float3 specularLighting;
-    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
-
-    uavOutput[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
-}
-
+#pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
+#pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
+
+
+#define LIGHTLOOP_TILE_PASS 1
+#define LIGHTLOOP_TILE_DIRECT 1
+#define LIGHTLOOP_TILE_INDIRECT 1
+#define LIGHTLOOP_TILE_ALL 1
+#define USE_FPTL_LIGHTLIST 1
+
+
+//-------------------------------------------------------------------------------------
+// Include
+//-------------------------------------------------------------------------------------
+
+#include "Common.hlsl"
+
+// Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+// deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+// the deferred shader will require to use multicompile.
+#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Lighting.hlsl" // This include Material.hlsl
+
+//-------------------------------------------------------------------------------------
+// variable declaration
+//-------------------------------------------------------------------------------------
+
+DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+
+TEXTURE2D(_CameraDepthTexture);
+SAMPLER2D(sampler_CameraDepthTexture);
+
+RWTexture2D<float4> uavOutput;
+
+[numthreads(TILE_SIZE, TILE_SIZE, 1)]
+void SHADE_OPAQUE_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)
+{
+    // input.positionCS is SV_Position
+    uint2 pixelCoord = dispatchThreadId;
+    PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw);
+    float depth = LOAD_TEXTURE2D(_CameraDepthTexture, posInput.unPositionSS).x;
+    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    float3 V = GetWorldSpaceNormalizeViewDir(posInput.positionWS);
+
+    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
+    BSDFData bsdfData;
+    float3 bakeDiffuseLighting;
+    DECODE_FROM_GBUFFER(gbuffer, bsdfData, bakeDiffuseLighting);
+
+    PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
+
+    float3 diffuseLighting;
+    float3 specularLighting;
+    LightLoop(V, posInput, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
+
+    uavOutput[pixelCoord] = float4(diffuseLighting + specularLighting, 1.0);
+}
+

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

-Shader "Hidden/HDRenderLoop/Deferred"
+Shader "Hidden/HDRenderPipeline/Deferred"
 {
     Properties
     {
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
             // the deferred shader will require to use multicompile.
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderConfig.cs.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/ShaderVariables.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/Lighting.hlsl" // This include Material.hlsl
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderConfig.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderVariables.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Lighting.hlsl" // This include Material.hlsl
  
             //-------------------------------------------------------------------------------------
             // variable declaration

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Lighting.hlsl

 
 #define HAS_LIGHTLOOP // Allow to not define LightLoop related function in Material.hlsl
 
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightUtilities.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightUtilities.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePass.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Shadow/Shadow.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Material/Material.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Shadow/Shadow.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Material.hlsl"
-#include "Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/TilePass/TilePassLoop.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl"
 #endif
 
 

Assets/ScriptableRenderLoop/HDRenderPipeline/SceneSettings/CommonSettings.cs

 
         void OnEnable()
         {
-            HDRenderPipeline renderLoop = Utilities.GetHDRenderLoop();
+            HDRenderPipeline renderLoop = Utilities.GetHDRenderPipeline();
             if (renderLoop == null)
             {
                 return;
 
         void OnDisable()
         {
-            HDRenderPipeline renderLoop = Utilities.GetHDRenderLoop();
+            HDRenderPipeline renderLoop = Utilities.GetHDRenderPipeline();
             if (renderLoop == null)
             {
                 return;
 
         void OnSkyRendererChanged()
         {
-            HDRenderPipeline renderLoop = Utilities.GetHDRenderLoop();
+            HDRenderPipeline renderLoop = Utilities.GetHDRenderPipeline();
             if (renderLoop == null)
             {
                 return;

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyManager.cs

 
             // TODO: We need to have an API to send our sky information to Enlighten. For now use a workaround through skybox/cubemap material...
             m_StandardSkyboxMaterial   = Utilities.CreateEngineMaterial("Skybox/Cubemap");
-            m_GGXConvolveMaterial      = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/GGXConvolve");
+            m_GGXConvolveMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/GGXConvolve");
             m_BuildProbabilityTablesCS = Resources.Load<ComputeShader>("BuildProbabilityTables");
 
             m_ConditionalDensitiesKernel = m_BuildProbabilityTablesCS.FindKernel("ComputeConditionalDensities");

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyManager.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyManager.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyManager.cs.  Please don't edit by hand.
 //
 
 #ifndef SKYMANAGER_CS_HLSL

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/SkyParameters.cs

 
         protected void OnEnable()
         {
-            HDRenderPipeline renderLoop = Utilities.GetHDRenderLoop();
+            HDRenderPipeline renderLoop = Utilities.GetHDRenderPipeline();
             if (renderLoop == null)
             {
                 return;
 
         protected void OnDisable()
         {
-            HDRenderPipeline renderLoop = Utilities.GetHDRenderLoop();
+            HDRenderPipeline renderLoop = Utilities.GetHDRenderPipeline();
             if (renderLoop == null)
             {
                 return;

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/Resources/GGXConvolve.shader

-Shader "Hidden/HDRenderLoop/GGXConvolve"
+Shader "Hidden/HDRenderPipeline/GGXConvolve"
 {
     SubShader
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

 
         override public void Build()
         {
-            m_ProceduralSkyMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Sky/SkyProcedural");
+            m_ProceduralSkyMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Sky/SkyProcedural");
         }
 
         override public void Cleanup()

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/ProceduralSky/Resources/SkyProcedural.shader

-Shader "Hidden/HDRenderLoop/Sky/SkyProcedural"
+Shader "Hidden/HDRenderPipeline/Sky/SkyProcedural"
 {
     SubShader
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

 
         override public void Build()
         {
-            m_SkyHDRIMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderLoop/Sky/SkyHDRI");
+            m_SkyHDRIMaterial = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/Sky/SkyHDRI");
         }
 
         override public void Cleanup()

Assets/ScriptableRenderLoop/HDRenderPipeline/Sky/HDRISky/Resources/SkyHDRI.shader

-Shader "Hidden/HDRenderLoop/Sky/SkyHDRI"
+Shader "Hidden/HDRenderPipeline/Sky/SkyHDRI"
 {
     SubShader
     {

Assets/ScriptableRenderLoop/HDRenderPipeline/Utilities.cs

                 m.DisableKeyword(keyword);
         }
 
-        public static HDRenderPipeline GetHDRenderLoop()
+        public static HDRenderPipeline GetHDRenderPipeline()
-                Debug.LogWarning("SkyParameters component can only be used with HDRenderLoop custom RenderPipeline.");
+                Debug.LogWarning("SkyParameters component can only be used with HDRenderPipeline custom RenderPipeline.");
                 return null;
             }
 

Assets/ScriptableRenderLoop/HDRenderPipeline.meta

+fileFormatVersion: 2
+guid: 4c38eac64d0e8344d85c9f309419d619
+folderAsset: yes
+timeCreated: 1483548930
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 0}
+  m_Name: HDRenderPipeline
+  m_EditorClassIdentifier: Assembly-CSharp:UnityEngine.Experimental.ScriptableRenderLoop:HDRenderPipeline
+  m_ShadowSettings:
+    enabled: 1
+    shadowAtlasWidth: 4096
+    shadowAtlasHeight: 4096
+    maxShadowDistance: 1000
+    directionalLightCascadeCount: 4
+    directionalLightCascades: {x: 0.05, y: 0.2, z: 0.3}
+  m_TextureSettings:
+    spotCookieSize: 128
+    pointCookieSize: 512
+    reflectionCubemapSize: 128

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.asset.meta

+fileFormatVersion: 2
+guid: e185fecca3c73cd47a09f1092663ef32
+timeCreated: 1483549297
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Builtin/BuiltinData.hlsl

+#ifndef UNITY_BUILTIN_DATA_INCLUDED
+#define UNITY_BUILTIN_DATA_INCLUDED
+
+//-----------------------------------------------------------------------------
+// BuiltinData
+// This structure include common data that should be present in all material
+// and are independent from the BSDF parametrization.
+// Note: These parameters can be store in GBuffer if the writer wants
+//-----------------------------------------------------------------------------
+
+#include "BuiltinData.cs.hlsl"
+
+//-----------------------------------------------------------------------------
+// common Encode/Decode functions
+//-----------------------------------------------------------------------------
+
+// Guideline for velocity buffer.
+// We support various architecture for HDRenderPipeline
+// - Forward only rendering
+// - Hybrid forward/deferred opaque
+// - Regular deferred
+// The velocity buffer is potentially fill in several pass.
+// - In gbuffer pass with extra RT
+// - In forward opaque pass (Can happen even when deferred) with MRT
+// - In dedicated velocity pass
+// Also the velocity buffer is only fill in case of dynamic or deformable objects, static case can use camera reprojection to retrieve motion vector (<= TODO: this may be false with TAA due to jitter matrix)
+// or just previous and current transform
+
+// So here we decide the following rules:
+// - A deferred material can't override the velocity buffer format of builtinData, must use appropriate function
+// - If velocity buffer is enable in deferred material it is the last one
+// - Velocity buffer can be optionally enabled (either in forward or deferred)
+// - Velocity data can't be pack with other properties
+// - Same velocity buffer is use for all scenario, so if deferred define a velocity buffer, the same is reuse for forward case.
+// For these reasons we chose to avoid to pack velocity buffer with anything else in case of PackgbufferInFP16 (and also in case the format change)
+
+// Encode/Decode velocity/distortion in a buffer (either forward of deferred)
+// Design note: We assume that velocity/distortion fit into a single buffer (i.e not spread on several buffer)
+void EncodeVelocity(float2 velocity, out float4 outBuffer)
+{
+    // RT - 16:16 float
+    outBuffer = float4(velocity.xy, 0.0, 0.0);
+}
+
+void DecodeVelocity(float4 inBuffer, out float2 velocity)
+{
+    velocity = inBuffer.xy;
+}
+
+void EncodeDistortion(float2 distortion, float distortionBlur, out float4 outBuffer)
+{
+    // RT - 16:16:16:16 float
+    // distortionBlur in alpha for a different blend mode
+    outBuffer = float4(distortion, 0.0, distortionBlur);
+}
+
+void DecodeDistortion(float4 inBuffer, out float2 distortion, out float2 distortionBlur)
+{
+    distortion = inBuffer.xy;
+    distortionBlur = inBuffer.a;
+}
+
+void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_OPACITY:
+        result = builtinData.opacity.xxx;
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_BAKE_DIFFUSE_LIGHTING:
+        // TODO: require a remap
+        result = builtinData.bakeDiffuseLighting;
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
+        // emissiveColor is premultiply by emissive intensity
+        result = (builtinData.emissiveColor / builtinData.emissiveIntensity); needLinearToSRGB = true;
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY:
+        result = builtinData.emissiveIntensity.xxx;
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY:
+        result = float3(builtinData.velocity, 0.0);
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION:
+        result = float3(builtinData.distortion, 0.0);
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR:
+        result = builtinData.distortionBlur.xxx;
+        break;
+    case DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET:
+        result = builtinData.depthOffset.xxx * 10.0; // * 10 assuming 1 unity unity is 1m
+        break;
+    }
+}
+
+void GetLighTransportDataDebug(uint paramId, LighTransportData lightTransportData, inout float3 result, inout bool needLinearToSRGB)
+{
+    switch (paramId)
+    {
+    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR:
+        result = lightTransportData.diffuseColor; needLinearToSRGB = true;
+        break;
+    case DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR:
+        // TODO: Need a tonemap ?
+        result = lightTransportData.emissiveColor;
+        break;
+    }    
+}
+
+#endif // UNITY_BUILTIN_DATA_INCLUDED

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Material.hlsl

+#ifndef UNITY_MATERIAL_INCLUDED
+#define UNITY_MATERIAL_INCLUDED
+
+#include "Color.hlsl"
+#include "Packing.hlsl"
+#include "BSDF.hlsl"
+#include "Debug.hlsl"
+#include "GeometricTools.hlsl"
+#include "CommonMaterial.hlsl"
+#include "EntityLighting.hlsl"
+#include "ImageBasedLighting.hlsl"
+
+//-----------------------------------------------------------------------------
+// BuiltinData
+//-----------------------------------------------------------------------------
+
+#include "Builtin/BuiltinData.hlsl"
+
+//-----------------------------------------------------------------------------
+// Material definition
+//-----------------------------------------------------------------------------
+
+// Here we include all the different lighting model supported by the renderloop based on define done in .shader
+// Only one deferred layout is allowed for a HDRenderPipeline, this will be detect by the redefinition of GBUFFERMATERIAL_COUNT
+// If GBUFFERMATERIAL_COUNT is define two time, the shaders will not compile
+#ifdef UNITY_MATERIAL_LIT
+#include "Lit/Lit.hlsl"
+#elif defined(UNITY_MATERIAL_UNLIT)
+#include "Unlit/Unlit.hlsl"
+#endif
+
+//-----------------------------------------------------------------------------
+// Define for GBuffer management
+//-----------------------------------------------------------------------------
+
+#ifdef GBUFFERMATERIAL_COUNT
+
+#if GBUFFERMATERIAL_COUNT == 2
+
+#define OUTPUT_GBUFFER(NAME)                            \
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1
+
+#define DECLARE_GBUFFER_TEXTURE(NAME)   \
+        TEXTURE2D(MERGE_NAME(NAME, 0));  \
+        TEXTURE2D(MERGE_NAME(NAME, 1));
+
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2);
+
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
+#define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target2
+#endif
+
+#elif GBUFFERMATERIAL_COUNT == 3
+
+#define OUTPUT_GBUFFER(NAME)                            \
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2
+
+#define DECLARE_GBUFFER_TEXTURE(NAME)   \
+        TEXTURE2D(MERGE_NAME(NAME, 0));  \
+        TEXTURE2D(MERGE_NAME(NAME, 1));  \
+        TEXTURE2D(MERGE_NAME(NAME, 2));
+
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2);
+
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
+#define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target3
+#endif
+
+#elif GBUFFERMATERIAL_COUNT == 4
+
+#define OUTPUT_GBUFFER(NAME)                            \
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
+        out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3
+
+#define DECLARE_GBUFFER_TEXTURE(NAME)   \
+        TEXTURE2D(MERGE_NAME(NAME, 0));  \
+        TEXTURE2D(MERGE_NAME(NAME, 1));  \
+        TEXTURE2D(MERGE_NAME(NAME, 2));  \
+        TEXTURE2D(MERGE_NAME(NAME, 3));
+
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2);
+
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
+#define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target4
+#endif
+
+#elif GBUFFERMATERIAL_COUNT == 5
+
+#define OUTPUT_GBUFFER(NAME)                            \
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
+        out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3,    \
+        out GBufferType4 MERGE_NAME(NAME, 4) : SV_Target4
+
+#define DECLARE_GBUFFER_TEXTURE(NAME)   \
+        TEXTURE2D(MERGE_NAME(NAME, 0));  \
+        TEXTURE2D(MERGE_NAME(NAME, 1));  \
+        TEXTURE2D(MERGE_NAME(NAME, 2));  \
+        TEXTURE2D(MERGE_NAME(NAME, 3));  \
+        TEXTURE2D(MERGE_NAME(NAME, 4));
+
+#define FETCH_GBUFFER(NAME, TEX, unCoord2)                                        \
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), unCoord2); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), unCoord2); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), unCoord2); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), unCoord2); \
+        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), unCoord2);
+
+#define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
+#define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
+
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target5
+#endif
+
+#endif
+
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define ENCODE_VELOCITY_INTO_GBUFFER(VELOCITY, NAME) EncodeVelocity(VELOCITY, NAME)
+#else
+#define OUTPUT_GBUFFER_VELOCITY(NAME)
+#define ENCODE_VELOCITY_INTO_GBUFFER(VELOCITY, NAME)
+#endif
+
+#endif // #ifdef GBUFFERMATERIAL_COUNT
+
+#endif // UNITY_MATERIAL_INCLUDED

Assets/ScriptableRenderLoop/HDRenderPipeline/ShaderPass/ShaderPass.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 2c2d7b256f4650943b60cc4ef1c7aeaa
+timeCreated: 1483548875
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderLoop.meta

-fileFormatVersion: 2
-guid: efe43be6d4923e441a2d4b20b3783b7f
-folderAsset: yes
-timeCreated: 1474540060
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: