HDRenderLoop: Update for velociy buffer + several stuff/fix/refactor

-fix issue with spotAngle that have been change in the light component
- remove undesired unrachable code warning
- create a proper shader config system (previous one was nor working)
- Change concept of material gbuffer to also include lighting, remove
all lighting buffer macro, bakeDiffuseLighting now pass to encode to
gbuffer
- deferred material is now in charge of all material RT format, lighting
buffer included
- velocity buffer is independt of deferred material
- add first start of distortion
- update velocity buffer management + add velocity pass
-

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

                 var dir = light.localToWorld.GetColumn (2);
                 lightSpotDirections[i] = new Vector4 (-dir.x, -dir.y, -dir.z, 0);
 
-                float radAngle = Mathf.Deg2Rad * light.spotAngle;
+                float radAngle = Mathf.Deg2Rad * light.light.spotAngle;
                 float cosTheta = Mathf.Cos (radAngle * 0.25f);
                 float cosPhi = Mathf.Cos (radAngle * 0.5f);
                 float cosDiff = cosTheta - cosPhi;

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

 fileFormatVersion: 2
 guid: 2400b74f5ce370c4481e5dc417d03703
-timeCreated: 1478744315
+timeCreated: 1478912125
 licenseType: Pro
 NativeFormatImporter:
   userData: 

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

         Material m_DeferredMaterial;
         Material m_FinalPassMaterial;
 
-        // TODO: Find a way to automatically create/iterate through these kind of class
+        // TODO: Find a way to automatically create/iterate through deferred material
-        Builtin.RenderLoop m_BuiltinRenderLoop;
 
         // Debug
         Material m_DebugViewMaterialGBuffer;
-        static private int s_CameraColorBuffer;
-        static private int s_CameraDepthBuffer;
-        static private int s_VelocityBuffer;
+        private int s_CameraColorBuffer;
+        private int s_CameraDepthBuffer;
+        private int s_VelocityBuffer;
+        private int s_DistortionBuffer;
-        static private ComputeBuffer s_punctualLightList;
-        static private ComputeBuffer s_envLightList;
-        static private ComputeBuffer s_punctualShadowList;
+        private ComputeBuffer s_punctualLightList;
+        private ComputeBuffer s_envLightList;
+        private ComputeBuffer s_punctualShadowList;
 
         private TextureCacheCubemap m_cubeReflTexArray;
 
             m_cubeReflTexArray = new TextureCacheCubemap();
             m_cubeReflTexArray.AllocTextureArray(32, (int)m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
 
-            // Init Lit material buffer - GBuffer and init
+            // Init Gbuffer description
-            m_BuiltinRenderLoop = new Builtin.RenderLoop();
+
+            m_gbufferManager.gbufferCount = m_LitRenderLoop.GetMaterialGBufferCount();
+            RenderTextureFormat[] RTFormat; RenderTextureReadWrite[] RTReadWrite;
+            m_LitRenderLoop.GetMaterialGBufferDescription(out RTFormat, out RTReadWrite);
-            for (int gbufferIndex = 0; gbufferIndex < m_LitRenderLoop.GetGBufferCount(); ++gbufferIndex)
+            for (int gbufferIndex = 0; gbufferIndex < m_gbufferManager.gbufferCount; ++gbufferIndex)
-                m_gbufferManager.SetBufferDescription(gbufferIndex, "_CameraGBufferTexture" + gbufferIndex, m_LitRenderLoop.RTFormat[gbufferIndex], m_LitRenderLoop.RTReadWrite[gbufferIndex]);
+                m_gbufferManager.SetBufferDescription(gbufferIndex, "_GBufferTexture" + gbufferIndex, RTFormat[gbufferIndex], RTReadWrite[gbufferIndex]);
-            m_gbufferManager.gbufferCount = m_LitRenderLoop.GetGBufferCount();
-            // In forward we still name the buffer as if they were gbuffer, it doesn't matter            
-            for (int gbufferIndex = 0; gbufferIndex < m_BuiltinRenderLoop.GetGBufferCount(); ++gbufferIndex)
+#pragma warning disable 162 // warning CS0162: Unreachable code detected
+            s_VelocityBuffer = Shader.PropertyToID("_VelocityTexture");
+            if (ShaderConfig.VelocityInGbuffer == 1)
-                int textureIndex = m_gbufferManager.gbufferCount + gbufferIndex;
-                m_gbufferManager.SetBufferDescription(textureIndex, "_CameraGBufferTexture" + textureIndex, m_BuiltinRenderLoop.RTFormat[gbufferIndex], m_BuiltinRenderLoop.RTReadWrite[gbufferIndex]);
+                // If velocity is in GBuffer then it is in the last RT. Assign a different name to it.
+                m_gbufferManager.SetBufferDescription(m_gbufferManager.gbufferCount, "_VelocityTexture", Builtin.RenderLoop.GetVelocityBufferFormat(), Builtin.RenderLoop.GetVelocityBufferReadWrite());
+                m_gbufferManager.gbufferCount++;
-            m_gbufferManager.gbufferCount += m_BuiltinRenderLoop.GetGBufferCount();
+#pragma warning restore 162
-            // Caution velocity texture name must match with Macro in Material.hlsl
-            s_VelocityBuffer = Shader.PropertyToID("_VelocityTexture");
-            #if VELOCITY_IN_GBUFFER
-            m_gbufferManager.SetBufferDescription(m_gbufferManager.gbufferCount, "_VelocityTexture", m_BuiltinRenderLoop.GetVelocityBufferFormat(), m_BuiltinRenderLoop.GetVelocityBufferReadWrite());
-            m_gbufferManager.gbufferCount++;
-            #endif     
+            s_DistortionBuffer = Shader.PropertyToID("_DistortionTexture");
-            m_BuiltinRenderLoop.Rebuild();
         }
 
         void OnDisable()
             // Last blit
             {
                 var cmd = new CommandBuffer { name = "Blit DebugView Material Debug" };
-                cmd.Blit(s_CameraColorBuffer, BuiltinRenderTextureType.CameraTarget);
+                cmd.Blit(new RenderTargetIdentifier(s_CameraColorBuffer), BuiltinRenderTextureType.CameraTarget);
                 renderLoop.ExecuteCommandBuffer(cmd);
                 cmd.Dispose();
             }
 
         void RenderVelocity(CullResults cullResults, Camera camera, RenderLoop renderLoop)
         {
+            // warning CS0162: Unreachable code detected // warning CS0429: Unreachable expression code detected
+#pragma warning disable 162, 429 
+            // If opaque velocity have been render during GBuffer no need to render it here
+            if ((ShaderConfig.VelocityInGbuffer == 0) || debugParameters.useForwardRenderingOnly)
+                return ;
+
-            cmd.GetTemporaryRT(s_VelocityBuffer, w, h, 0, FilterMode.Point, m_BuiltinRenderLoop.GetVelocityBufferFormat(), m_BuiltinRenderLoop.GetVelocityBufferReadWrite());
+            cmd.GetTemporaryRT(s_VelocityBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetVelocityBufferFormat(), Builtin.RenderLoop.GetVelocityBufferReadWrite());
+#pragma warning restore 162, 429
+        void RenderDistortion(CullResults cullResults, Camera camera, RenderLoop renderLoop)
+        {
+            int w = camera.pixelWidth;
+            int h = camera.pixelHeight;
+
+            var cmd = new CommandBuffer { name = "Distortion Pass" };
+            cmd.GetTemporaryRT(s_DistortionBuffer, w, h, 0, FilterMode.Point, Builtin.RenderLoop.GetDistortionBufferFormat(), Builtin.RenderLoop.GetDistortionBufferReadWrite());
+            cmd.SetRenderTarget(new RenderTargetIdentifier(s_DistortionBuffer), new RenderTargetIdentifier(s_CameraDepthBuffer));
+            renderLoop.ExecuteCommandBuffer(cmd);
+            cmd.Dispose();
+
+            // Only transparent object can render distortion vectors
+            RenderTransparentRenderList(cullResults, camera, renderLoop, "DistortionVectors");
+        }
+        
+
         void FinalPass(RenderLoop renderLoop)
         {
             // Those could be tweakable for the neutral tonemapper, but in the case of the LookDev we don't need that
             var cmd = new CommandBuffer { name = "FinalPass" };
 
             // Resolve our HDR texture to CameraTarget.
-            cmd.Blit(s_CameraColorBuffer, BuiltinRenderTextureType.CameraTarget, m_FinalPassMaterial, 0);
+            cmd.Blit(new RenderTargetIdentifier(s_CameraColorBuffer), BuiltinRenderTextureType.CameraTarget, m_FinalPassMaterial, 0);
             renderLoop.ExecuteCommandBuffer(cmd);
             cmd.Dispose();
         }
 
                 if (light.lightType == LightType.Spot)
                 {
-                    var spotAngle = light.spotAngle;
+                    var spotAngle = light.light.spotAngle;
 
                     var innerConePercent = AdditionalLightData.GetInnerSpotPercent01(additionalLightData);
                     var cosSpotOuterHalfAngle = Mathf.Clamp(Mathf.Cos(spotAngle * 0.5f * Mathf.Deg2Rad), 0.0f, 1.0f);
                     RenderForward(cullResults, camera, renderLoop);
                     RenderForwardUnlit(cullResults, camera, renderLoop);
 
-                    // If opaque velocity have been render during GBuffer no need to render them here
-                    // TODO: What about forward opaque object that will come later, (with stencil bit to avoid double lighting), we need to
-                    // also render their velocity inside the buffer. So It mean that when they are deferred opaque they should render during GBuffer pass
-                    // but when they are forward they should render a second time here in velocity pass... Maybe we should enable MRT during forward pass ?
-                    // TODO: implement MRT velocity buffer as an option in case of forward
-                    // Render as late as possible to benefit from an up to date depth buffer (TODO: could use equal depth test ?)
-                    #if VELOCITY_IN_GBUFFER
-                    if (debugParameters.useForwardRenderingOnly)                    
-                    #endif
-                        RenderVelocity(cullResults, camera, renderLoop);
+                    RenderVelocity(cullResults, camera, renderLoop);
+
+                    // TODO: Check with VFX team.
+                    // Rendering distortion here have off course lot of artifact.
+                    // But resolving at each objects that write in distortion is not possible (need to sort transparent, render those that do not distort, then resolve, then etc...)
+                    // Instead we chose to apply distortion at the end after we cumulate distortion vector and desired blurriness. This
+                    // RenderDistortion(cullResults, camera, renderLoop);
 
                     FinalPass(renderLoop);
                 }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterialGBuffer.shader

             #pragma fragment FragDeferred
 
             #include "Common.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Material.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl"            
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl"    
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Material.hlsl"
+        
-            DECLARE_GBUFFER_TEXTURE(_CameraGBufferTexture);
-            DECLARE_GBUFFER_BAKE_LIGHTING(_CameraGBufferTexture);
+            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
             TEXTURE2D(_CameraDepthTexture);
 			SAMPLER2D(sampler_CameraDepthTexture);
 
                 float depth = _CameraDepthTexture.Load(uint3(coord.unPositionSS, 0)).x;
 
-                FETCH_GBUFFER(gbuffer, _CameraGBufferTexture, coord.unPositionSS);
-                BSDFData bsdfData = DECODE_FROM_GBUFFER(gbuffer);
+                FETCH_GBUFFER(gbuffer, _GBufferTexture, coord.unPositionSS);
+                BSDFData bsdfData;
+                float3 bakeDiffuseLighting;
+                DECODE_FROM_GBUFFER(gbuffer, bsdfData, bakeDiffuseLighting);
 
                 // Init to not expected value
                 float3 result = float3(-666.0, 0.0, 0.0);
                 }
                 else if (_DebugViewMaterial == DEBUGVIEW_GBUFFER_BAKEDIFFUSELIGHTING)
                 {
-                    FETCH_BAKE_LIGHTING_GBUFFER(gbuffer, _CameraGBufferTexture, coord.unPositionSS);
-                    result = DECODE_BAKE_LIGHTING_FROM_GBUFFER(gbuffer);
+                    result = bakeDiffuseLighting;
                 }
 
                 GetBSDFDataDebug(_DebugViewMaterial, bsdfData, result, needLinearToSRGB);

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

             //-------------------------------------------------------------------------------------
 
             #include "Common.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"
-            #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"
-
+ 
-            DECLARE_GBUFFER_TEXTURE(_CameraGBufferTexture);
-            DECLARE_GBUFFER_BAKE_LIGHTING(_CameraGBufferTexture);
-
+            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
+ 
  			TEXTURE2D(_CameraDepthTexture);
 			SAMPLER2D(sampler_CameraDepthTexture);
 
                 float3 positionWS = UnprojectToWorld(depth, coord.positionSS, _InvViewProjMatrix);
                 float3 V = GetWorldSpaceNormalizeViewDir(positionWS);
 
-                FETCH_GBUFFER(gbuffer, _CameraGBufferTexture, coord.unPositionSS);
-                BSDFData bsdfData = DECODE_FROM_GBUFFER(gbuffer);
+                FETCH_GBUFFER(gbuffer, _GBufferTexture, coord.unPositionSS);
+                BSDFData bsdfData;
+                float3 bakeDiffuseLighting;
+                DECODE_FROM_GBUFFER(gbuffer, bsdfData, bakeDiffuseLighting);
-                FETCH_BAKE_LIGHTING_GBUFFER(gbuffer, _CameraGBufferTexture, coord.unPositionSS);
-                float3 bakeDiffuseLighting = DECODE_BAKE_LIGHTING_FROM_GBUFFER(gbuffer);
                 LightLoop(V, positionWS, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
                 return float4(diffuseLighting.rgb + specularLighting.rgb, 1.0);

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.cs

             public Vector3 emissiveColor;
         };
 
-        [GenerateHLSL(PackingRules.Exact)]
-        public enum GBufferBuiltin
-        {
-            Count = 1
-        };
-
-            // Note: Velocity buffer must be the last buffer of a GBuffer pass if applicable
-            public RenderTextureFormat GetVelocityBufferFormat()
+            public static RenderTextureFormat GetVelocityBufferFormat()
-                return RenderTextureFormat.RGHalf;
+                return RenderTextureFormat.RGHalf; // TODO: We should use 16bit normalized instead, better precision // RGInt
-            public RenderTextureReadWrite GetVelocityBufferReadWrite()
+            public static RenderTextureReadWrite GetVelocityBufferReadWrite()
-            //-----------------------------------------------------------------------------
-            // GBuffer management
-            //-----------------------------------------------------------------------------
-
-            public int GetGBufferCount() { return (int)GBufferBuiltin.Count; }
-
-            public RenderTextureFormat[] RTFormat =
+            public static RenderTextureFormat GetDistortionBufferFormat()
-                RenderTextureFormat.RGB111110Float
-            };
-
-            public RenderTextureReadWrite[] RTReadWrite =
-            {
-                RenderTextureReadWrite.Linear
-            };
+                return RenderTextureFormat.ARGBHalf; // This format need to be blendable and include distortionBlur
+            }
-            public void Rebuild()
+            public static RenderTextureReadWrite GetDistortionBufferReadWrite()
+                return RenderTextureReadWrite.Linear;
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.cs.hlsl

 #define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_DIFFUSE_COLOR (120)
 #define DEBUGVIEW_BUILTIN_LIGHTRANSPORTDATA_EMISSIVE_COLOR (121)
 
-//
-// UnityEngine.Experimental.ScriptableRenderLoop.Builtin.GBufferBuiltin:  static fields
-//
-#define GBUFFERBUILTIN_COUNT (1)
-
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.Builtin.BuiltinData
 // PackingRules = Exact
 struct BuiltinData

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Builtin/BuiltinData.hlsl

 // common Encode/Decode functions
 //-----------------------------------------------------------------------------
 
-// Encode/Decode velocity in a buffer (either forward of deferred)
-// Design note: We assume that VelocityVector fit into a single buffer (i.e not spread on several buffer)
+// Guideline for velocity buffer.
+// We support various architecture for HDRenderLoop
+// - 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
-float2 DecodeVelocity(float4 inBuffer)
+void DecodeVelocity(float4 inBuffer, out float2 velocity)
-    return float2(inBuffer.xy);
+    velocity = inBuffer.xy;
-// Encode/Decode into GBuffer - This is share so others material can use it.
-// Design note: We assume that BakeDiffuseLighting and emissive fit into a single buffer (i.e not spread on several buffer)
-void EncodeBakedDiffuseLigthingIntoGBuffer(float3 bakeDiffuseLighting, out float4 outBuffer)
+void EncodeDistortion(float2 distortion, float distortionBlur, out float4 outBuffer)
-    // RT - 11:11:10f
-    outBuffer = float4(bakeDiffuseLighting.xyz, 0.0);
+    // RT - 16:16 float
+    outBuffer = float4(distortion, distortionBlur, 0.0);
-float3 DecodeBakedDiffuseLigthingFromGBuffer(float4 inBuffer)
+void DecodeDistortion(float4 inBuffer, out float2 distortion, out float2 distortionBlur)
-    return float3(inBuffer.xyz);
+    distortion = inBuffer.xy;
+    distortionBlur = inBuffer.z;
-
 
 void GetBuiltinDataDebug(uint paramId, BuiltinData builtinData, inout float3 result, inout bool needLinearToSRGB)
 {

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

     //-------------------------------------------------------------------------------------
 
     #include "common.hlsl"
-    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPass.cs.hlsl"    
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/Lit.cs

         [GenerateHLSL(PackingRules.Exact)]
         public enum GBufferMaterial
         {
-            Count = 3
+            // Note: This count doesn't include the velocity buffer. On shader and csharp side the velocity buffer will be added by the framework
+            Count = (ShaderConfig.PackgbufferInFP16 == 1) ? 2 : 4
         };
 
         public class RenderLoop : Object
             //-----------------------------------------------------------------------------
 
-            public int GetGBufferCount() { return (int)GBufferMaterial.Count; }
+            public int GetMaterialGBufferCount() { return (int)GBufferMaterial.Count; }
-            public RenderTextureFormat[] RTFormat =
+            public void GetMaterialGBufferDescription(out RenderTextureFormat[] RTFormat, out RenderTextureReadWrite[] RTReadWrite)
-                RenderTextureFormat.ARGB32,
-                RenderTextureFormat.ARGB2101010,
-                RenderTextureFormat.ARGB32
-            };
+                RTFormat = new RenderTextureFormat[(int)GBufferMaterial.Count];
+                RTReadWrite = new RenderTextureReadWrite[(int)GBufferMaterial.Count];
-            public RenderTextureReadWrite[] RTReadWrite = 
-            {
-                RenderTextureReadWrite.sRGB,
-                RenderTextureReadWrite.Linear,
-                RenderTextureReadWrite.Linear
-            };
-      
+#pragma warning disable 162 // warning CS0162: Unreachable code detected
+                if (ShaderConfig.PackgbufferInFP16 == 1)
+                {
+                    RTFormat[0] = RenderTextureFormat.ARGBHalf; RTReadWrite[0] = RenderTextureReadWrite.Linear;
+                    RTFormat[1] = RenderTextureFormat.ARGBHalf; RTReadWrite[1] = RenderTextureReadWrite.Linear;
+                }
+                else
+                {
+                    RTFormat[0] = RenderTextureFormat.ARGB32; RTReadWrite[0] = RenderTextureReadWrite.sRGB;
+                    RTFormat[1] = RenderTextureFormat.ARGB2101010; RTReadWrite[1] = RenderTextureReadWrite.Linear;
+                    RTFormat[2] = RenderTextureFormat.ARGB32; RTReadWrite[2] = RenderTextureReadWrite.Linear;
+                    RTFormat[3] = RenderTextureFormat.RGB111110Float; RTReadWrite[3] = RenderTextureReadWrite.Linear;
+                }
+#pragma warning restore 162
+            }
+
             //-----------------------------------------------------------------------------
             // Init precomputed texture
             //-----------------------------------------------------------------------------

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

 //
 // UnityEngine.Experimental.ScriptableRenderLoop.Lit.GBufferMaterial:  static fields
 //
-#define GBUFFERMATERIAL_COUNT (3)
+#define GBUFFERMATERIAL_COUNT (4)
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.Lit.SurfaceData
 // PackingRules = Exact

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

 #include "Lit.cs.hlsl"
 
 // Reference Lambert diffuse / GGX Specular for IBL and area lights
-//#define LIT_DISPLAY_REFERENCE
+// #define LIT_DISPLAY_REFERENCE
+// Use Lambert diffuse instead of Disney diffuse
+// #define LIT_DIFFUSE_LAMBERT_BRDF
+// Use optimization of Precomputing LambdaV
+// TODO: Test if this is a win
+// #define LIT_USE_BSDF_PRE_LAMBDAV
 
 // TODO: Check if anisotropy with a dynamic if on anisotropy > 0 is performant. Because it may mean we always calculate both isotrpy and anisotropy case.
 // Maybe we should always calculate anisotropy in case of standard ? Don't think the compile can optimize correctly.
     // f0 * Gv * (1 - Fc) + Gv * Fc
     specularFGD = fresnel0 * preFGD.x + preFGD.y;
 
-#ifdef DIFFUSE_LAMBERT_BRDF
+#ifdef LIT_DIFFUSE_LAMBERT_BRDF
     diffuseFGD = 1.0;
 #else
     diffuseFGD = preFGD.z;
 // Encode SurfaceData (BSDF parameters) into GBuffer
 // Must be in sync with RT declared in HDRenderLoop.cs ::Rebuild
 void EncodeIntoGBuffer( SurfaceData surfaceData,
+                        float3 bakeDiffuseLighting,
-                        out float4 outGBuffer2)
+                        out float4 outGBuffer2,
+                        out float4 outGBuffer3)
 {
     // RT0 - 8:8:8:8 sRGB
     outGBuffer0 = float4(surfaceData.baseColor, surfaceData.specularOcclusion);
     {
         outGBuffer2 = float4(surfaceData.specularColor, 0.0);
     }
+
+    // Lighting
+    outGBuffer3 = float4(bakeDiffuseLighting, 0.0);
-BSDFData DecodeFromGBuffer( float4 inGBuffer0,
-                            float4 inGBuffer1,
-                            float4 inGBuffer2)
+void DecodeFromGBuffer( float4 inGBuffer0,
+                        float4 inGBuffer1,
+                        float4 inGBuffer2,
+                        float4 inGBuffer3,
+                        out BSDFData bsdfData,
+                        out float3 bakeDiffuseLighting)
-    BSDFData bsdfData;
     ZERO_INITIALIZE(BSDFData, bsdfData);
 
     float3 baseColor = inGBuffer0.rgb;
         bsdfData.fresnel0 = inGBuffer2.rgb;
     }
 
-    return bsdfData;
+    bakeDiffuseLighting = inGBuffer3.rgb;
 }
 
 //-----------------------------------------------------------------------------
 // GetBakedDiffuseLigthing function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case)
 // In forward it must be add to the final contribution.
 // This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer.
-float3 GetBakedDiffuseLigthing(PreLightData preLightData, SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData)
+float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData)
 {
     // Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration
     return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor * builtinData.emissiveIntensity;
         float TdotL = saturate(dot(bsdfData.tangentWS, L));
         float BdotL = saturate(dot(bsdfData.bitangentWS, L));
 
-        #ifdef USE_BSDF_PRE_LAMBDAV
+        #ifdef LIT_USE_BSDF_PRE_LAMBDAV
         Vis = V_SmithJointGGXAnisoLambdaV(  preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, TdotL, BdotL, NdotL,
                                             bsdfData.roughnessT, bsdfData.roughnessB, preLightData.anisoGGXLambdaV);
         #else
     }
     else
     {
-        #ifdef USE_BSDF_PRE_LAMBDAV
+        #ifdef LIT_USE_BSDF_PRE_LAMBDAV
         Vis = V_SmithJointGGX(NdotL, preLightData.NdotV, bsdfData.roughness, preLightData.ggxLambdaV);
         #else
         Vis = V_SmithJointGGX(NdotL, preLightData.NdotV, bsdfData.roughness);
     specularLighting.rgb = F * Vis * D;
-    #ifdef DIFFUSE_LAMBERT_BRDF
+    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
     float diffuseTerm = Lambert();
     #else
     float diffuseTerm = DisneyDiffuse(preLightData.NdotV, NdotL, LdotH, bsdfData.perceptualRoughness);
     // TODO: Fresnel is missing here but should be present
     specularLighting.rgb = LTCEvaluate(V, bsdfData.normalWS, preLightData.minV, L, lightData.twoSided) * preLightData.ltcGGXMagnitude;
 
-//#ifdef DIFFUSE_LAMBERT_BRDF
+//#ifdef LIT_DIFFUSE_LAMBERT_BRDF
     // Lambert diffuse term (here it should be Disney)
     float3x3 identity = 0;
     identity._m00_m11_m22 = 1.0;
     specularLighting.a = 1.0;
 
 /*
-    #ifdef DIFFUSE_LAMBERT_BRDF
+    #ifdef LIT_DIFFUSE_LAMBERT_BRDF
     diffuseLighting.rgb = IntegrateLambertIBLRef(lightData, bsdfData);
     #else
     diffuseLighting.rgb = IntegrateDisneyDiffuseIBLRef(lightLoopContext, V, lightData, bsdfData);

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

 float2 CalculateVelocity(float4 positionCS, float4 previousPositionCS)
 {
     // This test on define is required to remove warning of divide by 0 when initializing empty struct
-#if SHADERPASS == SHADERPASS_VELOCITY || (SHADERPASS == SHADERPASS_GBUFFER && defined(VELOCITY_IN_GBUFFER))
+    // TODO: Add forward opaque MRT case...
+#if (SHADERPASS == SHADERPASS_VELOCITY) || (SHADERPASS == SHADERPASS_GBUFFER && SHADEROPTIONS_VELOCITY_IN_GBUFFER)
     // Encode velocity
     positionCS.xy = positionCS.xy / positionCS.w;
     previousPositionCS.xy = previousPositionCS.xy / previousPositionCS.w;

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/LitDefault.shader

     #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
     //-------------------------------------------------------------------------------------
     
     #include "common.hlsl"
-    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPass.cs.hlsl"    
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Material.hlsl

 //-----------------------------------------------------------------------------
 
 // 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 HDRenderLoop, 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)
         float4 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
         float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0));
 
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, NAME) EncodeIntoGBuffer(SURFACE_DATA, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
-#define DECODE_FROM_GBUFFER(NAME) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
+#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)
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 2)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 2)
-#ifdef VELOCITY_IN_GBUFFER
-#define GBUFFER_VELOCITY_NAME(NAME) MERGE_NAME(NAME, 3)
-#define GBUFFER_VELOCITY_TARGET(TARGET) MERGE_NAME(TARGET, 3)
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target2
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 3
         float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
         float4 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0));
 
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, NAME) EncodeIntoGBuffer(SURFACE_DATA, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
-#define DECODE_FROM_GBUFFER(NAME) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
+#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)
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 3)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 3)
-#ifdef VELOCITY_IN_GBUFFER
-#define GBUFFER_VELOCITY_NAME(NAME) MERGE_NAME(NAME, 4)
-#define GBUFFER_VELOCITY_TARGET(TARGET) MERGE_NAME(TARGET, 4)
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target3
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 4
         float4 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
         float4 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0));
 
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, NAME) EncodeIntoGBuffer(SURFACE_DATA, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
-#define DECODE_FROM_GBUFFER(NAME) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
+#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)
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 4)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 4)
-#ifdef VELOCITY_IN_GBUFFER
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 5)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 5)
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target4
 #endif
 
 #elif GBUFFERMATERIAL_COUNT == 5
         float4 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0)); \
         float4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), uint3(UV, 0));
 
-#define ENCODE_INTO_GBUFFER(SURFACE_DATA, NAME) EncodeIntoGBuffer(SURFACE_DATA, 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) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
+#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)
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 5)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 5)
-#ifdef VELOCITY_IN_GBUFFER
-#define GBUFFER_BAKE_LIGHTING_NAME(NAME) MERGE_NAME(NAME, 6)
-#define GBUFFER_BAKE_LIGHTING_TARGET(TARGET) MERGE_NAME(TARGET, 6)
+#if SHADEROPTIONS_VELOCITY_IN_GBUFFER
+#define OUTPUT_GBUFFER_VELOCITY(NAME) ,out float4 NAME : SV_Target5
-#endif // #if GBUFFERMATERIAL_COUNT == 3
+#endif
-// Generic whatever the number of GBuffer
-#define OUTPUT_GBUFFER_BAKE_LIGHTING(NAME) out float4 GBUFFER_BAKE_LIGHTING_NAME(NAME) : GBUFFER_BAKE_LIGHTING_TARGET(SV_Target)
-#define DECLARE_GBUFFER_BAKE_LIGHTING(NAME) TEXTURE2D(GBUFFER_BAKE_LIGHTING_NAME(NAME));
-#define ENCODE_BAKE_LIGHTING_INTO_GBUFFER(BAKE_DIFFUSE_LIGHTING, NAME) EncodeBakedDiffuseLigthingIntoGBuffer(BAKE_DIFFUSE_LIGHTING, GBUFFER_BAKE_LIGHTING_NAME(NAME))
-#define FETCH_BAKE_LIGHTING_GBUFFER(NAME, TEX, UV) float4 GBUFFER_BAKE_LIGHTING_NAME(NAME) = LOAD_TEXTURE2D(GBUFFER_BAKE_LIGHTING_NAME(TEX), uint3(UV, 0));
-#define DECODE_BAKE_LIGHTING_FROM_GBUFFER(NAME) DecodeBakedDiffuseLigthingFromGBuffer(GBUFFER_BAKE_LIGHTING_NAME(NAME))
-
-#ifdef VELOCITY_IN_GBUFFER
-#define OUTPUT_GBUFFER_VELOCITY(NAME) out float4 GBUFFER_VELOCITY_NAME(NAME) : GBUFFER_VELOCITY_TARGET(SV_Target)
-#define DECLARE_GBUFFER_VELOCITY_TEXTURE(NAME) TEXTURE2D(GBUFFER_VELOCITY_NAME(NAME));
-#define ENCODE_VELOCITY_INTO_GBUFFER(VELOCITY, NAME) EncodeVelocity(VELOCITY, GBUFFER_VELOCITY_NAME(NAME))
+#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

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Unlit/UnlitDefault.shader

     //-------------------------------------------------------------------------------------
 
     #include "common.hlsl"
-    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs"
+    #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPass.cs.hlsl"    
     #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Debug/DebugViewMaterial.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs

+using UnityEngine;
+using UnityEngine.Rendering;
+using System;
-// #define DIFFUSE_LAMBERT_BRDF
-// #define USE_BSDF_PRE_LAMBDAV
+namespace UnityEngine.Experimental.ScriptableRenderLoop
+{
+    [GenerateHLSL(PackingRules.Exact)]
+    public enum ShaderOptions
+    {
+        // TODO: Currently it is not yet possible to use this feature, we need to provide previousPositionCS to the vertex shader as part of Attribute for GBuffer pass
+        // TODO: How to enable this feature only on mesh that effectively require it like skinned and moving mesh (other can be done with depth reprojection. But TAA can be an issue)
+        VelocityInGBuffer = 0, // Change to 1 to enable the feature
+        PackGBufferInFP16 = 0
+    };
+
+    // Note: #define can't be use in include file in C# so we choes this way to configure both C# and hlsl
+    // Changing a value in this enum Config here require to regenerate the hlsl include and recompile C# and shaders
+    public class ShaderConfig
+    {
+        public const int VelocityInGbuffer = (int)ShaderOptions.VelocityInGBuffer;
+        public const int PackgbufferInFP16 = (int)ShaderOptions.PackGBufferInFP16;
+    }
+}
-// Note: C# define can't be reuse in another C# file and ideally we would like that these define are present both on C# and HLSL side... How to do that ?
-// For now sync by hand within HDRenderLoop.cs file and this one
-// TODO: Currently it is not yet possible to use this feature, we need to provide previousPositionCS to the vertex shader as part of Attribute for GBuffer pass
 //#define VELOCITY_IN_GBUFFER

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassForward.hlsl

 
 	float4 diffuseLighting;
 	float4 specularLighting;
-    float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(preLightData, surfaceData, builtinData, bsdfData);
+    float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
     LightLoop(V, positionWS, preLightData, bsdfData, bakeDiffuseLighting, diffuseLighting, specularLighting);
 
 	return float4(diffuseLighting.rgb + specularLighting.rgb, builtinData.opacity);

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassGBuffer.hlsl

 #endif
 
 void Frag(  PackedVaryings packedInput,
-			OUTPUT_GBUFFER(outGBuffer),
-			OUTPUT_GBUFFER_BAKE_LIGHTING(outGBuffer)
-            #ifdef VELOCITY_IN_GBUFFER
-            , OUTPUT_GBUFFER_VELOCITY(outGBuffer)
-            #endif
+			OUTPUT_GBUFFER(outGBuffer)
+            OUTPUT_GBUFFER_VELOCITY(outVelocityBuffer)
 			)
 {
     FragInput input = UnpackVaryings(packedInput);
 	BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
 	Coordinate coord = GetCoordinate(input.unPositionSS.xy, _ScreenSize.zw);
 	PreLightData preLightData = GetPreLightData(V, positionWS, coord, bsdfData);
+    float3 bakeDiffuseLighting = GetBakedDiffuseLigthing(surfaceData, builtinData, bsdfData, preLightData);
-	ENCODE_INTO_GBUFFER(surfaceData, outGBuffer);
-	ENCODE_BAKE_LIGHTING_INTO_GBUFFER(GetBakedDiffuseLigthing(preLightData, surfaceData, builtinData, bsdfData), outGBuffer);
-	#ifdef VELOCITY_IN_GBUFFER
-	ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outGBuffer);
-	#endif
+	ENCODE_INTO_GBUFFER(surfaceData, bakeDiffuseLighting, outGBuffer);
+    ENCODE_VELOCITY_INTO_GBUFFER(builtinData.velocity, outVelocityBuffer);
 }

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

                     const float degToRad = (float)(pi / 180.0);
 
 
-                    var sa = cl.spotAngle;
+                    var sa = cl.light.spotAngle;
 
                     var cs = Mathf.Cos(0.5f * sa * degToRad);
                     var si = Mathf.Sin(0.5f * sa * degToRad);
             // do anything we need to do upon a new frame.
             NewFrame ();
 
-            if(!k_UseAsyncCompute) RenderShadowMaps(cullResults, loop);
-
+#pragma warning disable 162 // warning CS0162: Unreachable code detected
+            if (!k_UseAsyncCompute) RenderShadowMaps(cullResults, loop);
+#pragma warning restore 162
             // generate g-buffer before shadows to leverage async compute
             // forward opaques just write to depth.
             loop.SetupCameraProperties(camera);
 
         private float PerceptualRoughnessToBlinnPhongPower(float perceptualRoughness)
         {
+#pragma warning disable 162 // warning CS0162: Unreachable code detected
             // There is two code here, by default the code corresponding for UNITY_GLOSS_MATCHES_MARMOSET_TOOLBAG2 was use for cloud reasons
             // The other code (not marmoset) is not matching the shader code for cloud reasons.
             // As none of this solution match BRDF 1 or 2, I let the Marmoset code to avoid to break current test. But ideally, all this should be rewrite to match BRDF1
 
                 return n;
             }
+#pragma warning restore 162
         }
         private float PerceptualRoughnessToPhongPower(float perceptualRoughness)
         {

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl

+//
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.  Please don't edit by hand.
+//
+
+#ifndef SHADERCONFIG_CS_HLSL
+#define SHADERCONFIG_CS_HLSL
+//
+// UnityEngine.Experimental.ScriptableRenderLoop.ShaderOptions:  static fields
+//
+#define SHADEROPTIONS_VELOCITY_IN_GBUFFER (0)
+#define SHADEROPTIONS_PACK_GBUFFER_IN_FP16 (0)
+
+
+#endif

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl.meta

+fileFormatVersion: 2
+guid: ca6f5e7099c13ae489aa982d4af7599d
+timeCreated: 1478905378
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: