Merge branch 'master' into update-changelog

.gitignore

 TestProjects/GraphicsTests/Temp/
 TestProjects/LWRP/GraphicsTests/Temp/
 TestProjects/LWRP/GraphicsTests/obj/
+TestProjects/ShaderGraph/Temp/

TestProjects/ShaderGraph/Assets/Testing/Editor/IntegrationTests/ShaderGenerationTest.cs

                 Object.DestroyImmediate(m_FromDisk);
         }
 
-        [Test, TestCaseSource(typeof(CollectGraphs), "graphs")]
+      // [Test, TestCaseSource(typeof(CollectGraphs), "graphs")]
+        [Ignore("Not currently runable")]
         public void Graph(TestInfo testInfo)
         {
             var file = testInfo.info;

build.py

         ("com.unity.render-pipelines.lightweight", os.path.join("com.unity.render-pipelines.lightweight")),
         ("com.unity.render-pipelines.high-definition", os.path.join("com.unity.render-pipelines.high-definition")),
         ("com.unity.shadergraph", os.path.join("com.unity.shadergraph")),
+        ("com.unity.postprocessing", os.path.join("com.unity.postprocessing")),
     ]
 
 def test_packages_list():
         "com.unity.render-pipelines.high-definition",
-        "com.unity.shadergraph"
+        "com.unity.shadergraph",
+        "com.unity.postprocessing"
     ]
 
 if __name__ == "__main__":

com.unity.render-pipelines.core/CoreRP/Editor/CoreEditorUtils.cs

 using System;
+using System.IO;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 
 namespace UnityEditor.Experimental.Rendering
 {
+    using UnityObject = UnityEngine.Object;
+
     public static class CoreEditorUtils
     {
         // GUIContent cache utilities
 
             return data;
         }
-    }
-    static class ShadowCascadeSplitGUI
-    {
-        private const int kSliderbarTopMargin = 2;
-        private const int kSliderbarHeight = 24;
-        private const int kSliderbarBottomMargin = 2;
-        private const int kPartitionHandleWidth = 2;
-        private const int kPartitionHandleExtraHitAreaWidth = 2;
-
-        private static readonly Color[] kCascadeColors =
+        static public GameObject CreateGameObject(GameObject parent, string name, params Type[] types)
-            new Color(0.5f, 0.5f, 0.6f, 1.0f),
-            new Color(0.5f, 0.6f, 0.5f, 1.0f),
-            new Color(0.6f, 0.6f, 0.5f, 1.0f),
-            new Color(0.6f, 0.5f, 0.5f, 1.0f),
-        };
+            return ObjectFactory.CreateGameObject(GameObjectUtility.GetUniqueNameForSibling(parent != null ? parent.transform : null, name), types);
+        }
-        // using a LODGroup skin
-        private static readonly GUIStyle s_CascadeSliderBG = "LODSliderRange";
-        private static readonly GUIStyle s_TextCenteredStyle =  new GUIStyle(EditorStyles.whiteMiniLabel)
+        static public string GetCurrentProjectVersion()
-            alignment = TextAnchor.MiddleCenter
-        };
+            string[] readText = File.ReadAllLines("ProjectSettings/ProjectVersion.txt");
+            // format is m_EditorVersion: 2018.2.0b7
+            string[] versionText = readText[0].Split(' ');
+            return versionText[1];
+        }
-        // Internal struct to bundle drag information
-        private class DragCache
+        static public void CheckOutFile(bool VCSEnabled, UnityObject mat)
-            public int      m_ActivePartition;          // the cascade partition that we are currently dragging/resizing
-            public float    m_NormalizedPartitionSize;  // the normalized size of the partition (0.0f < size < 1.0f)
-            public Vector2  m_LastCachedMousePosition;  // mouse position the last time we registered a drag or mouse down.
-
-            public DragCache(int activePartition, float normalizedPartitionSize, Vector2 currentMousePos)
+            if (VCSEnabled)
-                m_ActivePartition = activePartition;
-                m_NormalizedPartitionSize = normalizedPartitionSize;
-                m_LastCachedMousePosition = currentMousePos;
-            }
-        };
-        private static DragCache  s_DragCache;
+                UnityEditor.VersionControl.Task task = UnityEditor.VersionControl.Provider.Checkout(mat, UnityEditor.VersionControl.CheckoutMode.Both);
-        private static readonly int s_CascadeSliderId = "s_CascadeSliderId".GetHashCode();
-
-        private static SceneView s_RestoreSceneView;
-        private static SceneView.CameraMode s_OldSceneDrawMode;
-        private static bool s_OldSceneLightingMode;
-
-
-        /**
-            *  Static function to handle the GUI and User input related to the cascade slider.
-            *
-            *  @param  normalizedCascadePartition      The array of partition sizes in the range 0.0f - 1.0f; expects ONE entry if cascades = 2, and THREE if cascades=4
-            *                                          The last entry will be automatically determined by summing up the array, and doing 1.0f - sum
-            */
-        public static void HandleCascadeSliderGUI(ref float[] normalizedCascadePartitions)
-        {
-            EditorGUILayout.LabelField("Cascade splits");
-
-            // get the inspector width since we need it while drawing the partition rects.
-            // Only way currently is to reserve the block in the layout using GetRect(), and then immediately drawing the empty box
-            // to match the call to GetRect.
-            // From this point on, we move to non-layout based code.
-            var sliderRect = GUILayoutUtility.GetRect(GUIContent.none
-                    , s_CascadeSliderBG
-                    , GUILayout.Height(kSliderbarTopMargin + kSliderbarHeight + kSliderbarBottomMargin)
-                    , GUILayout.ExpandWidth(true));
-            GUI.Box(sliderRect, GUIContent.none);
-
-            float currentX = sliderRect.x;
-            float cascadeBoxStartY = sliderRect.y + kSliderbarTopMargin;
-            float cascadeSliderWidth = sliderRect.width - (normalizedCascadePartitions.Length * kPartitionHandleWidth);
-            Color origTextColor = GUI.color;
-            Color origBackgroundColor = GUI.backgroundColor;
-            int colorIndex = -1;
-
-            // setup the array locally with the last partition
-            float[] adjustedCascadePartitions = new float[normalizedCascadePartitions.Length + 1];
-            System.Array.Copy(normalizedCascadePartitions, adjustedCascadePartitions, normalizedCascadePartitions.Length);
-            adjustedCascadePartitions[adjustedCascadePartitions.Length - 1] = 1.0f - normalizedCascadePartitions.Sum();
-
-
-            // check for user input on any of the partition handles
-            // this mechanism gets the current event in the queue... make sure that the mouse is over our control before consuming the event
-            int sliderControlId = GUIUtility.GetControlID(s_CascadeSliderId, FocusType.Passive);
-            Event currentEvent = Event.current;
-            int hotPartitionHandleIndex = -1; // the index of any partition handle that we are hovering over or dragging
-
-            // draw each cascade partition
-            for (int i = 0; i < adjustedCascadePartitions.Length; ++i)
-            {
-                float currentPartition = adjustedCascadePartitions[i];
-
-                colorIndex = (colorIndex + 1) % kCascadeColors.Length;
-                GUI.backgroundColor = kCascadeColors[colorIndex];
-                float boxLength = (cascadeSliderWidth * currentPartition);
-
-                // main cascade box
-                Rect partitionRect = new Rect(currentX, cascadeBoxStartY, boxLength, kSliderbarHeight);
-                GUI.Box(partitionRect, GUIContent.none, s_CascadeSliderBG);
-                currentX += boxLength;
-
-                // cascade box percentage text
-                GUI.color = Color.white;
-                Rect textRect = partitionRect;
-                var cascadeText = string.Format("{0}\n{1:F1}%", i, currentPartition * 100.0f);
-
-                GUI.Label(textRect, cascadeText, s_TextCenteredStyle);
-
-                // no need to draw the partition handle for last box
-                if (i == adjustedCascadePartitions.Length - 1)
-                    break;
-
-                // partition handle
-                GUI.backgroundColor = Color.black;
-                Rect handleRect = partitionRect;
-                handleRect.x = currentX;
-                handleRect.width = kPartitionHandleWidth;
-                GUI.Box(handleRect, GUIContent.none, s_CascadeSliderBG);
-                // we want a thin handle visually (since wide black bar looks bad), but a slightly larger
-                // hit area for easier manipulation
-                Rect handleHitRect = handleRect;
-                handleHitRect.xMin -= kPartitionHandleExtraHitAreaWidth;
-                handleHitRect.xMax += kPartitionHandleExtraHitAreaWidth;
-                if (handleHitRect.Contains(currentEvent.mousePosition))
-                    hotPartitionHandleIndex = i;
-
-                // add regions to slider where the cursor changes to Resize-Horizontal
-                if (s_DragCache == null)
+                if (!task.success)
-                    EditorGUIUtility.AddCursorRect(handleHitRect, MouseCursor.ResizeHorizontal, sliderControlId);
+                    Debug.Log(task.text + " " + task.resultCode);
-
-                currentX += kPartitionHandleWidth;
-            }
-
-            GUI.color = origTextColor;
-            GUI.backgroundColor = origBackgroundColor;
-
-            EventType eventType = currentEvent.GetTypeForControl(sliderControlId);
-            switch (eventType)
-            {
-                case EventType.MouseDown:
-                    if (hotPartitionHandleIndex >= 0)
-                    {
-                        s_DragCache = new DragCache(hotPartitionHandleIndex, normalizedCascadePartitions[hotPartitionHandleIndex], currentEvent.mousePosition);
-                        if (GUIUtility.hotControl == 0)
-                            GUIUtility.hotControl = sliderControlId;
-                        currentEvent.Use();
-
-                        // Switch active scene view into shadow cascades visualization mode, once we start
-                        // tweaking cascade splits.
-                        if (s_RestoreSceneView == null)
-                        {
-                            s_RestoreSceneView = SceneView.lastActiveSceneView;
-                            if (s_RestoreSceneView != null)
-                            {
-                                s_OldSceneDrawMode = s_RestoreSceneView.cameraMode;
-                                s_OldSceneLightingMode = s_RestoreSceneView.m_SceneLighting;
-                                s_RestoreSceneView.cameraMode = SceneView.GetBuiltinCameraMode(DrawCameraMode.ShadowCascades);
-                            }
-                        }
-                    }
-                    break;
-
-                case EventType.MouseUp:
-                    // mouseUp event anywhere should release the hotcontrol (if it belongs to us), drags (if any)
-                    if (GUIUtility.hotControl == sliderControlId)
-                    {
-                        GUIUtility.hotControl = 0;
-                        currentEvent.Use();
-                    }
-                    s_DragCache = null;
-
-                    // Restore previous scene view drawing mode once we stop tweaking cascade splits.
-                    if (s_RestoreSceneView != null)
-                    {
-                        s_RestoreSceneView.cameraMode = s_OldSceneDrawMode;
-                        s_RestoreSceneView.m_SceneLighting = s_OldSceneLightingMode;
-                        s_RestoreSceneView = null;
-                    }
-                    break;
-
-                case EventType.MouseDrag:
-                    if (GUIUtility.hotControl != sliderControlId)
-                        break;
-
-                    // convert the mouse movement to normalized cascade width. Make sure that we are safe to apply the delta before using it.
-                    float delta = (currentEvent.mousePosition - s_DragCache.m_LastCachedMousePosition).x / cascadeSliderWidth;
-                    bool isLeftPartitionHappy = ((adjustedCascadePartitions[s_DragCache.m_ActivePartition] + delta) > 0.0f);
-                    bool isRightPartitionHappy = ((adjustedCascadePartitions[s_DragCache.m_ActivePartition + 1] - delta) > 0.0f);
-                    if (isLeftPartitionHappy && isRightPartitionHappy)
-                    {
-                        s_DragCache.m_NormalizedPartitionSize += delta;
-                        normalizedCascadePartitions[s_DragCache.m_ActivePartition] = s_DragCache.m_NormalizedPartitionSize;
-                        if (s_DragCache.m_ActivePartition < normalizedCascadePartitions.Length - 1)
-                            normalizedCascadePartitions[s_DragCache.m_ActivePartition + 1] -= delta;
-                        GUI.changed = true;
-                    }
-                    s_DragCache.m_LastCachedMousePosition = currentEvent.mousePosition;
-                    currentEvent.Use();
-                    break;
             }
         }
     }

com.unity.render-pipelines.core/CoreRP/Editor/Debugging/DebugWindow.cs

             s_TypeMapDirty = false;
         }
 
-        [MenuItem("Window/Render Pipeline/Debug Window", priority = CoreUtils.editMenuPriority2)]
+        [MenuItem("Window/General/Render Pipeline Debug", priority = CoreUtils.editMenuPriority2)]
-            window.titleContent = new GUIContent("Debugging");
+            window.titleContent = new GUIContent("Debug");
         }
 
         void OnEnable()

com.unity.render-pipelines.core/CoreRP/Inputs/InputRegistering.cs

         public static void RegisterInputs(List<InputManagerEntry> entries)
         {
             // Grab reference to input manager
-            var inputManager = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/InputManager.asset")[0];
+            var assets = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/InputManager.asset");
+            // Temporary fix. This happens some time with HDRP init when it's called before asset database is initialized (probably related to package load order).
+            if (assets.Length == 0)
+                return;
+
+            var inputManager = assets[0];
 
             // Wrap in serialized object
             var soInputManager = new SerializedObject(inputManager);

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/D3D11.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)
-#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index), offset)
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2, offset)      textureName.GatherRed(samplerName, coord2, offset)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2, offset)    textureName.GatherGreen(samplerName, coord2, offset)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2, offset)     textureName.GatherBlue(samplerName, coord2, offset)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/GLCore.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName)   TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)         RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName)   RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)         RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                    SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                          textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                 textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)               textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy)           textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)             textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)    textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)  textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                        textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)               textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)             textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy)                textureName.SampleGrad(samplerName, coord2, ddx, ddy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
 #ifdef UNITY_NO_CUBEMAP_ARRAY
 #define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)           ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURECUBE_ARRAY)
 #define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)  ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURECUBE_ARRAY_LOD)
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)                ERROR_ON_UNSUPPORTED_FUNCTION(GATHER_TEXTURECUBE)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)   ERROR_ON_UNSUPPORTED_FUNCTION(GATHER_TEXTURECUBE_ARRAY)
 #endif
+

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/GLES2.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName)           TEXTURECUBE_SHADOW(textureName) // No support to texture array
 
 #define RW_TEXTURE2D(type, textureNam)                  ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture2D)
+#define RW_TEXTURE2D_ARRAY(type, textureName)           ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture2DArray)
 #define RW_TEXTURE3D(type, textureNam)                  ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture3D)
 
 #define SAMPLER(samplerName)
 #define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                     ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURE2D_ARRAY)
 #define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)            ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURE2D_ARRAY_LOD)
 #define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)          ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURE2D_ARRAY_BIAS)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy)    ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURE2D_ARRAY_GRAD)
 #define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                                texCUBE(textureName, coord3)
 // No lod support. Very poor approximation with bias.
 #define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                       SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, lod)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/GLES3.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName)   TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)         ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture2D)
+#define RW_TEXTURE2D_ARRAY(type, textureName)   ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture2DArray)
 #define RW_TEXTURE3D(type, textureName)         ERROR_ON_UNSUPPORTED_FUNCTION(RWTexture3D)
 
 #define SAMPLER(samplerName)                    SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                          textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                 textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)               textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy)           textureName.SampleGrad(samplerName, coord2, ddx, ddy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)             textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)    textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)  textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                        textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)               textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)             textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, ddx, ddy)                textureName.SampleGrad(samplerName, coord2, ddx, ddy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
 
 #ifdef UNITY_NO_CUBEMAP_ARRAY
 #define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)           ERROR_ON_UNSUPPORTED_FUNCTION(SAMPLE_TEXTURECUBE_ARRAY)
 #define GATHER_TEXTURECUBE(textureName, samplerName, coord3)                ERROR_ON_UNSUPPORTED_FUNCTION(GATHER_TEXTURECUBE)
 #define GATHER_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)   ERROR_ON_UNSUPPORTED_FUNCTION(GATHER_TEXTURECUBE_ARRAY)
 #endif
+

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/Metal.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D(textureName, unCoord3)                                   textureName.Load(int4(unCoord3, 0))
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
+#define PLATFORM_SUPPORT_GATHER
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)              textureName.GatherRed(samplerName, coord2)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherGreen(samplerName, coord2)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)             textureName.GatherBlue(samplerName, coord2)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/PSSL.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RW_Texture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RW_Texture2D_Array<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RW_Texture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)
-#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index), offset)
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2, offset)      textureName.GatherRed(samplerName, coord2, offset)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2, offset)    textureName.GatherGreen(samplerName, coord2, offset)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2, offset)     textureName.GatherBlue(samplerName, coord2, offset)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/Switch.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)              textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)
-#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index), offset)
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2, offset)      textureName.GatherRed(samplerName, coord2, offset)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2, offset)    textureName.GatherGreen(samplerName, coord2, offset)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2, offset)     textureName.GatherBlue(samplerName, coord2, offset)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/Vulkan.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)
-#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index), offset)
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2, offset)      textureName.GatherRed(samplerName, coord2, offset)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2, offset)    textureName.GatherGreen(samplerName, coord2, offset)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2, offset)     textureName.GatherBlue(samplerName, coord2, offset)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/API/XBoxOne.hlsl

 #define TEXTURECUBE_ARRAY_SHADOW(textureName) TEXTURECUBE_ARRAY(textureName)
 
 #define RW_TEXTURE2D(type, textureName)       RWTexture2D<type> textureName
+#define RW_TEXTURE2D_ARRAY(type, textureName) RWTexture2DArray<type> textureName
 #define RW_TEXTURE3D(type, textureName)       RWTexture3D<type> textureName
 
 #define SAMPLER(samplerName)                  SamplerState samplerName
 #define TEXTURECUBE_SHADOW_PARAM(textureName, samplerName)       textureName, samplerName
 #define TEXTURECUBE_ARRAY_SHADOW_PARAM(textureName, samplerName) textureName, samplerName
 
-#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                           textureName.Sample(samplerName, coord2)
-#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                  textureName.SampleLevel(samplerName, coord2, lod)
-#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                textureName.SampleBias(samplerName, coord2, bias)
-#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)          textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
-#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)              textureName.Sample(samplerName, float3(coord2, index))
-#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)     textureName.SampleLevel(samplerName, float3(coord2, index), lod)
-#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)   textureName.SampleBias(samplerName, float3(coord2, index), bias)
-#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                         textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                textureName.SampleLevel(samplerName, coord3, lod)
-#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)              textureName.SampleBias(samplerName, coord3, bias)
-#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)            textureName.Sample(samplerName, float4(coord3, index))
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)   textureName.SampleLevel(samplerName, float4(coord3, index), lod)
-#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias) textureName.SampleBias(samplerName, float4(coord3, index), bias)
-#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                           textureName.Sample(samplerName, coord3)
-#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                  textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURE2D(textureName, samplerName, coord2)                               textureName.Sample(samplerName, coord2)
+#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod)                      textureName.SampleLevel(samplerName, coord2, lod)
+#define SAMPLE_TEXTURE2D_BIAS(textureName, samplerName, coord2, bias)                    textureName.SampleBias(samplerName, coord2, bias)
+#define SAMPLE_TEXTURE2D_GRAD(textureName, samplerName, coord2, dpdx, dpdy)              textureName.SampleGrad(samplerName, coord2, dpdx, dpdy)
+#define SAMPLE_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)                  textureName.Sample(samplerName, float3(coord2, index))
+#define SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, coord2, index, lod)         textureName.SampleLevel(samplerName, float3(coord2, index), lod)
+#define SAMPLE_TEXTURE2D_ARRAY_BIAS(textureName, samplerName, coord2, index, bias)       textureName.SampleBias(samplerName, float3(coord2, index), bias)
+#define SAMPLE_TEXTURE2D_ARRAY_GRAD(textureName, samplerName, coord2, index, dpdx, dpdy) textureName.SampleGrad(samplerName, float3(coord2, index), dpdx, dpdy)
+#define SAMPLE_TEXTURECUBE(textureName, samplerName, coord3)                             textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURECUBE_LOD(textureName, samplerName, coord3, lod)                    textureName.SampleLevel(samplerName, coord3, lod)
+#define SAMPLE_TEXTURECUBE_BIAS(textureName, samplerName, coord3, bias)                  textureName.SampleBias(samplerName, coord3, bias)
+#define SAMPLE_TEXTURECUBE_ARRAY(textureName, samplerName, coord3, index)                textureName.Sample(samplerName, float4(coord3, index))
+#define SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)       textureName.SampleLevel(samplerName, float4(coord3, index), lod)
+#define SAMPLE_TEXTURECUBE_ARRAY_BIAS(textureName, samplerName, coord3, index, bias)     textureName.SampleBias(samplerName, float4(coord3, index), bias)
+#define SAMPLE_TEXTURE3D(textureName, samplerName, coord3)                               textureName.Sample(samplerName, coord3)
+#define SAMPLE_TEXTURE3D_LOD(textureName, samplerName, coord3, lod)                      textureName.SampleLevel(samplerName, coord3, lod)
 
 #define SAMPLE_TEXTURE2D_SHADOW(textureName, samplerName, coord3)                    textureName.SampleCmpLevelZero(samplerName, (coord3).xy, (coord3).z)
 #define SAMPLE_TEXTURE2D_ARRAY_SHADOW(textureName, samplerName, coord3, index)       textureName.SampleCmpLevelZero(samplerName, float3((coord3).xy, index), (coord3).z)
 #define LOAD_TEXTURE3D_LOD(textureName, unCoord3, lod)                          textureName.Load(int4(unCoord3, lod))
 
 #define PLATFORM_SUPPORT_GATHER
-#define GATHER_TEXTURE2D(textureName, samplerName, coord2, offset)        textureName.Gather(samplerName, coord2, offset)
-#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index), offset)
+#define GATHER_TEXTURE2D(textureName, samplerName, coord2)                textureName.Gather(samplerName, coord2)
+#define GATHER_TEXTURE2D_ARRAY(textureName, samplerName, coord2, index)   textureName.Gather(samplerName, float3(coord2, index))
-
-#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2, offset)      textureName.GatherRed(samplerName, coord2, offset)
-#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2, offset)    textureName.GatherGreen(samplerName, coord2, offset)
-#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2, offset)     textureName.GatherBlue(samplerName, coord2, offset)
+#define GATHER_RED_TEXTURE2D(textureName, samplerName, coord2)            textureName.GatherRed(samplerName, coord2)
+#define GATHER_GREEN_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherGreen(samplerName, coord2)
+#define GATHER_BLUE_TEXTURE2D(textureName, samplerName, coord2)           textureName.GatherBlue(samplerName, coord2)
+#define GATHER_ALPHA_TEXTURE2D(textureName, samplerName, coord2)          textureName.GatherAlpha(samplerName, coord2)

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/Common.hlsl

     return ComputeTextureLOD(uv);
 }
 
+float ComputeTextureLOD(float3 Px, float3 Py, float3 Pz)
+{
+    float d = max(dot(Px, Px), max(dot(Py, Py), dot(Pz, Pz)));
+    return max(0.0, 0.5 * log2(d));
+}
+
+
 uint GetMipCount(Texture2D tex)
 {
 #if defined(SHADER_API_D3D11) || defined(SHADER_API_D3D12) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_PSSL)

com.unity.render-pipelines.core/CoreRP/Shadow/AdditionalShadowData.cs

     [RequireComponent(typeof(Light))]
     public class AdditionalShadowData : MonoBehaviour
     {
-#pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
-        // We can't rely on Unity for our additional data, we need to version it ourself.
-        [SerializeField]
-        float m_Version = 1.0f;
-#pragma warning restore 414
+        [HideInInspector]
+        public float version = 1.0f;
 
         public const int DefaultShadowResolution = 512;
 

com.unity.render-pipelines.core/CoreRP/Utilities/SceneRenderPipeline.cs

 {
     public RenderPipelineAsset renderPipelineAsset;
 
-#if UNITY_EDITOR
     void OnEnable()
     {
         GraphicsSettings.renderPipelineAsset = renderPipelineAsset;
     {
         GraphicsSettings.renderPipelineAsset = renderPipelineAsset;
     }
-#endif
 }

com.unity.render-pipelines.core/package.json

     "unity": "2018.2",
     "displayName": "Render Pipeline Core Library",
     "dependencies": {
-        "com.unity.postprocessing": "2.0.6-preview"
+        "com.unity.postprocessing": "2.0.7-preview"
     }
 }

com.unity.render-pipelines.high-definition/CHANGELOG.md

 # Changelog
 
 ## [2018.2 undecided]
-- Fix issue with LOD transition and instancing
-- Fix discrepency between object motion vector and camera motion vector
 
 ### Improvements
 - Add stripper of shader variant when building a player. Save shader compile time.
 - Support correctly scene selection for alpha tested object
 - Add per light shadow mask mode control (i.e shadow mask distance and shadow mask). It use the option NonLightmappedOnly
 - Add geometric filtering to Lit shader (allow to reduce specular aliasing)
+- Allow to double click on a render pipeline asset to setup it automatically in GraphicSettings
+- Add shortcut to create DensityVolume and PlanarReflection in hierarchy
+- Add a DefaultHDMirrorMaterial material for PlanarReflection
+- Added a script to be able to upgrade material to newer version of HDRP
+- Removed useless duplication of ForwardError passes.
+- Remove EmissiveIntensity parameter and change EmissiveColor to be HDR (Matching Builtin Unity behavior) - Data need to be updated
+- Changed versioning variable name in HDAdditionalXXXData from m_version to version
+- Create unique name when creating a game object in the rendering menu (i.e Density Volume(2))
+- Re-organize various files and folder location to clean the repository
+- Change Debug windows name and location. Now located at:  Windows -> General -> Render Pipeline Debug
+
+### Bug fixes
+- Fix issue with LOD transition and instancing
+- Fix discrepency between object motion vector and camera motion vector
+- Fix issue with spot and dir light gizmo axis not highlighted correctly
+- Fix potential crash while register debug windows inputs at startup
+- Fix warning when creating Planar reflection
+- Fix specular lighting debug mode (was rendering black)
+- Allow projector decal with null material to allow to configure decal when HDRP is not set
+
 
 ## [2018.1 undecided]
 
 - The VolumetricLightingSystem now uses RTHandles, which allows to save memory by sharing buffers between different cameras (history buffers are not shared), and reduce reallocation frequency by reallocating buffers only if the rendering resolution increases (and suballocating within existing buffers if the rendering resolution decreases)
 - Add a Volumetric Dimmer slider to lights to control the intensity of the scattered volumetric lighting
 - Add UV tiling and offset support for decals.
+- Add mipmapping support for volume 3D mask textures
 
 ### Changed, Removals and deprecations
 - Remove Resource folder of PreIntegratedFGD and add the resource to RenderPipeline Asset

com.unity.render-pipelines.high-definition/HDRP/Camera/HDAdditionalCameraData.cs

     [RequireComponent(typeof(Camera))]
     public class HDAdditionalCameraData : MonoBehaviour, ISerializationCallbackReceiver
     {
+        [HideInInspector]
+        public float version = 1.0f;
+
-
-#pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
-        // We can't rely on Unity for our additional data, we need to version it ourself.
-        [SerializeField]
-        float m_Version = 1.0f;
-#pragma warning restore 414
 
         Camera m_camera;
 

com.unity.render-pipelines.high-definition/HDRP/Camera/HDCamera.cs

 
             postprocessRenderContext = new PostProcessRenderContext();
 
-            m_AdditionalCameraData = cam.GetComponent<HDAdditionalCameraData>();
+            m_AdditionalCameraData = null; // Init in Update
 
             Reset();
         }
         public void Update(FrameSettings currentFrameSettings, PostProcessLayer postProcessLayer, VolumetricLightingSystem vlSys)
         {
+            // store a shortcut on HDAdditionalCameraData (done here and not in the constructor as
+            // we do'nt create HDCamera at every frame and user can change the HDAdditionalData later (Like when they create a new scene).
+            m_AdditionalCameraData = camera.GetComponent<HDAdditionalCameraData>();
+
             m_frameSettings = currentFrameSettings;
 
             // If TAA is enabled projMatrix will hold a jittered projection matrix. The original,

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

                     );
 
             Inspector = CED.Group(
-                    SectionProbeModeSettings,
+                    //SectionProbeModeSettings,
                     CED.space,
                     CED.Action((s, d, o) => EditorGUILayout.LabelField(_.GetContent("Proxy Volume"), EditorStyles.boldLabel)),
                     CED.Action(Drawer_FieldProxyVolumeReference),
             GUI.enabled = false;
             EditorGUILayout.PropertyField(d.refreshMode, _.GetContent("Refresh Mode"));
             EditorGUILayout.PropertyField(d.capturePositionMode, _.GetContent("Capture Position Mode"));
-            d.refreshMode.enumValueIndex = (int)ReflectionProbeRefreshMode.EveryFrame;
-            d.capturePositionMode.enumValueIndex = (int)PlanarReflectionProbe.CapturePositionMode.MirrorCamera;
             GUI.enabled = true;
         }
 
         {
             GUI.enabled = false;
             EditorGUILayout.PropertyField(d.mode, _.GetContent("Type"));
-            d.mode.enumValueIndex = (int)ReflectionProbeMode.Realtime;
             GUI.enabled = true;
         }
 

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/SerializedPlanarReflectionProbe.cs

         {
             serializedObject.Update();
 
+            mode.enumValueIndex = (int)ReflectionProbeMode.Realtime;
+            refreshMode.enumValueIndex = (int)ReflectionProbeRefreshMode.EveryFrame;
+            capturePositionMode.enumValueIndex = (int)PlanarReflectionProbe.CapturePositionMode.MirrorCamera;
+
             var updateProxyVolume = reflectionProxyVolume != null
                 && serializedObject.targetObjects.Length != reflectionProxyVolume.serializedObject.targetObjects.Length;
             if (!updateProxyVolume && reflectionProxyVolume != null)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/LayeredLit/LayeredLitUI.cs

             return layerChanged;
         }
 
-        protected override bool ShouldEmissionBeEnabled(Material mat)
+        protected override bool ShouldEmissionBeEnabled(Material material)
-            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
+            return (material.GetColor(kEmissiveColor) != Color.black) || material.GetTexture(kEmissiveColorMap);
         }
 
         protected override void SetupMaterialKeywordsAndPassInternal(Material material)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Lit/LitUI.cs

 
             // Emissive
             public static string emissiveLabelText = "Emissive Inputs";
-            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
+            public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive Color (linear RGB) in nits unit");
             public static GUIContent albedoAffectEmissiveText = new GUIContent("Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.");
 
             public static GUIContent normalMapSpaceWarning = new GUIContent("Object space normal can't be use with triplanar mapping.");
         protected const string kEmissiveColor = "_EmissiveColor";
         protected MaterialProperty emissiveColorMap = null;
         protected const string kEmissiveColorMap = "_EmissiveColorMap";
-        protected MaterialProperty emissiveIntensity = null;
-        protected const string kEmissiveIntensity = "_EmissiveIntensity";
         protected MaterialProperty albedoAffectEmissive = null;
         protected const string kAlbedoAffectEmissive = "_AlbedoAffectEmissive";
         protected MaterialProperty UVEmissive = null;
             emissiveColorMode = FindProperty(kEmissiveColorMode, props);
             emissiveColor = FindProperty(kEmissiveColor, props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
-            emissiveIntensity = FindProperty(kEmissiveIntensity, props);
             albedoAffectEmissive = FindProperty(kAlbedoAffectEmissive, props);
 
             UVEmissive = FindProperty(kUVEmissive, props);
                 EditorGUI.indentLevel--;
             }
 
-            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
             m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText);
             EditorGUI.indentLevel--;
         }
             m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText);
         }
 
-        protected override bool ShouldEmissionBeEnabled(Material mat)
+        protected override bool ShouldEmissionBeEnabled(Material material)
-            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
+            return (material.GetColor(kEmissiveColor) != Color.black) || material.GetTexture(kEmissiveColorMap);
         }
 
         protected override void SetupMaterialKeywordsAndPassInternal(Material material)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Lit/StandardsToHDLitMaterialUpgrader.cs

                     break;
             }
 
-            // Emission: Convert the HDR emissive color to ldr color + intensity
-            float intensity = Mathf.Max(hdrEmission.r, Mathf.Max(hdrEmission.g, hdrEmission.b));
-
-            if (intensity > 1f)
-            {
-                hdrEmission.r /= intensity;
-                hdrEmission.g /= intensity;
-                hdrEmission.b /= intensity;
-            }
-            else
-                intensity = 1f;
-
-            intensity = Mathf.Pow(intensity, 2.2f); // Gamma to Linear conversion
-
-            dstMaterial.SetFloat("_EmissiveIntensity", intensity);
 
             HDEditorUtils.ResetMaterialKeywords(dstMaterial);
         }

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/StackLit/StackLitUI.cs

         protected const string k_EmissiveColor = "_EmissiveColor";
         protected const string k_EmissiveColorMap = "_EmissiveColorMap";
         protected const string k_EmissiveColorMapUV = "_EmissiveColorMapUV";
-        protected const string k_EmissiveIntensity = "_EmissiveIntensity";
         protected const string k_AlbedoAffectEmissive = "_AlbedoAffectEmissive";
 
         // Coat
         protected const string kStencilWriteMaskMV = "_StencilWriteMaskMV";
 
         protected const string k_GeometricNormalFilteringEnabled = "_GeometricNormalFilteringEnabled";
-        protected const string k_TextureNormalFilteringEnabled = "_TextureNormalFilteringEnabled";        
+        protected const string k_TextureNormalFilteringEnabled = "_TextureNormalFilteringEnabled";
 
         #endregion
 
                 new GroupProperty(this, "_Emissive", "Emissive", new BaseProperty[]
                 {
                     new TextureProperty(this, k_EmissiveColorMap, k_EmissiveColor, "Emissive Color", "Emissive", true, false),
-                    new Property(this, k_EmissiveIntensity, "Emissive Intensity", "Emissive", false),
                     new Property(this, k_AlbedoAffectEmissive, "Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.", false),
                 }),
 
 
         protected override bool ShouldEmissionBeEnabled(Material material)
         {
-            return material.GetFloat(k_EmissiveIntensity) > 0.0f;
+            return (material.GetColor(k_EmissiveColor) != Color.black) || material.GetTexture(k_EmissiveColorMap);
         }
 
         protected override void FindBaseMaterialProperties(MaterialProperty[] props)

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Unlit/UnlitUI.cs

             public static GUIContent colorText = new GUIContent("Color", "Color");
 
             public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive");
-            public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive");
         }
 
         protected MaterialProperty color = null;
         protected const string kEmissiveColor = "_EmissiveColor";
         protected MaterialProperty emissiveColorMap = null;
         protected const string kEmissiveColorMap = "_EmissiveColorMap";
-        protected MaterialProperty emissiveIntensity = null;
-        protected const string kEmissiveIntensity = "_EmissiveIntensity";
 
         override protected void FindMaterialProperties(MaterialProperty[] props)
         {
             emissiveColor = FindProperty(kEmissiveColor, props);
             emissiveColorMap = FindProperty(kEmissiveColorMap, props);
-            emissiveIntensity = FindProperty(kEmissiveIntensity, props);
         }
 
         protected override void MaterialPropertiesGUI(Material material)
 
             m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor);
             m_MaterialEditor.TextureScaleOffsetProperty(emissiveColorMap);
-            m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText);
 
             var surfaceTypeValue = (SurfaceType)surfaceType.floatValue;
             if (surfaceTypeValue == SurfaceType.Transparent)
         {
         }
 
-        protected override bool ShouldEmissionBeEnabled(Material mat)
+        protected override bool ShouldEmissionBeEnabled(Material material)
-            return mat.GetFloat(kEmissiveIntensity) > 0.0f;
+            return (material.GetColor(kEmissiveColor) != Color.black) || material.GetTexture(kEmissiveColorMap);
         }
 
         protected override void SetupMaterialKeywordsAndPassInternal(Material material)

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

     //-------------------------------------------------------------------------------------
 
     HLSLPROGRAM
-    
+
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     //#pragma enable_d3d11_debug_symbols
     //-------------------------------------------------------------------------------------
     // End Defines
     //-------------------------------------------------------------------------------------
-    
+
     #include "HDRP/ShaderVariables.hlsl"
     #ifdef DEBUG_DISPLAY
         #include "HDRP/Debug/DebugDisplay.hlsl"
 
             // TODO: positionSS is SV_Position, graph input expects screenPosition to be 0..1 across the active viewport (?)
             $SurfaceDescriptionInputs.screenPosition:            output.screenPosition = input.positionSS;
-            
+
-            
+
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
             return output;
 
         builtinData.opacity =                   surfaceDescription.Alpha;
         builtinData.bakeDiffuseLighting =       SampleBakedGI(fragInputs.positionWS, bentNormalWS, fragInputs.texCoord1, fragInputs.texCoord2);    // see GetBuiltinData()
-     
+
         // It is safe to call this function here as surfaceData have been filled
         // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
         BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
             builtinData.bakeDiffuseLighting += SampleBakedGI(fragInputs.positionWS, -fragInputs.worldToTangent[2], fragInputs.texCoord1, fragInputs.texCoord2) * bsdfData.transmittance;
         }
 
-        builtinData.emissiveIntensity =         1.0f;
 $SurfaceDescription.Emission:     builtinData.emissiveColor =             surfaceDescription.Emission;
         builtinData.velocity =                  float2(0.0, 0.0);
 #ifdef SHADOWS_SHADOWMASK
     //-------------------------------------------------------------------------------------
 
     ENDHLSL
-}
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRSubShader.cs

             return defines.GetShaderString(2);
         }
 
-        private static bool GenerateShaderPass(PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result)
+        private static bool GenerateShaderPass(PBRMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result, List<string> sourceAssetDependencyPaths)
         {
             var templateLocation = Path.Combine(Path.Combine(Path.Combine(HDEditorUtils.GetHDRenderPipelinePath(), "Editor"), "ShaderGraph"), pass.TemplateName);
             if (!File.Exists(templateLocation))
             }
+
+            if (sourceAssetDependencyPaths != null)
+                sourceAssetDependencyPaths.Add(templateLocation);
 
             // grab all of the active nodes
             var activeNodeList = ListPool<INode>.Get();
             return true;
         }
 
-        public string GetSubshader(IMasterNode iMasterNode, GenerationMode mode)
+        public string GetSubshader(IMasterNode iMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
+            if (sourceAssetDependencyPaths != null)
+            {
+                // HDPBRSubShader.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("c4e8610eb7ce19747bb637c68acc55cd"));
+                // HDSubShaderUtilities.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("713ced4e6eef4a44799a4dd59041484b"));
+            }
+
             var masterNode = iMasterNode as PBRMasterNode;
             var subShader = new ShaderGenerator();
             subShader.AddShaderChunk("SubShader", true);
 
                 if (opaque)
                 {
-                    GenerateShaderPass(masterNode, m_PassGBuffer, mode, materialOptions, subShader);
-                    GenerateShaderPass(masterNode, m_PassGBufferWithPrepass, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassGBuffer, mode, materialOptions, subShader, sourceAssetDependencyPaths);
+                    GenerateShaderPass(masterNode, m_PassGBufferWithPrepass, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                GenerateShaderPass(masterNode, m_PassMETA, mode, materialOptions, subShader);
-                GenerateShaderPass(masterNode, m_PassShadowCaster, mode, materialOptions, subShader);
+                GenerateShaderPass(masterNode, m_PassMETA, mode, materialOptions, subShader, sourceAssetDependencyPaths);
+                GenerateShaderPass(masterNode, m_PassShadowCaster, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassDepthOnly, mode, materialOptions, subShader);
-                    GenerateShaderPass(masterNode, m_PassMotionVectors, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassDepthOnly, mode, materialOptions, subShader, sourceAssetDependencyPaths);
+                    GenerateShaderPass(masterNode, m_PassMotionVectors, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassDistortion, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassDistortion, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassTransparentDepthPrepass, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassTransparentDepthPrepass, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassTransparentBackface, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassTransparentBackface, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                GenerateShaderPass(masterNode, m_PassForward, mode, materialOptions, subShader);
+                GenerateShaderPass(masterNode, m_PassForward, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassTransparentDepthPostpass, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassTransparentDepthPostpass, mode, materialOptions, subShader, sourceAssetDependencyPaths);
                 }
             }
             subShader.Deindent();

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

     //-------------------------------------------------------------------------------------
 
     HLSLPROGRAM
-    
+
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     //#pragma enable_d3d11_debug_symbols
     //-------------------------------------------------------------------------------------
     // End Defines
     //-------------------------------------------------------------------------------------
-    
+
     #include "HDRP/ShaderVariables.hlsl"
     #ifdef DEBUG_DISPLAY
         #include "HDRP/Debug/DebugDisplay.hlsl"
             $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                mul(UNITY_MATRIX_V, float4(input.positionWS, 1.0f));
             $SurfaceDescriptionInputs.ViewSpacePosition:         output.ViewSpacePosition =           posViewSpace.xyz / posViewSpace.w;
             $SurfaceDescriptionInputs.TangentSpacePosition:      output.TangentSpacePosition =        float3(0.0f, 0.0f, 0.0f);
-            
+
-            
+
-            
+
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
             return output;
 
         builtinData.opacity =                   surfaceDescription.Alpha;
         builtinData.bakeDiffuseLighting =       float3(0.0, 0.0, 0.0);
-     
-        builtinData.emissiveIntensity =         1.0f;
+
 $SurfaceDescription.Emission:     builtinData.emissiveColor =             surfaceDescription.Emission;
         builtinData.velocity =                  float2(0.0, 0.0);
         builtinData.shadowMask0 = 0.0;
     //-------------------------------------------------------------------------------------
 
     ENDHLSL
-}
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitSubShader.cs

             return defines.GetShaderString(2);
         }
 
-        private static bool GenerateShaderPass(UnlitMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result)
+        private static bool GenerateShaderPass(UnlitMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result, List<string> sourceAssetDependencyPaths)
-            var templateLocation = ShaderGenerator.GetTemplatePath(pass.TemplateName);
+            var templateLocation = Path.Combine(Path.Combine(Path.Combine(HDEditorUtils.GetHDRenderPipelinePath(), "Editor"), "ShaderGraph"), pass.TemplateName);
+
+            sourceAssetDependencyPaths.Add(templateLocation);
 
             // grab all of the active nodes
             var activeNodeList = ListPool<INode>.Get();
             return true;
         }
 
-        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode)
+        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
+            if (sourceAssetDependencyPaths != null)
+            {
+                // HDUnlitSubShader.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("292c6a3c80161fa4cb49a9d11d35cbe9"));
+                // HDSubShaderUtilities.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("713ced4e6eef4a44799a4dd59041484b"));
+            }
+
             var masterNode = inMasterNode as UnlitMasterNode;
             var subShader = new ShaderGenerator();
             subShader.AddShaderChunk("SubShader", true);
 //                bool transparent = (masterNode.surfaceType != SurfaceType.Opaque);
                 bool distortionActive = false;
 
-                GenerateShaderPass(masterNode, m_PassDepthOnly, mode, materialOptions, subShader);
-                GenerateShaderPass(masterNode, m_PassForward, mode, materialOptions, subShader);
-                GenerateShaderPass(masterNode, m_PassMETA, mode, materialOptions, subShader);
+                GenerateShaderPass(masterNode, m_PassDepthOnly, mode, materialOptions, subShader, sourceAssetDependencyPaths);
+                GenerateShaderPass(masterNode, m_PassForward, mode, materialOptions, subShader, sourceAssetDependencyPaths);
+                GenerateShaderPass(masterNode, m_PassMETA, mode, materialOptions, subShader, sourceAssetDependencyPaths);
-                    GenerateShaderPass(masterNode, m_PassDistortion, mode, materialOptions, subShader);
+                    GenerateShaderPass(masterNode, m_PassDistortion, mode, materialOptions, subShader, sourceAssetDependencyPaths);
                 }
             }
             subShader.Deindent();

com.unity.render-pipelines.high-definition/HDRP/Editor/BuildProcessors/HDRPreprocessShaders.cs.meta

 fileFormatVersion: 2
-guid: 168f8e50628e857489eb62f41d9c911f
+guid: d342206cb3c614b4fa4caee7fb269b93
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

com.unity.render-pipelines.high-definition/HDRP/Editor/BuildProcessors/HDRPreprocessShaders.cs

 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
-    class HDRPVariantStripper : IPreprocessShaders
+    class HDRPreprocessShaders : IPreprocessShaders
     {
         // returns true if the variant should be stripped.
         delegate bool VariantStrippingFunc(Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData);
 
         //ShaderKeyword m_FeatureSSS;
 
-        public HDRPVariantStripper()
+        public HDRPreprocessShaders()
         {
             // TODO: Grab correct configuration/quality asset.
             HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;

com.unity.render-pipelines.high-definition/HDRP/Editor/BuildProcessors/HDRPPreprocessBuild.cs.meta

 fileFormatVersion: 2
-guid: 2ae263b0b434c7e4d9229fde8f6096c5
+guid: 0c6c205acc48bbd4c9cbf70d66fa9ffc
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

com.unity.render-pipelines.high-definition/HDRP/Editor/BuildProcessors/HDRPPreprocessBuild.cs

 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 
-class HDRPCustomBuildProcessor : IPreprocessBuildWithReport
+class HDRPPreprocessBuild : IPreprocessBuildWithReport
 {
     public int callbackOrder { get { return 0; } }
 

com.unity.render-pipelines.high-definition/HDRP/Editor/AssetProcessors/NormalMapAverageLengthTexturePostprocessor.cs.meta

 fileFormatVersion: 2
-guid: c7467d803a5cf8c479b64fbdac53aa41
+guid: 3ceae5765b6bbee4fb4f76acdaae9130
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

com.unity.render-pipelines.high-definition/HDRP/Lighting/GlobalIlluminationUtils.cs

 
             // Note that the HDRI is correctly integrated in the GlobalIllumination system, we don't need to do anything regarding it.
 
+            // The difference is that `l.lightmapBakeType` is the intent, e.g.you want a mixed light with shadowmask. But then the overlap test might detect more than 4 overlapping volumes and force a light to fallback to baked.
+            // In that case `l.bakingOutput.lightmapBakeType` would be baked, instead of mixed, whereas `l.lightmapBakeType` would still be mixed. But this difference is only relevant in editor builds
+#else
+            ld.mode = LightmapperUtils.Extract(l.bakingOutput.lightmapBakeType);
 #endif
 
             ld.shadow = (byte)(l.shadows != LightShadows.None ? 1 : 0);

com.unity.render-pipelines.high-definition/HDRP/Lighting/Light/HDAdditionalLightData.cs

     [RequireComponent(typeof(Light))]
     public class HDAdditionalLightData : MonoBehaviour
     {
- #pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
-        // We can't rely on Unity for our additional data, we need to version it ourself.
-        [SerializeField]
-        float m_Version = 1.0f;
- #pragma warning restore 414
+        [HideInInspector]
+        public float version = 1.0f;
 
         // To be able to have correct default values for our lights and to also control the conversion of intensity from the light editor (so it is compatible with GI)
         // we add intensity (for each type of light we want to manage).

com.unity.render-pipelines.high-definition/HDRP/Lighting/Light/HDLightEditorUtilities.cs

 #if UNITY_EDITOR
     public static class HDLightEditorUtilities
     {
+        // Don't use Handles.Disc as it break the highlight of the gizmo axis, use our own draw disc function instead for gizmo
+        public static void DrawWireDisc(Quaternion q, Vector3 position, Vector3 axis, float radius)
+        {
+            Matrix4x4 rotation = Matrix4x4.TRS(Vector3.zero, q, Vector3.one);
+
+            Gizmos.color = Color.white;
+            float theta = 0.0f;
+            float x = radius * Mathf.Cos(theta);
+            float y = radius * Mathf.Sin(theta);
+            Vector3 pos = rotation * new Vector3(x, y, 0);
+            pos += position;
+            Vector3 newPos = pos;
+            Vector3 lastPos = pos;
+            for (theta = 0.1f; theta < 2.0f * Mathf.PI; theta += 0.1f)
+            {
+                x = radius * Mathf.Cos(theta);
+                y = radius * Mathf.Sin(theta);
+
+                newPos = rotation * new Vector3(x, y, 0);
+                newPos += position;
+                Gizmos.DrawLine(pos, newPos);
+                pos = newPos;
+            }
+            Gizmos.DrawLine(pos, lastPos);
+        }
+
         public static void DrawSpotlightGizmo(Light spotlight, bool selected)
         {
             var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
             var nearDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.shadowNearPlane;
             var nearDiscRadius = spotlight.shadowNearPlane * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
 
-
-            Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius, false, 1);
+            DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius);
             //Draw Lines
 
             Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
                 Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.right, vectorLineUp, spotlight.spotAngle, spotlight.range);
                 Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.up, vectorLineLeft, spotlight.spotAngle, spotlight.range);
                 //Draw Near Plane Disc
-                if (spotlight.shadows != LightShadows.None) Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius, false, 1);
+                if (spotlight.shadows != LightShadows.None)
+                    DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius);
 
                 //Inner Cone
                 var additionalLightData = spotlight.GetComponent<HDAdditionalLightData>();
                 var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * spotlight.range;
                 var innerDiscRadius = spotlight.range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
                 //Draw Range disc
-                Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius, false, 1);
+                DrawWireDisc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius);
             }
         }
 
         public static void DrawDirectionalLightGizmo(Light directionalLight)
         {
             var gizmoSize = 0.2f;
-            Handles.Disc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize, false, 1);
+            DrawWireDisc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize);
             Gizmos.DrawLine(directionalLight.transform.position, directionalLight.transform.position + directionalLight.transform.forward);
             Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * gizmoSize, directionalLight.transform.position + directionalLight.transform.up * gizmoSize + directionalLight.transform.forward);
             Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * -gizmoSize, directionalLight.transform.position + directionalLight.transform.up * -gizmoSize + directionalLight.transform.forward);

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/HDAdditionalReflectionData.cs

     [RequireComponent(typeof(ReflectionProbe), typeof(MeshFilter), typeof(MeshRenderer))]
     public class HDAdditionalReflectionData : MonoBehaviour
     {
-#pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
-        // We can't rely on Unity for our additional data, we need to version it ourself.
-        [SerializeField]
-        float m_Version = 1.0f;
-#pragma warning restore 414
+        [HideInInspector]
+        public float version = 1.0f;
 
         public ShapeType influenceShape;
         [FormerlySerializedAsAttribute("dimmer")]

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/PlanarReflectionProbe.cs

         [SerializeField]
         ReflectionProxyVolumeComponent m_ProxyVolumeReference;
         [SerializeField]
-        InfluenceVolume m_InfluenceVolume;
+        InfluenceVolume m_InfluenceVolume = new InfluenceVolume();
         [SerializeField]
         Vector3 m_CaptureLocalPosition;
         [SerializeField]
         [SerializeField]
         Vector3 m_CaptureMirrorPlaneLocalPosition;
         [SerializeField]
-        Vector3 m_CaptureMirrorPlaneLocalNormal = Vector3.forward;
+        Vector3 m_CaptureMirrorPlaneLocalNormal = Vector3.up;
         [SerializeField]
         bool m_OverrideFieldOfView = false;
         [SerializeField]

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/DensityVolume.cs

             volumeScrollingAmount = textureScrollingSpeed;
         }
 
-        public void Update()
+        public void Update(bool animate, float time)
-                volumeScrollingAmount = volumeScrollingAmount + (textureScrollingSpeed * Time.deltaTime);
+                float animationTime = animate ? time : 0.0f;
+                volumeScrollingAmount = (textureScrollingSpeed * animationTime);
             }
         }
 
         public Action OnTextureUpdated;
 
         //Gather and Update any parameters that may have changed
-        public void PrepareParameters()
+        public void PrepareParameters(bool animate, float time)
         {
             //Texture has been updated notify the manager
             if (previousVolumeMask != parameters.volumeMask)
             }
 
-            parameters.Update();
+            parameters.Update(animate, time);
         }
 
         private void NotifyUpdatedTexure()

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/DensityVolumeManager.cs

             TriggerVolumeAtlasRefresh();
         }
 
-        public DensityVolume[] PrepareDensityVolumeData(CommandBuffer cmd)
+        public DensityVolume[] PrepareDensityVolumeData(CommandBuffer cmd, Camera currentCam, float time)
+            bool animate = CoreUtils.AreAnimatedMaterialsEnabled(currentCam);
-                volume.PrepareParameters();
+                volume.PrepareParameters(animate, time);
             }
 
             if (atlasNeedsRefresh)

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/VolumeTextureAtlas.cs

 
             if (volumeTexture.format != requiredTextureFormat)
             {
-                Debug.LogError(string.Format("VolumeTextureAtlas: Texture format of texture {0} : {1} does not match expected format of {2}", volumeTexture, volumeTexture.format, requiredTextureSize));
+                Debug.LogError(string.Format("VolumeTextureAtlas: Texture format of texture {0} : {1} does not match expected format of {2}", volumeTexture, volumeTexture.format, requiredTextureFormat));
                 return;
             }
 
                 if (textures.Count > 0)
                 {
                     Color[] colorArray = new Color[0];
-                    volumeAtlas = new Texture3D(requiredTextureSize, requiredTextureSize, requiredTextureSize * textures.Count, requiredTextureFormat, false);
+                    volumeAtlas = new Texture3D(requiredTextureSize, requiredTextureSize, requiredTextureSize * textures.Count, requiredTextureFormat, true);
 
                     foreach (Texture3D tex in textures)
                     {

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/VolumeVoxelization.compute

     float4   _VBufferSampleOffset;     // Not used by this shader
     float    _CornetteShanksConstant;  // Not used by this shader
     uint     _NumVisibleDensityVolumes;
-    float2   _VolumeMaskDimensions;    //x = 1/totalTextures , y = 1/textureSize
+    float3   _VolumeMaskDimensions;    //x = 1/totalTextures , y = 1/textureSize, z = textureSize
-float SampleVolumeMask(DensityVolumeData volumeData, float3 voxelCenterUV)
+float SampleVolumeMask(DensityVolumeData volumeData, float3 voxelCenterUV, float3 VxUV, float3 VyUV, float3 VzUV)
 {
     float offset = volumeData.textureIndex * _VolumeMaskDimensions.x;
     float clampBorder = 0.5f * _VolumeMaskDimensions.y;
     voxelCenterUV.z += offset;
 
     voxelCenterUV.z = clamp(voxelCenterUV.z, offset + clampBorder, offset + _VolumeMaskDimensions.x - clampBorder);
-
-    float maskValue = SAMPLE_TEXTURE3D_LOD(_VolumeMaskAtlas, s_linear_clamp_sampler, voxelCenterUV, 0).a;
+    
+    float lod = ComputeTextureLOD(VxUV * _VolumeMaskDimensions.z, VyUV * _VolumeMaskDimensions.z, VzUV * _VolumeMaskDimensions.z);
+    float maskValue = SAMPLE_TEXTURE3D_LOD(_VolumeMaskAtlas, s_linear_clamp_sampler, voxelCenterUV, lod).a;
 
     return maskValue;
 }
         float  halfDZ        = 0.5 * (z1 - z0);
         float  z             = z0 + halfDZ;
         float3 voxelCenterWS = rayOriginWS + z * rayUnDirWS; // Works due to the length of of the dir
+
+        // Dimensions of the voxel as we step along the ray.
+        float3 voxelRightSize = z * voxelAxisRight;
+        float3 voxelUpSize = z * voxelAxisUp;
+        float3 voxelDepthSize = halfDZ * voxelAxisForward;
+
 
         // TODO: define a function ComputeGlobalFogCoefficients(float3 voxelCenterWS),
         // which allows procedural definition of extinction and scattering.
                     //Sample the volumeMask
                     if (_VolumeData[volumeIndex].textureIndex != -1)
                     {
-                        scatteringAndExtinctionMask = SampleVolumeMask(_VolumeData[volumeIndex], voxelCenterUV);
+                        float3 voxelRightSizeBS = mul(voxelRightSize, transpose(obbFrame));
+                        float3 voxelRightSizeUV = (voxelRightSizeBS / obbExtents);
+                        
+                        float3 voxelUpSizeBS = mul(voxelUpSize, transpose(obbFrame));
+                        float3 voxelUpSizeUV = (voxelUpSizeBS / obbExtents);
+                        
+                        float3 voxelDepthSizeBS = mul(voxelDepthSize, transpose(obbFrame));
+                        float3 voxelDepthSizeUV = (voxelDepthSizeBS / obbExtents);
+
+                        scatteringAndExtinctionMask = SampleVolumeMask(_VolumeData[volumeIndex], voxelCenterUV * 0.5 + 0.5, voxelRightSizeUV, voxelUpSizeUV, voxelDepthSizeUV);
                     }
 
                     // There is an overlap. Sample the 3D texture, or load the constant value.

com.unity.render-pipelines.high-definition/HDRP/Lighting/Volumetrics/VolumetricLighting.cs

             cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,                m_LightingBufferHandle);
         }
 
-        public DensityVolumeList PrepareVisibleDensityVolumeList(HDCamera hdCamera, CommandBuffer cmd)
+        public DensityVolumeList PrepareVisibleDensityVolumeList(HDCamera hdCamera, CommandBuffer cmd, float time)
         {
             DensityVolumeList densityVolumes = new DensityVolumeList();
 
                 m_VisibleVolumeData.Clear();
 
                 // Collect all visible finite volume data, and upload it to the GPU.
-                DensityVolume[] volumes = DensityVolumeManager.manager.PrepareDensityVolumeData(cmd);
+                DensityVolume[] volumes = DensityVolumeManager.manager.PrepareDensityVolumeData(cmd, hdCamera.camera, time);
 
                 for (int i = 0; i < Math.Min(volumes.Length, k_MaxVisibleVolumeCount); i++)
                 {
                 Matrix4x4 transform   = HDUtils.ComputePixelCoordToWorldSpaceViewDirectionMatrix(vFoV, resolution, hdCamera.viewMatrix, false);
 
                 Texture3D volumeAtlas = DensityVolumeManager.manager.volumeAtlas.volumeAtlas;
-                Vector2 volumeAtlasDimensions = new Vector2(0.0f, 0.0f);
+                Vector3 volumeAtlasDimensions = new Vector3(0.0f, 0.0f, 0.0f);
+                    volumeAtlasDimensions.z = volumeAtlas.width;
                 }
 
                 cmd.SetComputeTextureParam(m_VolumeVoxelizationCS, kernel, HDShaderIDs._VBufferDensity, m_DensityBufferHandle);

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs

             [SurfaceDataAttributes("Shadow Mask 3")]
             public float shadowMask3;
 
-            [SurfaceDataAttributes("Emissive Color", false, true)]
+            [SurfaceDataAttributes("Emissive Color", false, false)]
-            [SurfaceDataAttributes("Emissive Intensity")]
-            public float emissiveIntensity;
 
             // These is required for motion blur and temporalAA
             [SurfaceDataAttributes("Velocity")]

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs.hlsl

 #define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_2 (104)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_SHADOW_MASK_3 (105)
 #define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR (106)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_INTENSITY (107)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (108)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (109)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (110)
-#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (111)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_VELOCITY (107)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION (108)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DISTORTION_BLUR (109)
+#define DEBUGVIEW_BUILTIN_BUILTINDATA_DEPTH_OFFSET (110)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Builtin+LightTransportData:  static fields
     float shadowMask2;
     float shadowMask3;
     float3 emissiveColor;
-    float emissiveIntensity;
     float2 velocity;
     float2 distortion;
     float distortionBlur;
             break;
         case DEBUGVIEW_BUILTIN_BUILTINDATA_EMISSIVE_COLOR:
             result = builtindata.emissiveColor;
-            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);

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.hlsl

         // TODO: we should not gamma correct, but easier to debug for now without correct high range value
         result = builtinData.bakeDiffuseLighting; needLinearToSRGB = true;
         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_DEPTH_OFFSET:
         result = builtinData.depthOffset.xxx * 10.0; // * 10 assuming 1 unity is 1m
         break;

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLit.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
         // Following set of parameters represent the parameters node inside the MaterialGraph.
         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
 
         [ToggleUI]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         [ToggleUI] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLitData.hlsl

 
     // Normalize
     maxHeight = GetMaxHeight(maskedHeights);
-    maskedHeights = maskedHeights / maxHeight.xxxx;
+    maskedHeights = maskedHeights / max(maxHeight.xxxx, 1e-6);
 
     return maskedHeights.yzwx;
 }

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLitTessellation.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
         // Following set of parameters represent the parameters node inside the MaterialGraph.
         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
 
         [ToggleUI]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         [ToggleUI] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

 
     if (_DebugLightingMode != 0)
     {
-        bool keepSpecular = false;
-
+        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
+        // current cases
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            else
-                keepSpecular = true;
-            else
-                keepSpecular = true;
-
-        if (!keepSpecular)
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
     }
     else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
     {

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
         // Following set of parameters represent the parameters node inside the MaterialGraph.
         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
         // These option below will cause different compilation flag.
         [ToggleUI]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/LitBuiltinData.hlsl

     builtinData.shadowMask3 = 0.0;
 #endif
 
-    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
-    builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code
-
-    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
+    builtinData.emissiveColor = _EmissiveColor * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
 #ifdef _EMISSIVE_COLOR_MAP
 
     // Use layer0 of LayerTexCoord to retrieve emissive color mapping information

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/LitProperties.hlsl

 float _PPDLodThreshold;
 
 float3 _EmissiveColor;
-float _EmissiveIntensity;
 float _AlbedoAffectEmissive;
 
 float _EnableSpecularOcclusion;

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/LitTessellation.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
         // Following set of parameters represent the parameters node inside the MaterialGraph.
         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
         // These option below will cause different compilation flag.
         [ToggleUI]  _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0
 
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.hlsl

 
     if (_DebugLightingMode != 0)
     {
-        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-
+        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
+        // current cases
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            //diffuseLighting = aoFactor.indirectSpecularOcclusion;
+            diffuseLighting = aoFactor.indirectSpecularOcclusion;
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            //    diffuseLighting = lighting.indirect.specularTransmitted;
+             //   diffuseLighting = lighting.indirect.specularTransmitted;
+            break;
+
+        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION:
+            //if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+            //    diffuseLighting = lighting.indirect.specularReflected;
             break;
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
         // Following set of parameters represent the parameters node inside the MaterialGraph.
         // They are use to fill a SurfaceData. With a MaterialGraph this should not exist.
 
         [HideInInspector] _AmbientOcclusionRange("AmbientOcclusion Range", Vector) = (0, 1, 0, 0)
 
         [HideInInspector] _EmissiveColorMapShow("Emissive Color Map Show", Float) = 0.0
-        _EmissiveColor("Emissive Color", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("Emissive Intensity", Float) = 0
         [ToggleUI] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0
 
         [ToggleUI] _EnableSubsurfaceScattering("Enable Subsurface Scattering", Float) = 0.0

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLitData.hlsl

         builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance;
     }
 
-    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
-    builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code
-    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
+    builtinData.emissiveColor = _EmissiveColor * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive);
     builtinData.emissiveColor *= SAMPLE_TEXTURE2D_SCALE_BIAS(_EmissiveColorMap).rgb;
 
     // TODO:

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLitProperties.hlsl

 float4 _EmissiveColorMap_MipInfo;
 float _EmissiveColorMapUV;
 float _EmissiveColorMapUVLocal;
-float _EmissiveIntensity;
 float _AlbedoAffectEmissive;
 
 float _GeometricNormalFilteringEnabled;

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/Unlit.shader

 {
     Properties
     {
+        // Versioning of material to help for upgrading
+        [HideInInspector] _HdrpVersion("_HdrpVersion", Float) = 1
+
-        _EmissiveColor("EmissiveColor", Color) = (1, 1, 1)
+        [HDR] _EmissiveColor("EmissiveColor", Color) = (0, 0, 0)
-        _EmissiveIntensity("EmissiveIntensity", Float) = 0
 
         _DistortionVectorMap("DistortionVectorMap", 2D) = "black" {}
         [ToggleUI] _DistortionEnable("Enable Distortion", Float) = 0.0

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/UnlitData.hlsl

 
     builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);
 
-    // Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity
-    builtinData.emissiveIntensity = _EmissiveIntensity;
-
-    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb * _EmissiveColor * builtinData.emissiveIntensity;
+    builtinData.emissiveColor = SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, TRANSFORM_TEX(input.texCoord0, _EmissiveColorMap)).rgb * _EmissiveColor;
-    builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity;
+    builtinData.emissiveColor = _EmissiveColor;
 #endif
 
     builtinData.velocity = float2(0.0, 0.0);

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/UnlitProperties.hlsl

 float3 _EmissiveColor;
 float4 _EmissiveColorMap_ST;
 
-float _EmissiveIntensity;
-
 float _AlphaCutoff;
 float _DistortionScale;
 float _DistortionVectorScale;

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/DefaultHDDecalMaterial.mat

     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1
-    - _EmissiveIntensity: 0
     - _EnableBlendModeAccurateLighting: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _EnableFogOnTransparent: 1

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/DefaultHDMaterial.mat

     - _Drag: 1
     - _DstBlend: 0
     - _EmissiveColorMode: 1
-    - _EmissiveIntensity: 0
     - _EnableBlendModeAccurateLighting: 1
     - _EnableBlendModePreserveSpecularLighting: 1
     - _EnableFogOnTransparent: 1

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/DepthPyramid.compute

     float2 offset = float2(srcPixelUL) + 0.5;
 
 #if defined(PLATFORM_SUPPORT_GATHER)
-    float4 depths = GATHER_RED_TEXTURE2D(_Source, sampler_PointClamp, offset * _SrcSize.zw, 0.0).wzxy;
+    float4 depths = GATHER_RED_TEXTURE2D(_Source, sampler_PointClamp, offset * _SrcSize.zw).wzxy;
 #else
     float p00 = SAMPLE_TEXTURE2D_LOD(_Source, sampler_PointClamp, (offset) * _SrcSize.zw, 0.0).x;
     float p10 = SAMPLE_TEXTURE2D_LOD(_Source, sampler_PointClamp, (offset + float2(1.0, 0.0)) * _SrcSize.zw, 0.0).x;

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

 --- !u!114 &11400000
 MonoBehaviour:
   m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
+  m_CorrespondingSourceObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 0}
   m_Enabled: 1
   m_EditorClassIdentifier: 
+  version: 1
+    type: 2}
+  defaultMirrorMaterial: {fileID: 2100000, guid: 6b17274157b33bc45b6a40e7d4ff51fe,
     type: 2}
   defaultDecalMaterial: {fileID: 2100000, guid: 500e733574922d04ea961553b1b26a63,
     type: 2}

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/RenderPipelineResources.cs

 {
     public class RenderPipelineResources : ScriptableObject
     {
+        [HideInInspector]
+        public float version = 1.0f;
+
+        public Material defaultMirrorMaterial;
         public Material defaultDecalMaterial;
         public Shader defaultShader;
 

com.unity.render-pipelines.high-definition/package.json

     "unity": "2018.2",
     "displayName": "HD Render Pipeline",
     "dependencies": {
-        "com.unity.postprocessing": "2.0.6-preview",
+        "com.unity.postprocessing": "2.0.7-preview",
         "com.unity.render-pipelines.core": "3.0.0-preview",
         "com.unity.shadergraph": "3.0.0-preview"
     }

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightPBRSubShader.cs

             }
         };
 
-        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode)
+        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
+            if (sourceAssetDependencyPaths != null)
+            {
+                // LightWeightPBRSubShader.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("ca91dbeb78daa054c9bbe15fef76361c"));
+            }
+
+
+            if (sourceAssetDependencyPaths != null)
+            {
+                sourceAssetDependencyPaths.Add(templatePath);
+                sourceAssetDependencyPaths.Add(extraPassesTemplatePath);
+            }
 
             string forwardTemplate = File.ReadAllText(templatePath);
             string extraTemplate = File.ReadAllText(extraPassesTemplatePath);

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/LightWeightUnlitSubShader.cs

 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using UnityEditor;
 using UnityEditor.Experimental.Rendering.LightweightPipeline;
 using UnityEditor.Graphing;
 using UnityEditor.ShaderGraph;
             }
         };
 
-        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode)
+        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
+            if (sourceAssetDependencyPaths != null)
+            {
+                // LightWeightUnlitSubShader.cs
+                sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("3ef30c5c1d5fc412f88511ef5818b654"));
+            }
+
+            if (sourceAssetDependencyPaths != null)
+            {
+                sourceAssetDependencyPaths.Add(templatePath);
+                sourceAssetDependencyPaths.Add(extraPassesTemplatePath);
+            }
+
             string forwardTemplate = File.ReadAllText(templatePath);
             string extraTemplate = File.ReadAllText(extraPassesTemplatePath);
 
 
         static string GetTemplatePath(string templateName)
         {
-            string relativeTemplatePath = Path.Combine("LWRP", Path.Combine("Editor", Path.Combine("ShaderGraph", templateName)));
-            foreach (var path in LightweightIncludePaths.GetPaths())
-            {
-                var templatePath = Path.Combine(path, relativeTemplatePath);
-                if (File.Exists(templatePath))
-                    return templatePath;
-            }
-            throw new FileNotFoundException(string.Format(@"Cannot find a template with name ""{0}"".", templateName));
+            var pathSegments = new[] { "Packages", "com.unity.render-pipelines.lightweight", "LWRP", "Editor", "ShaderGraph", templateName };
+            var path = pathSegments.Aggregate("", Path.Combine);
+            if (!File.Exists(path))
+                throw new FileNotFoundException(string.Format(@"Cannot find a template with name ""{0}"".", templateName));
+            return path;
         }
 
         static string GetShaderPassFromTemplate(string template, UnlitMasterNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions)

com.unity.render-pipelines.lightweight/package.json

     "unity": "2018.2",
     "displayName": "Lightweight Render Pipeline",
     "dependencies": {
-        "com.unity.postprocessing": "2.0.6-preview",
+        "com.unity.postprocessing": "2.0.7-preview",
         "com.unity.render-pipelines.core": "3.0.0-preview",
         "com.unity.shadergraph": "3.0.0-preview"
     }

com.unity.shadergraph/CHANGELOG.md

 
 This change expands Unity's support for Texture types via two new property types and four new nodes. These allow you to define and sample Texture 3D and Texture 2D Array type assets in Shader Graph.
 
+### Texture 2D LOD node
+
+![](.data/texture_2d_lod_node.png)
+
+This adds a new node for LOD functionality on a Texture 2D Sample. Sample Texture 2D LOD uses the exact same input and output slots as Sample Texture 2D, but also includes an input for level of detail adjustments via a Vector1 slot. 
+
 ### Show generated code
 
 ![](.data/show_generated_code.gif)
 - When you edit sub graph paths, the search window no longer yields a null reference exception.
 - The blackboard is now within view when deserialized.
 - Your system locale can no longer cause incorrect commands due to full stops being converted to commas.
+- Deserialization of subgraphs now works correctly.
+- Sub graphs are now suffixed with (sub), so you can tell them apart from other nodes.

com.unity.shadergraph/Editor/Data/Graphs/IShaderGraph.cs

 {
     public interface IShaderGraph
     {
-        string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures);
+        string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths = null);
         void LoadedFromDisk();
     }
 }

com.unity.shadergraph/Editor/Data/Graphs/MaterialGraph.cs

             get { return GetNodes<INode>().OfType<IMasterNode>().FirstOrDefault(); }
         }
 
-        public string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures)
+        public string GetShader(string name, GenerationMode mode, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths = null)
-            return masterNode.GetShader(mode, name, out configuredTextures);
+            return masterNode.GetShader(mode, name, out configuredTextures, sourceAssetDependencyPaths);
         }
 
         public void LoadedFromDisk()

com.unity.shadergraph/Editor/Data/Graphs/PreviewProperty.cs

         }
 
         [StructLayout(LayoutKind.Explicit)]
-        struct Data
+        struct ClassData
-            [FieldOffset(0)]
-            public Color colorValue;
             [FieldOffset(0)]
             public Texture textureValue;
             [FieldOffset(0)]
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        struct StructData
+        {
+
+            [FieldOffset(0)]
+            public Color colorValue;
             [FieldOffset(0)]
             public Vector4 vector4Value;
             [FieldOffset(0)]
         }
 
-        Data m_Data;
+        ClassData m_ClassData;
+        StructData m_StructData;
 
         public Color colorValue
         {
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Color, propType));
-                return m_Data.colorValue;
+                return m_StructData.colorValue;
-                m_Data.colorValue = value;
+                m_StructData.colorValue = value;
             }
         }
 
             {
                 if (propType != PropertyType.Texture2D && propType != PropertyType.Texture2DArray && propType != PropertyType.Texture3D)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Texture2D, propType));
-                return m_Data.textureValue;
+                return m_ClassData.textureValue;
-                m_Data.textureValue = value;
+                m_ClassData.textureValue = value;
             }
         }
 
             {
                 if (propType != PropertyType.Cubemap)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Cubemap, propType));
-                return m_Data.cubemapValue;
+                return m_ClassData.cubemapValue;
-                m_Data.cubemapValue = value;
+                m_ClassData.cubemapValue = value;
             }
         }
 
             {
                 if (propType != PropertyType.Gradient)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Gradient, propType));
-                return m_Data.gradientValue;
+                return m_ClassData.gradientValue;
-                m_Data.gradientValue = value;
+                m_ClassData.gradientValue = value;
             }
         }
 
             {
                 if (propType != PropertyType.Vector2 && propType != PropertyType.Vector3 && propType != PropertyType.Vector4)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Vector4, propType));
-                return m_Data.vector4Value;
+                return m_StructData.vector4Value;
             }
             set
             {
-                m_Data.vector4Value = value;
+                m_StructData.vector4Value = value;
             }
         }
 
             {
                 if (propType != PropertyType.Vector1)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Vector1, propType));
-                return m_Data.floatValue;
+                return m_StructData.floatValue;
-                m_Data.floatValue = value;
+                m_StructData.floatValue = value;
             }
         }
 
             {
                 if (propType != PropertyType.Boolean)
                     throw new ArgumentException(string.Format(k_GetErrorMessage, PropertyType.Boolean, propType));
-                return m_Data.booleanValue;
+                return m_StructData.booleanValue;
-                m_Data.booleanValue = value;
+                m_StructData.booleanValue = value;
             }
         }
 
         public void SetMaterialPropertyBlockValue(MaterialPropertyBlock block)
         {
             if ((propType == PropertyType.Texture2D || propType == PropertyType.Texture2DArray || propType == PropertyType.Texture3D) && textureValue != null)
-                block.SetTexture(name, m_Data.textureValue);
+                block.SetTexture(name, m_ClassData.textureValue);
-                block.SetTexture(name, m_Data.cubemapValue);
+                block.SetTexture(name, m_ClassData.cubemapValue);
-                block.SetColor(name, m_Data.colorValue);
+                block.SetColor(name, m_StructData.colorValue);
-                block.SetVector(name, m_Data.vector4Value);
+                block.SetVector(name, m_StructData.vector4Value);
-                block.SetFloat(name, m_Data.floatValue);
+                block.SetFloat(name, m_StructData.floatValue);
-                block.SetFloat(name, m_Data.booleanValue ? 1 : 0);
+                block.SetFloat(name, m_StructData.booleanValue ? 1 : 0);
         }
     }
 

com.unity.shadergraph/Editor/Data/MasterNodes/ISubShader.cs

 using System;
-using UnityEditor.Graphing;
-using UnityEngine.Experimental.UIElements;
+using System.Collections.Generic;
-        string GetSubshader(IMasterNode masterNode, GenerationMode mode);
+        string GetSubshader(IMasterNode masterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null);
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/AbstractMaterialNode.cs

             var slot = FindSlot<MaterialSlot>(slotId);
             return slot != null && owner.GetEdges(slot.slotReference).Any();
         }
+
+        public virtual void GetSourceAssetDependencies(List<string> paths)
+        {}
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/IMasterNode.cs

 {
     public interface IMasterNode : INode
     {
-        string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures);
+        string GetShader(GenerationMode mode, string name, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths = null);
         bool IsPipelineCompatible(IRenderPipeline renderPipeline);
     }
 }

com.unity.shadergraph/Editor/Data/Nodes/MasterNode.cs

             Dirty(ModificationScope.Graph);
         }
 
-        public string GetShader(GenerationMode mode, string outputName, out List<PropertyCollector.TextureInfo> configuredTextures)
+        public string GetShader(GenerationMode mode, string outputName, out List<PropertyCollector.TextureInfo> configuredTextures, List<string> sourceAssetDependencyPaths = null)
         {
             var activeNodeList = ListPool<INode>.Get();
             NodeUtils.DepthFirstCollectNodesFromNode(activeNodeList, this);
                 }
 
                 foreach (var subShader in m_SubShaders)
-                    finalShader.AppendLines(subShader.GetSubshader(this, mode));
+                    finalShader.AppendLines(subShader.GetSubshader(this, mode, sourceAssetDependencyPaths));
 
                 finalShader.AppendLine(@"FallBack ""Hidden/InternalErrorShader""");
             }

com.unity.shadergraph/Editor/Data/Nodes/Utility/SubGraphNode.cs

         [SerializeField]
         private string m_SerializedSubGraph = string.Empty;
 
+        [NonSerialized]
+        MaterialSubGraphAsset m_SubGraph;
+
         [Serializable]
         private class SubGraphHelper
         {
             }
         }
 
-#if UNITY_EDITOR
-        [ObjectControl("")]
         public MaterialSubGraphAsset subGraphAsset
         {
             get
 
-                var helper = new SubGraphHelper();
-                EditorJsonUtility.FromJsonOverwrite(m_SerializedSubGraph, helper);
-                return helper.subGraph;
+                if (m_SubGraph == null)
+                {
+                    var helper = new SubGraphHelper();
+                    EditorJsonUtility.FromJsonOverwrite(m_SerializedSubGraph, helper);
+                    m_SubGraph = helper.subGraph;
+                }
+
+                return m_SubGraph;
             }
             set
             {
                 var helper = new SubGraphHelper();
                 helper.subGraph = value;
                 m_SerializedSubGraph = EditorJsonUtility.ToJson(helper, true);
+                m_SubGraph = null;
-#else
-        public MaterialSubGraphAsset subGraphAsset {get; set; }
-#endif
 
         public INode outputNode
         {
             var validNames = new List<int>();
             if (referencedGraph == null)
             {
-                RemoveSlotsNameNotMatching(validNames);
+                RemoveSlotsNameNotMatching(validNames, true);
                 return;
             }
 
                 return false;
 
             return referencedGraph.activeNodes.OfType<IMayRequireVertexColor>().Any(x => x.RequiresVertexColor(stageCapability));
+        }
+
+        public override void GetSourceAssetDependencies(List<string> paths)
+        {
+            base.GetSourceAssetDependencies(paths);
+            if (subGraphAsset != null)
+            {
+                var assetPath = AssetDatabase.GetAssetPath(subGraphAsset);
+                paths.Add(assetPath);
+                foreach (var dependencyPath in AssetDatabase.GetDependencies(assetPath))
+                    paths.Add(dependencyPath);
+            }
         }
     }
 }

com.unity.shadergraph/Editor/Drawing/MaterialGraphEditWindow.cs

             graphEditorView = null;
         }
 
-        void UpdateDependantGraphs()
-        {
-            string[] lookFor = new string[] {"Assets"};
-            var guids = AssetDatabase.FindAssets("t:shader", lookFor);
-            foreach (string guid in guids)
-            {
-                if (AssetDatabase.GUIDToAssetPath(guid).ToLower().EndsWith(ShaderGraphImporter.ShaderGraphExtension))
-                {
-                    var path = AssetDatabase.GUIDToAssetPath(guid);
-
-                    var textGraph = File.ReadAllText(path, Encoding.UTF8);
-                    var graph = JsonUtility.FromJson<MaterialGraph>(textGraph);
-                    graph.LoadedFromDisk();
-
-                    foreach (SubGraphNode graphNode in graph.GetNodes<SubGraphNode>())
-                    {
-                        var subpath = AssetDatabase.GetAssetPath(graphNode.subGraphAsset);
-                        var subguid = AssetDatabase.AssetPathToGUID(subpath);
-                        if (subguid == selectedGuid)
-                        {
-                            UpdateShaderGraphOnDisk(path, graph);
-                        }
-                    }
-                }
-            }
-        }
-
         public void PingAsset()
         {
             if (selectedGuid != null)
 
             File.WriteAllText(path, EditorJsonUtility.ToJson(graph, true));
             AssetDatabase.ImportAsset(path);
-
-            UpdateDependantGraphs();
         }
 
         void UpdateShaderGraphOnDisk(string path)

com.unity.shadergraph/Editor/Drawing/Views/GraphEditorView.cs

         MaterialGraphView m_GraphView;
         MasterPreviewView m_MasterPreviewView;
 
-        private EditorWindow m_EditorWindow;
-
         AbstractMaterialGraph m_Graph;
         PreviewManager m_PreviewManager;
         SearchWindowProvider m_SearchWindowProvider;
         {
             m_Graph = graph;
             AddStyleSheetPath("Styles/GraphEditorView");
-            m_EditorWindow = editorWindow;
             previewManager = new PreviewManager(graph);
 
             string serializedWindowLayout = EditorUserSettings.GetConfigValue(k_FloatingWindowsLayoutKey);

com.unity.shadergraph/Editor/Drawing/Views/MaterialNodeView.cs

         {
             var subGraphNode = node as SubGraphNode;
             if (subGraphNode != null && subGraphNode.subGraphAsset != null)
-                title = subGraphNode.subGraphAsset.name;
+                title = subGraphNode.subGraphAsset.name + " (sub)";
             else
                 title = node.name;
         }

com.unity.shadergraph/Editor/Importers/ShaderGraphImporter.cs

 using UnityEditor.Experimental.AssetImporters;
 using UnityEditor.ShaderGraph.Drawing;
 
-[ScriptedImporter(14, ShaderGraphImporter.ShaderGraphExtension)]
+[ScriptedImporter(15, ShaderGraphExtension)]
 public class ShaderGraphImporter : ScriptedImporter
 {
     public const string ShaderGraphExtension = "shadergraph";
             ShaderUtil.ClearShaderErrors(oldShader);
 
         List<PropertyCollector.TextureInfo> configuredTextures;
-        var text = GetShaderText(ctx.assetPath, out configuredTextures);
-        var shader = ShaderUtil.CreateShaderAsset(text);
-
-        EditorMaterialUtility.SetShaderDefaults(
-            shader,
-            configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
-            configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
-        EditorMaterialUtility.SetShaderNonModifiableDefaults(
-            shader,
-            configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
-            configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
-
-        ctx.AddObjectToAsset("MainAsset", shader);
-        ctx.SetMainObject(shader);
-    }
-
-    internal static string GetShaderText(string path, out List<PropertyCollector.TextureInfo> configuredTextures)
-    {
+        string path = ctx.assetPath;
+        var sourceAssetDependencyPaths = new List<string>();
         var shaderName = Path.GetFileNameWithoutExtension(path);
         try
         {
 
             if (!string.IsNullOrEmpty(graph.path))
                 shaderName = graph.path + "/" + shaderName;
-            shaderString = graph.GetShader(shaderName, GenerationMode.ForReals, out configuredTextures);
+            shaderString = graph.GetShader(shaderName, GenerationMode.ForReals, out configuredTextures, sourceAssetDependencyPaths);
+
+            foreach (var node in graph.GetNodes<AbstractMaterialNode>())
+                node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
         }
         catch (Exception)
         {
-        return shaderString ?? k_ErrorShader.Replace("Hidden/GraphErrorShader2", shaderName);
+
+        var text = shaderString ?? k_ErrorShader.Replace("Hidden/GraphErrorShader2", shaderName);
+        var shader = ShaderUtil.CreateShaderAsset(text);
+
+        EditorMaterialUtility.SetShaderDefaults(
+            shader,
+            configuredTextures.Where(x => x.modifiable).Select(x => x.name).ToArray(),
+            configuredTextures.Where(x => x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
+        EditorMaterialUtility.SetShaderNonModifiableDefaults(
+            shader,
+            configuredTextures.Where(x => !x.modifiable).Select(x => x.name).ToArray(),
+            configuredTextures.Where(x => !x.modifiable).Select(x => EditorUtility.InstanceIDToObject(x.textureId) as Texture).ToArray());
+
+        ctx.AddObjectToAsset("MainAsset", shader);
+        ctx.SetMainObject(shader);
+
+        foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
+            ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
     }
 }
 

com.unity.shadergraph/Editor/Importers/ShaderSubGraphImporter.cs

+using System.Collections.Generic;
+using System.Linq;
-[ScriptedImporter(1, "ShaderSubGraph")]
+[ScriptedImporter(2, "ShaderSubGraph")]
 public class ShaderSubGraphImporter : ScriptedImporter
 {
     public override void OnImportAsset(AssetImportContext ctx)
         if (graph == null)
             return;
 
+        var sourceAssetDependencyPaths = new List<string>();
+        foreach (var node in graph.GetNodes<AbstractMaterialNode>())
+            node.GetSourceAssetDependencies(sourceAssetDependencyPaths);
+
+
+
+        foreach (var sourceAssetDependencyPath in sourceAssetDependencyPaths.Distinct())
+            ctx.DependsOnSourceAsset(sourceAssetDependencyPath);
     }
 }

com.unity.shadergraph/Editor/Resources/Styles/Controls/EnumControlView.uss

 }
 
 EnumControlView > Label {
-    width: 100;
+    width: 94;
     padding-left: 0;
     padding-right: 0;
     padding-top: 0;

com.unity.shadergraph/Editor/Resources/Styles/MaterialNodeView.uss

 }
 
 MaterialNodeView #previewFiller > #expand > #icon {
-    align-self: center;
     background-image : resource("GraphView/Nodes/PreviewExpand.png");
     width: 16;
     height: 16;
 
 #settings-button {
     width: 16;
-    align-self: center;
     justify-content: center;
     padding-left: 8;
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/HDAssetFactory.cs

                 string CorePath = HDEditorUtils.GetCorePath();
 
                 newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");
+                newAsset.defaultMirrorMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMirrorMaterial.mat");
+
                 newAsset.defaultDecalMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDDecalMaterial.mat");
                 newAsset.defaultShader = Load<Shader>(HDRenderPipelinePath + "Material/Lit/Lit.shader");
 
                 newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
 
                 // Material
-                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD.shader");
+                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD.shader");
 
                 // Utilities / Core
                 newAsset.encodeBC6HCS = Load<ComputeShader>(CorePath + "CoreResources/EncodeBC6H.compute");

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipelineAsset.cs

     // The HDRenderPipeline assumes linear lighting. Doesn't work with gamma.
     public class HDRenderPipelineAsset : RenderPipelineAsset, ISerializationCallbackReceiver
     {
+        [HideInInspector]
+        public float version = 1.0f;
+
         HDRenderPipelineAsset()
         {
         }
         public Material GetDefaultDecalMaterial()
         {
             return m_RenderPipelineResources.defaultDecalMaterial;
+        }
+
+        // Note: This function is HD specific
+        public Material GetDefaultMirrorMaterial()
+        {
+            return m_RenderPipelineResources.defaultMirrorMaterial;
         }
 
         public override Material GetDefaultParticleMaterial()

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

         RTHandleSystem.RTHandle m_DistortionBuffer;
 
         // The pass "SRPDefaultUnlit" is a fall back to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
-        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
-        ShaderPassName[] m_ForwardOnlyPassNames = { new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
+        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { HDShaderPassNames.s_ForwardOnlyName, HDShaderPassNames.s_ForwardName, HDShaderPassNames.s_SRPDefaultUnlitName };
+        ShaderPassName[] m_ForwardOnlyPassNames = { HDShaderPassNames.s_ForwardOnlyName, HDShaderPassNames.s_SRPDefaultUnlitName };
 
         ShaderPassName[] m_AllTransparentPassNames = {  HDShaderPassNames.s_TransparentBackfaceName,
                                                         HDShaderPassNames.s_ForwardOnlyName,
                     m_MaterialList.ForEach(material => material.Bind());
 
                     // Frustum cull density volumes on the CPU. Can be performed as soon as the camera is set up.
-                    DensityVolumeList densityVolumes = m_VolumetricLightingSystem.PrepareVisibleDensityVolumeList(hdCamera, cmd);
+                    DensityVolumeList densityVolumes = m_VolumetricLightingSystem.PrepareVisibleDensityVolumeList(hdCamera, cmd, m_Time);
 
                     // Note: Legacy Unity behave like this for ShadowMask
                     // When you select ShadowMask in Lighting panel it recompile shaders on the fly with the SHADOW_MASK keyword.
                         StartStereoRendering(renderContext, hdCamera);
 
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
 
                         // SSS pass here handle both SSS material from deferred and forward
                         m_SSSBufferManager.SubsurfaceScatteringPass(hdCamera, cmd, diffusionProfileSettings,
 
                         // Render pre refraction objects
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
+
+                        // Render All forward error
+                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd);
 
                         // Fill depth buffer to reduce artifact for transparent object during postprocess
                         RenderTransparentDepthPostpass(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer);
                     }
 
-                    m_ForwardAndForwardOnlyPassNames[0] = m_ForwardOnlyPassNames[0] =
-                            HDShaderPassNames.s_ForwardOnlyName;
-                    m_ForwardAndForwardOnlyPassNames[1] = HDShaderPassNames.s_ForwardName;
-
                     var passNames = hdCamera.frameSettings.enableForwardRenderingOnly
                         ? m_ForwardAndForwardOnlyPassNames
                         : m_ForwardOnlyPassNames;
 
         // This is use to Display legacy shader with an error shader
         [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
-        void RenderForwardError(CullResults cullResults, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, ForwardPass pass)
+        void RenderForwardError(CullResults cullResults, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-
-                if (pass == ForwardPass.Opaque)
-                {
-                    RenderOpaqueRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, null, null, m_ErrorMaterial);
-                }
-                else
-                {
-                    RenderTransparentRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent, null, m_ErrorMaterial);
-                }
+                RenderOpaqueRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, RenderQueueRange.all, null, m_ErrorMaterial);
             }
         }
 

TestProjects/LWGraphicsTest/Packages/manifest.json

 {
     "dependencies": {
-        "com.unity.postprocessing": "file:../../../../com.unity.postprocessing", 
-        "com.unity.render-pipelines.core": "file:../../../../com.unity.render-pipelines.core",
-        "com.unity.shadergraph": "file:../../../../com.unity.shadergraph",
-        "com.unity.render-pipelines.lightweight": "file:../../../../com.unity.render-pipelines.lightweight"
+        "com.unity.postprocessing": "file:../../../com.unity.postprocessing", 
+        "com.unity.render-pipelines.core": "file:../../../com.unity.render-pipelines.core",
+        "com.unity.shadergraph": "file:../../../com.unity.shadergraph",
+        "com.unity.render-pipelines.lightweight": "file:../../../com.unity.render-pipelines.lightweight"
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Decal/DecalMenuItems.cs

 {
     public class DecalMenuItems
     {
-        [MenuItem("GameObject/Rendering/DecalProjector", priority = CoreUtils.gameObjectMenuPriority)]
+        [MenuItem("GameObject/Rendering/Decal Projector", priority = CoreUtils.gameObjectMenuPriority)]
-            // Create a custom game object
-            GameObject go = new GameObject("DecalProjector");
+            var parent = menuCommand.context as GameObject;
+            var go = CoreEditorUtils.CreateGameObject(parent, "Decal Projector");
             go.AddComponent<DecalProjectorComponent>();
             // Ensure it gets re-parented if this was a context click (otherwise does nothing)
             GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/DecalProjectorComponent.cs

             }
 
             if (m_Handle != null)
+            { 
+                m_Handle = null;
+            }
+
             Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
             m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Material);
         }
-            DecalSystem.instance.RemoveDecal(m_Handle);
-            m_Handle = null;
+            if (m_Handle != null)
+            { 
+                DecalSystem.instance.RemoveDecal(m_Handle);
+                m_Handle = null;
+            }
         }
 
         // Declare the method signature of the delegate to call.

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/DecalSystem.cs

     public class DecalSystem
     {
         public const int kInvalidIndex = -1;
+        public const int kNullMaterialIndex = int.MaxValue;
         public class DecalHandle
         {
             public DecalHandle(int index, int materialID)
         {
             public void InitializeMaterialValues()
             {
+                if (m_Material == null)
+                    return;
                 m_Diffuse.m_Texture = m_Material.GetTexture("_BaseColorMap");
                 m_Normal.m_Texture = m_Material.GetTexture("_NormalMap");
                 m_Mask.m_Texture = m_Material.GetTexture("_MaskMap");
             public DecalSet(Material material)
             {
-                m_Material = material;
+                m_Material = material;              
                 InitializeMaterialValues();
             }
 
 
             public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle)
             {
+                if (m_Material == null)
+                    return;
                 int index = handle.m_Index;
                 m_CachedDecalToWorld[index] = transform.localToWorldMatrix;
 
 
             public void BeginCull()
             {
+                if (m_Material == null)
+                    return;
                 if (m_CullingGroup != null)
                 {
                     Debug.LogError("Begin/EndCull() called out of sequence for decal projectors.");
 
             public int QueryCullResults()
             {
+                if (m_Material == null)
+                    return 0;
                 m_NumResults = m_CullingGroup.QueryIndices(true, m_ResultIndices, 0);
                 return m_NumResults;
             }
 
             public void CreateDrawData()
             {
+                if (m_Material == null)
+                    return;
                 if (m_NumResults == 0)
                     return;
                 // only add if anything in this decal set is visible.
 
             public void EndCull()
             {
+                if (m_Material == null)
+                    return;
                 if (m_CullingGroup == null)
                 {
                     Debug.LogError("Begin/EndCull() called out of sequence for decal projectors.");
 
             public void RenderIntoDBuffer(CommandBuffer cmd)
             {
+                if (m_Material == null)
+                    return;
                 if (m_NumResults == 0)
                     return;
                 int batchIndex = 0;
         public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, Material material)
         {
             DecalSet decalSet = null;
-            int key = material.GetInstanceID();
+            int key = material != null ? material.GetInstanceID() : kNullMaterialIndex;
             if (!m_DecalSets.TryGetValue(key, out decalSet))
             {
                 decalSet = new DecalSet(material);

com.unity.render-pipelines.core/CoreRP/Editor/Shadow.meta

+fileFormatVersion: 2
+guid: 61ef33a54404cb747aad57d04e535154
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: