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

Assets/BasicRenderLoopTutorial/BasicRenderLoop.cs

 
     private ShaderPassName shaderPassBasic;
 
-    public void OnEnable()
+    public override void Build()
-        Rebuild();
-    public override void Initialize()
+    public override void Cleanup()
-        shaderPassBasic = new ShaderPassName("BasicPass");
     }
 
     // Main entry point for our scriptable render loop
             SetupLightShaderVariables (cull.visibleLights, loop);
 
             // Draw opaque objects using BasicPass shader pass
-            var settings = new DrawRendererSettings (cull, camera, shaderPassBasic);
+            var settings = new DrawRendererSettings (cull, camera, new ShaderPassName("BasicPass"));
             settings.sorting.flags = SortFlags.CommonOpaque;
             settings.inputFilter.SetQueuesOpaque ();
             loop.DrawRenderers (ref settings);

Assets/Editor/Tests/RenderloopTests/RenderloopTestFixture.cs

         renderLoop.Submit();
     }
 
+    public override void Build()
+    {
+        
+    }
+
+    public override void Cleanup()
+    {
+        
+    }
+
     public static void Run(TestDelegate renderCallback)
     {
         if (m_Instance == null)

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

             public readonly int[] shadowsCascadeCountValues = new int[] { 1, 2, 3, 4 };
             public readonly GUIContent shadowsCascades = new GUIContent("Cascade values");
 
-            public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop settings");
+            public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop Settings");
             public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Punctual Light", "Area Light", "Env Light"};
             public readonly GUIContent splitLightEvaluation = new GUIContent("Split light and reflection evaluation", "Toggle");
             public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
 
 
-            public readonly GUIContent textureSettings = new GUIContent("texture Settings");
+            public readonly GUIContent textureSettings = new GUIContent("Texture Settings");
-            public readonly GUIContent spotCookieSize = new GUIContent("spotCookie Size");
-            public readonly GUIContent pointCookieSize = new GUIContent("pointCookie Size");
-            public readonly GUIContent reflectionCubemapSize = new GUIContent("reflectionCubemap Size");              
+            public readonly GUIContent spotCookieSize = new GUIContent("Spot cookie size");
+            public readonly GUIContent pointCookieSize = new GUIContent("Point cookie size");
+            public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection cubemap size");              
         }
 
         private static Styles s_Styles = null;
             }
         }
 
-        public override void OnInspectorGUI()
+        private void DebugParametersUI(HDRenderLoop renderLoop)
-            var renderLoop = target as HDRenderLoop;
-
-            if (!renderLoop)
-                return;
-
             var debugParameters = renderLoop.debugParameters;
 
             EditorGUILayout.LabelField(styles.debugParameters);
                 EditorUtility.SetDirty(renderLoop); // Repaint
             }
             EditorGUI.indentLevel--;
+        }
+        private void SkyParametersUI(HDRenderLoop renderLoop)
+        {
             EditorGUILayout.Space();
             var skyParameters = renderLoop.skyParameters;
 
                 EditorUtility.SetDirty(renderLoop); // Repaint
             }
             EditorGUI.indentLevel--;
+        }
+        private void ShadowParametersUI(HDRenderLoop renderLoop)
+        {
             EditorGUILayout.Space();
             var shadowParameters = renderLoop.shadowSettings;
 
                 EditorUtility.SetDirty(renderLoop); // Repaint
             }
             EditorGUI.indentLevel--;
+        }
+        private void TextureParametersUI(HDRenderLoop renderLoop)
+        {
             EditorGUILayout.Space();
             var textureParameters = renderLoop.textureSettings;
 
 
             if (EditorGUI.EndChangeCheck())
             {
+                renderLoop.textureSettings = textureParameters;
+        }
-
+        private void TilePassUI(HDRenderLoop renderLoop)
+        {
             EditorGUILayout.Space();
 
             // TODO: we should call a virtual method or something similar to setup the UI, inspector should not know about it
                 {
                     EditorUtility.SetDirty(renderLoop); // Repaint
 
-                    // If something is chanage regarding tile/cluster rendering we need to force a OnValidate() OnHDRenderLoop, else change Rebuild() will not be call
-                    renderLoop.OnValidate();
+                    // SetAssetDirty will tell renderloop to rebuild
+                    renderLoop.SetAssetDirty();
                 }
 
                 EditorGUI.BeginChangeCheck();
                 }
                 EditorGUI.indentLevel--;
             }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var renderLoop = target as HDRenderLoop;
+
+            if (!renderLoop)
+                return;
+
+            DebugParametersUI(renderLoop);
+            SkyParametersUI(renderLoop);
+            ShadowParametersUI(renderLoop);
+            TextureParametersUI(renderLoop);
+            TilePassUI(renderLoop);
         }
     }
 }

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

         public TextureSettings textureSettings
         {
             get { return m_TextureSettings; }
+            set { m_TextureSettings = value; }
         }
 
         // Various set of material use in render loop
         int m_CameraDepthBuffer;
         int m_VelocityBuffer;
         int m_DistortionBuffer;
-
-        public bool m_Dirty = false;
 
         RenderTargetIdentifier m_CameraColorBufferRT;
         RenderTargetIdentifier m_CameraDepthBufferRT;
         // TODO TO CHECK: SebL I move allocation from Rebuild() to here, but there was a comment "// Our object can be garbage collected, so need to be allocate here", it is still true ?
         Lit.RenderLoop m_LitRenderLoop = new Lit.RenderLoop();
 
-        public void OnValidate()
-        {
-            // Calling direction Rebuild() here cause this warning:
-            // "SendMessage cannot be called during Awake, CheckConsistency, or OnValidate UnityEngine.Experimental.ScriptableRenderLoop.HDRenderLoop:OnValidate()"
-            // Workaround is to declare this dirty flag and call REbuild in Render()
-            m_Dirty = true;
-        }
-
-        public override void Rebuild()
+        public override void Build()
-            // We call Cleanup() here because Rebuild() can be call by OnValidate(), i.e when inspector is touch
-            // Note that module don't need to do the same as the call here is propagated correctly
-            Cleanup();
+#if UNITY_EDITOR
+            UnityEditor.SupportedRenderingFeatures.active = new UnityEditor.SupportedRenderingFeatures
+            {
+                reflectionProbe = UnityEditor.SupportedRenderingFeatures.ReflectionProbe.Rotation
+            };
+#endif
 
             m_CameraColorBuffer = Shader.PropertyToID("_CameraColorTexture");
             m_CameraDepthBuffer  = Shader.PropertyToID("_CameraDepthTexture");
 
             m_LitRenderLoop.Rebuild();
             m_lightLoop.Rebuild(m_TextureSettings);
-
-            m_Dirty = false;
-        }
-
-        public override void Initialize()
-        {
-#if UNITY_EDITOR
-            UnityEditor.SupportedRenderingFeatures.active = new UnityEditor.SupportedRenderingFeatures
-            {
-                reflectionProbe = UnityEditor.SupportedRenderingFeatures.ReflectionProbe.Rotation
-            };
-#endif
-
-            Rebuild();
         }
 
         public override void Cleanup()
 
         public override void Render(Camera[] cameras, RenderLoop renderLoop)
         {
-            if (m_Dirty)
-            {
-                Rebuild();
-            }
-
             if (!m_LitRenderLoop.isInit)
             {
                 m_LitRenderLoop.RenderInit(renderLoop);

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

 #ifndef __SHADERBASE_H__
 #define __SHADERBASE_H__
 
+// can't use UNITY_REVERSED_Z since it's not enabled in compute shaders
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+	#define REVERSE_ZBUF
+#endif
+
 #ifdef SHADER_API_PSSL
 
 #ifndef Texture2DMS
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
 	float zdpth = LOAD_TEXTURE2D(depthTexture, pixCoord.xy).x;
-#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+#ifdef REVERSE_ZBUF
 	zdpth = 1.0 - zdpth;
 #endif
 	return zdpth;
 {
 	float zdpth = LOAD_TEXTURE2D_MSAA(depthTexture, pixCoord.xy, sampleIdx).x;
-#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+#ifdef REVERSE_ZBUF
     zdpth = 1.0 - zdpth;
 #endif
 	return zdpth;

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

-
-
-// In unity we can have a mix of fully baked lightmap (static lightmap) + enlighten realtime lightmap (dynamic lightmap)
-// for each case we can have directional lightmap or not.
-// Else we have lightprobe for dynamic/moving entity. Either SH9 per object lightprobe or SH4 per pixel per object volume probe
-float3 SampleBakedGI(float3 positionWS, float3 normalWS, float2 uvStaticLightmap, float2 uvDynamicLightmap)
-{
-    // If there is no lightmap, it assume lightprobe
-#if !defined(LIGHTMAP_ON) && !defined(DYNAMICLIGHTMAP_ON)
-
-// TODO: Confirm with Ionut but it seems that UNITY_LIGHT_PROBE_PROXY_VOLUME is always define for high end and 
-// unity_ProbeVolumeParams always bind.
-    if (unity_ProbeVolumeParams.x == 0.0)
-    {
-        // TODO: pass a tab of coefficient instead!
-        float4 SHCoefficients[7];
-        SHCoefficients[0] = unity_SHAr;
-        SHCoefficients[1] = unity_SHAg;
-        SHCoefficients[2] = unity_SHAb;
-        SHCoefficients[3] = unity_SHBr;
-        SHCoefficients[4] = unity_SHBg;
-        SHCoefficients[5] = unity_SHBb;
-        SHCoefficients[6] = unity_SHC;
-
-        return SampleSH9(SHCoefficients, normalWS);
-    }
-    else
-    {
-        // TODO: Move all this to C++!
-        float4x4 identity = 0;
-        identity._m00_m11_m22_m33 = 1.0;
-        float4x4 WorldToTexture = (unity_ProbeVolumeParams.y == 1.0f) ? unity_ProbeVolumeWorldToObject : identity;
-
-        float4x4 translation = identity;
-        translation._m30_m31_m32 = -unity_ProbeVolumeMin.xyz;
-
-        float4x4 scale = 0;
-        scale._m00_m11_m22_m33 = float4(unity_ProbeVolumeSizeInv.xyz, 1.0);
-
-        WorldToTexture = mul(mul(scale, translation), WorldToTexture);
-    
-        return SampleProbeVolumeSH4(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), positionWS, normalWS, WorldToTexture, unity_ProbeVolumeParams.z);
-    }
-
-#else
-
-    float3 bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
-
-    #ifdef LIGHTMAP_ON
-        #ifdef DIRLIGHTMAP_COMBINED
-        bakeDiffuseLighting += SampleDirectionalLightmap(TEXTURE2D_PARAM(unity_Lightmap, samplerunity_Lightmap),
-                                                        TEXTURE2D_PARAM(unity_LightmapInd, samplerunity_Lightmap),
-                                                        uvStaticLightmap, unity_LightmapST, normalWS);
-        #else
-        bakeDiffuseLighting += SampleSingleLightmap(TEXTURE2D_PARAM(unity_Lightmap, samplerunity_Lightmap), uvStaticLightmap, unity_LightmapST);
-        #endif
-    #endif
-
-    #ifdef DYNAMICLIGHTMAP_ON
-        #ifdef DIRLIGHTMAP_COMBINED
-        bakeDiffuseLighting += SampleDirectionalLightmap(TEXTURE2D_PARAM(unity_DynamicLightmap, samplerunity_DynamicLightmap),
-                                                        TEXTURE2D_PARAM(unity_DynamicDirectionality, samplerunity_DynamicLightmap),
-                                                        uvDynamicLightmap, unity_DynamicLightmapST, normalWS);
-        #else
-        bakeDiffuseLighting += SampleSingleLightmap(TEXTURE2D_PARAM(unity_DynamicLightmap, samplerunity_DynamicLightmap), uvDynamicLightmap, unity_DynamicLightmapST);
-        #endif
-    #endif
-
-    return bakeDiffuseLighting;
-
-#endif
-}
-
-float2 CalculateVelocity(float4 positionCS, float4 previousPositionCS)
-{
-    // This test on define is required to remove warning of divide by 0 when initializing empty struct
-    // 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;
-
-    return (positionCS.xy - previousPositionCS.xy) * _ForceNoMotion;
-#else
-    return float2(0.0, 0.0);
-#endif
-}
+#include "../MaterialUtilities.hlsl"
 
 void GetBuiltinData(FragInput input, SurfaceData surfaceData, float alpha, out BuiltinData builtinData)
 {

Assets/ScriptableRenderLoop/HDRenderLoop/Sky/SkyRenderer.cs

 
         MaterialPropertyBlock m_RenderSkyPropertyBlock = null;
 
-        GameObject[] m_CubemapFaceCamera = new GameObject[6];
+        Matrix4x4[] m_faceCameraInvViewProjectionMatrix = new Matrix4x4[6];
-        Mesh BuildSkyMesh(Camera camera, bool forceUVBottom)
+        Mesh BuildSkyMesh(Vector3 cameraPosition, Matrix4x4 cameraInvViewProjectionMatrix, bool forceUVBottom)
         {
             Vector4 vertData0 = new Vector4(-1.0f, -1.0f, 1.0f, 1.0f);
             Vector4 vertData1 = new Vector4(1.0f, -1.0f, 1.0f, 1.0f);
             // Get view vector based on the frustum, i.e (invert transform frustum get position etc...)
             Vector3[] eyeVectorData = new Vector3[4];
 
-            Matrix4x4 transformMatrix = camera.cameraToWorldMatrix * camera.projectionMatrix.inverse;
+            Matrix4x4 transformMatrix = cameraInvViewProjectionMatrix;
 
             Vector4 posWorldSpace0 = transformMatrix * vertData0;
             Vector4 posWorldSpace1 = transformMatrix * vertData1;
-            Vector3 temp = camera.GetComponent<Transform>().position;
-            Vector4 cameraPosition = new Vector4(temp.x, temp.y, temp.z, 0.0f);
+            Vector4 cameraPos = new Vector4(cameraPosition.x, cameraPosition.y, cameraPosition.z, 0.0f);
-            Vector4 direction0 = (posWorldSpace0 / posWorldSpace0.w - cameraPosition);
-            Vector4 direction1 = (posWorldSpace1 / posWorldSpace1.w - cameraPosition);
-            Vector4 direction2 = (posWorldSpace2 / posWorldSpace2.w - cameraPosition);
-            Vector4 direction3 = (posWorldSpace3 / posWorldSpace3.w - cameraPosition);
+            Vector4 direction0 = (posWorldSpace0 / posWorldSpace0.w - cameraPos);
+            Vector4 direction1 = (posWorldSpace1 / posWorldSpace1.w - cameraPos);
+            Vector4 direction2 = (posWorldSpace2 / posWorldSpace2.w - cameraPos);
+            Vector4 direction3 = (posWorldSpace3 / posWorldSpace3.w - cameraPos);
 
             if (SystemInfo.graphicsUVStartsAtTop && !forceUVBottom)
             {
 
             for (int i = 0; i < 6; ++i)
             {
-                m_CubemapFaceCamera[i] = new GameObject();
-                m_CubemapFaceCamera[i].hideFlags = HideFlags.HideAndDontSave;
-
-                Camera camera = m_CubemapFaceCamera[i].AddComponent<Camera>();
-                camera.projectionMatrix = cubeProj;
-                Transform transform = camera.GetComponent<Transform>();
-                transform.LookAt(lookAtList[i], UpVectorList[i]);
+                Matrix4x4 lookAt = Matrix4x4.LookAt(Vector3.zero, lookAtList[i], UpVectorList[i]);
+                m_faceCameraInvViewProjectionMatrix[i] = Utilities.GetViewProjectionMatrix(lookAt, cubeProj).inverse;
-                m_CubemapFaceMesh[i] = BuildSkyMesh(camera, true);
+                m_CubemapFaceMesh[i] = BuildSkyMesh(Vector3.zero, m_faceCameraInvViewProjectionMatrix[i], true);
             }
         }
 
             Utilities.Destroy(m_GGXConvolveMaterial);
             Utilities.Destroy(m_SkyboxCubemapRT);
             Utilities.Destroy(m_SkyboxGGXCubemapRT);
-
-            for(int i = 0 ; i < 6 ; ++i)
-            {
-                Utilities.Destroy(m_CubemapFaceCamera[i]);
-            }
-
         }
 
         public bool IsSkyValid(SkyParameters parameters)
         }
 
-        private void RenderSky(Camera camera, SkyParameters skyParameters, Mesh skyMesh, RenderLoop renderLoop)
+        private void RenderSky(Matrix4x4 invViewProjectionMatrix, SkyParameters skyParameters, Mesh skyMesh, RenderLoop renderLoop)
-            m_RenderSkyPropertyBlock.SetMatrix("_InvViewProjMatrix", Utilities.GetViewProjectionMatrix(camera).inverse);
+            m_RenderSkyPropertyBlock.SetMatrix("_InvViewProjMatrix", invViewProjectionMatrix);
 
             var cmd = new CommandBuffer { name = "" };
             cmd.DrawMesh(skyMesh, Matrix4x4.identity, m_SkyHDRIMaterial, 0, 0, m_RenderSkyPropertyBlock);
             for (int i = 0; i < 6; ++i)
             {
                 Utilities.SetRenderTarget(renderLoop, target, 0, (CubemapFace)i);
-                Camera faceCamera = m_CubemapFaceCamera[i].GetComponent<Camera>();
-                RenderSky(faceCamera, skyParameters, m_CubemapFaceMesh[i], renderLoop);
+                RenderSky(m_faceCameraInvViewProjectionMatrix[i], skyParameters, m_CubemapFaceMesh[i], renderLoop);
             }
         }
 
 
                     // Render the sky itself
                     Utilities.SetRenderTarget(renderLoop, colorBuffer, depthBuffer);
-                    RenderSky(camera, skyParameters, BuildSkyMesh(camera, false), renderLoop);
+                    Matrix4x4 invViewProjectionMatrix = Utilities.GetViewProjectionMatrix(camera).inverse;
+                    RenderSky(invViewProjectionMatrix, skyParameters, BuildSkyMesh(camera.GetComponent<Transform>().position, invViewProjectionMatrix, false), renderLoop);
                 }
             }
         }

Assets/ScriptableRenderLoop/HDRenderLoop/Utilities.cs

                 disposed = true;
             }
         }
-
-        public static Matrix4x4 GetViewProjectionMatrix(Camera camera)
+        public static Matrix4x4 GetViewProjectionMatrix(Matrix4x4 worldToViewMatrix, Matrix4x4 projectionMatrix)
-            var gpuProj = GL.GetGPUProjectionMatrix(camera.projectionMatrix, false);
-            var gpuVP = gpuProj * camera.worldToCameraMatrix;
+            var gpuProj = GL.GetGPUProjectionMatrix(projectionMatrix, false);
+            var gpuVP = gpuProj * worldToViewMatrix;
+        }
+
+        public static Matrix4x4 GetViewProjectionMatrix(Camera camera)
+        {
+            return GetViewProjectionMatrix(camera.worldToCameraMatrix, camera.projectionMatrix);
         }
 
         public static Vector4 ComputeScreenSize(Camera camera)

Assets/ScriptableRenderLoop/common/ShaderBase.h

 #ifndef __SHADERBASE_H__
 #define __SHADERBASE_H__
 
+// can't use UNITY_REVERSED_Z since it's not enabled in compute shaders
+#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+	#define REVERSE_ZBUF
+#endif
+
 #ifdef SHADER_API_PSSL
 
 #ifndef Texture2DMS
 float FetchDepth(Texture2D depthTexture, uint2 pixCoord)
 {
 	float zdpth = depthTexture.Load(uint3(pixCoord.xy, 0)).x;
-#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+#ifdef REVERSE_ZBUF
 	zdpth = 1.0 - zdpth;
 #endif
     return zdpth;
 {
 	float zdpth = depthTexture.Load(uint3(pixCoord.xy, 0), sampleIdx).x;
-#if !defined(SHADER_API_GLES3) && !defined(SHADER_API_GLCORE)
+#ifdef REVERSE_ZBUF
 	zdpth = 1.0 - zdpth;
 #endif
     return zdpth;

Assets/ScriptableRenderLoop/common/TextureSettings.cs

 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     [System.Serializable]
-    public class TextureSettings
+    public struct TextureSettings
     {
         public int spotCookieSize;
         public int pointCookieSize;

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

         private Texture2D m_LightAttentuationTexture;
         private int m_shadowBufferID;
 
-        private void OnValidate()
-        {
-            Rebuild();
-        }
-
-        public override void Initialize()
-        {
-            Rebuild();
-        }
-
-            // RenderLoop.renderLoopDelegate -= ExecuteRenderLoop;
             if (m_DeferredMaterial) DestroyImmediate(m_DeferredMaterial);
             if (m_DeferredReflectionMaterial) DestroyImmediate(m_DeferredReflectionMaterial);
             if (m_BlitMaterial) DestroyImmediate(m_BlitMaterial);
             }
         }
 
-        public override void Rebuild()
+        public override void Build()
-            ClearComputeBuffers();
-
             s_GBufferAlbedo = Shader.PropertyToID("_CameraGBufferTexture0");
             s_GBufferSpecRough = Shader.PropertyToID("_CameraGBufferTexture1");
             s_GBufferNormal = Shader.PropertyToID("_CameraGBufferTexture2");

Assets/ScriptableRenderLoop/fptl/LightingTemplate.hlsl

 
 
 #define DECLARE_SHADOWMAP( tex ) Texture2D tex; SamplerComparisonState sampler##tex
-#define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, (coord).z )
+#ifdef REVERSE_ZBUF
+	#define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, (coord).z )
+#else
+	#define SAMPLE_SHADOW( tex, coord ) tex.SampleCmpLevelZero( sampler##tex, (coord).xy, 1.0-(coord).z )
+#endif
 
 DECLARE_SHADOWMAP(g_tShadowBuffer);
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/MaterialUtilities.hlsl

+// In unity we can have a mix of fully baked lightmap (static lightmap) + enlighten realtime lightmap (dynamic lightmap)
+// for each case we can have directional lightmap or not.
+// Else we have lightprobe for dynamic/moving entity. Either SH9 per object lightprobe or SH4 per pixel per object volume probe
+float3 SampleBakedGI(float3 positionWS, float3 normalWS, float2 uvStaticLightmap, float2 uvDynamicLightmap)
+{
+    // If there is no lightmap, it assume lightprobe
+#if !defined(LIGHTMAP_ON) && !defined(DYNAMICLIGHTMAP_ON)
+
+// TODO: Confirm with Ionut but it seems that UNITY_LIGHT_PROBE_PROXY_VOLUME is always define for high end and 
+// unity_ProbeVolumeParams always bind.
+    if (unity_ProbeVolumeParams.x == 0.0)
+    {
+        // TODO: pass a tab of coefficient instead!
+        float4 SHCoefficients[7];
+        SHCoefficients[0] = unity_SHAr;
+        SHCoefficients[1] = unity_SHAg;
+        SHCoefficients[2] = unity_SHAb;
+        SHCoefficients[3] = unity_SHBr;
+        SHCoefficients[4] = unity_SHBg;
+        SHCoefficients[5] = unity_SHBb;
+        SHCoefficients[6] = unity_SHC;
+
+        return SampleSH9(SHCoefficients, normalWS);
+    }
+    else
+    {
+        // TODO: Move all this to C++!
+        float4x4 identity = 0;
+        identity._m00_m11_m22_m33 = 1.0;
+        float4x4 WorldToTexture = (unity_ProbeVolumeParams.y == 1.0f) ? unity_ProbeVolumeWorldToObject : identity;
+
+        float4x4 translation = identity;
+        translation._m30_m31_m32 = -unity_ProbeVolumeMin.xyz;
+
+        float4x4 scale = 0;
+        scale._m00_m11_m22_m33 = float4(unity_ProbeVolumeSizeInv.xyz, 1.0);
+
+        WorldToTexture = mul(mul(scale, translation), WorldToTexture);
+    
+        return SampleProbeVolumeSH4(TEXTURE3D_PARAM(unity_ProbeVolumeSH, samplerunity_ProbeVolumeSH), positionWS, normalWS, WorldToTexture, unity_ProbeVolumeParams.z);
+    }
+
+#else
+
+    float3 bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
+
+    #ifdef LIGHTMAP_ON
+        #ifdef DIRLIGHTMAP_COMBINED
+        bakeDiffuseLighting += SampleDirectionalLightmap(TEXTURE2D_PARAM(unity_Lightmap, samplerunity_Lightmap),
+                                                        TEXTURE2D_PARAM(unity_LightmapInd, samplerunity_Lightmap),
+                                                        uvStaticLightmap, unity_LightmapST, normalWS);
+        #else
+        bakeDiffuseLighting += SampleSingleLightmap(TEXTURE2D_PARAM(unity_Lightmap, samplerunity_Lightmap), uvStaticLightmap, unity_LightmapST);
+        #endif
+    #endif
+
+    #ifdef DYNAMICLIGHTMAP_ON
+        #ifdef DIRLIGHTMAP_COMBINED
+        bakeDiffuseLighting += SampleDirectionalLightmap(TEXTURE2D_PARAM(unity_DynamicLightmap, samplerunity_DynamicLightmap),
+                                                        TEXTURE2D_PARAM(unity_DynamicDirectionality, samplerunity_DynamicLightmap),
+                                                        uvDynamicLightmap, unity_DynamicLightmapST, normalWS);
+        #else
+        bakeDiffuseLighting += SampleSingleLightmap(TEXTURE2D_PARAM(unity_DynamicLightmap, samplerunity_DynamicLightmap), uvDynamicLightmap, unity_DynamicLightmapST);
+        #endif
+    #endif
+
+    return bakeDiffuseLighting;
+
+#endif
+}
+
+float2 CalculateVelocity(float4 positionCS, float4 previousPositionCS)
+{
+    // This test on define is required to remove warning of divide by 0 when initializing empty struct
+    // 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;
+
+    return (positionCS.xy - previousPositionCS.xy) * _ForceNoMotion;
+#else
+    return float2(0.0, 0.0);
+#endif
+}

Assets/ScriptableRenderLoop/HDRenderLoop/Material/MaterialUtilities.hlsl.meta

+fileFormatVersion: 2
+guid: 79a3fb95997b9d54d98b5888a5082570
+timeCreated: 1481202371
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: