Merge pull request #1702 from Unity-Technologies/HDRP/staging

Merge Hdrp/staging

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

 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [unreleased]
+
+
+### Fixed
+- Fixed an issue with PreIntegratedFGD texture being sometimes destroyed and not regenerated causing rendering to break
+- PostProcess input buffers are not copied anymore on PC if the viewport size matches the final render target size
+- Fixed an issue when manipulating a lot of decals, it was displaying a lot of errors in the inspector
+- Fixed capture material with reflection probe
+
+### Added
+- Added support for RendererPriority on Renderer. This allow to control order of transparent rendering manually. HDRP have now two stage of sorting for transparent in addition to bact to front. Material have a priority then Renderer have a priority.
+- Add Coupling of (HD)Camera and HDAdditionalCameraData for reset and remove in inspector contextual menu of Camera
+- Add macro to forbid unity_ObjectToWorld/unity_WorldToObject to be use as it doesn't handle camera relative rendering
 
 ## [3.0.0-preview]
 

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

 using UnityEngine.Serialization;
+using UnityEngine.Assertions;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         public Color backgroundColorHDR = new Color(0.025f, 0.07f, 0.19f, 0.0f);
         public bool clearDepth = true;
 
-        public RenderingPath renderingPath;
+        public RenderingPath renderingPath = RenderingPath.Default;
         [Tooltip("Layer Mask used for the volume interpolation for this camera.")]
         public LayerMask volumeLayerMask = -1;
 
         bool m_IsDebugRegistered = false;
         string m_CameraRegisterName;
 
-        // When we are a preview, there is no way inside Unity to make a disctinctoin between camera preview and material preview.
+        // When we are a preview, there is no way inside Unity to make a distinction between camera preview and material preview.
+
+        // This is use to copy data into camera for the Reset() workflow in camera editor
+        public void CopyTo(HDAdditionalCameraData data)
+        {
+            data.clearColorMode = clearColorMode;
+            data.backgroundColorHDR = backgroundColorHDR;
+            data.clearDepth = clearDepth;
+            data.renderingPath = renderingPath;
+            data.volumeLayerMask = volumeLayerMask;
+            data.aperture = aperture;
+            data.shutterSpeed = shutterSpeed;
+            data.iso = iso;
+
+            m_FrameSettings.CopyTo(data.m_FrameSettings);
+            m_FrameSettingsRuntime.CopyTo(data.m_FrameSettingsRuntime);
+            data.m_frameSettingsIsDirty = true; // Let's be sure it is dirty for update
+
+            // We must not copy the following
+            //data.m_IsDebugRegistered = m_IsDebugRegistered;
+            //data.m_CameraRegisterName = m_CameraRegisterName;
+            //data.isEditorCameraPreview = isEditorCameraPreview;
+        }
 
         // This is the function use outside to access FrameSettings. It return the current state of FrameSettings for the camera
         // taking into account the customization via the debug menu

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.cs

         {
             m_DebugDisplayStatsItems = new DebugUI.Widget[]
             {
-                new DebugUI.Value { displayName = "Frame Rate", getter = () => 1f / Time.smoothDeltaTime, refreshRate = 1f / 30f },
-                new DebugUI.Value { displayName = "Frame Rate (ms)", getter = () => Time.smoothDeltaTime * 1000f, refreshRate = 1f / 30f }
+                new DebugUI.Value { displayName = "Frame Rate (fps)", getter = () => 1f / Time.smoothDeltaTime, refreshRate = 1f / 30f },
+                new DebugUI.Value { displayName = "Frame Time (ms)", getter = () => Time.smoothDeltaTime * 1000f, refreshRate = 1f / 30f }
             };
 
             var panel = DebugManager.instance.GetPanel(k_PanelDisplayStats, true);

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

     [CanEditMultipleObjects]
     partial class HDCameraEditor : Editor
     {
-        [MenuItem("CONTEXT/Camera/Remove HD Camera", false, 0)]
-        static void RemoveLight(MenuCommand menuCommand)
+        [MenuItem("CONTEXT/Camera/Remove Component", false, 0)]
+        static void RemoveCamera(MenuCommand menuCommand)
+            Camera camera = go.GetComponent<Camera>();
+            HDAdditionalCameraData cameraAdditionalData = go.GetComponent<HDAdditionalCameraData>();
+
+            Assert.IsNotNull(camera);
+            Assert.IsNotNull(cameraAdditionalData);
+
-            Undo.DestroyObjectImmediate(go.GetComponent<Camera>());
-            Undo.DestroyObjectImmediate(go.GetComponent<HDAdditionalCameraData>());
+            Undo.DestroyObjectImmediate(camera);
+            Undo.DestroyObjectImmediate(cameraAdditionalData);
+        }
+
+        [MenuItem("CONTEXT/Camera/Reset", false, 0)]
+        static void ResetCamera(MenuCommand menuCommand)
+        {
+            GameObject go = ((Camera)menuCommand.context).gameObject;
+
+            Assert.IsNotNull(go);
+
+            Camera camera = go.GetComponent<Camera>();
+            HDAdditionalCameraData cameraAdditionalData = go.GetComponent<HDAdditionalCameraData>();
+
+            Assert.IsNotNull(camera);
+            Assert.IsNotNull(cameraAdditionalData);
+
+            Undo.SetCurrentGroupName("Reset HD Camera");
+            Undo.RecordObjects(new UnityEngine.Object[] { camera, cameraAdditionalData }, "Reset HD Camera");
+            camera.Reset();
+            // To avoid duplicating init code we copy default settings to Reset additional data
+            // Note: we can't call this code inside the HDAdditionalCameraData, thus why we don't wrap it in a Reset() function
+            HDUtils.s_DefaultHDAdditionalCameraData.CopyTo(cameraAdditionalData);
         }
 
         SerializedHDCamera m_SerializedCamera;

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

 {
     public static class EditorReflectionSystem
     {
-        static int _Cubemap = Shader.PropertyToID("_Cubemap");
         const HideFlags k_ReflectionSystemDictionaryHideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector | HideFlags.DontSaveInBuild;
 
         public static bool IsCollidingWithOtherProbes(string targetPath, ReflectionProbe targetProbe, out ReflectionProbe collidingProbe)
             if (!UnityEditor.Lightmapping.BakeReflectionProbe(probe, path))
                 Debug.LogError("Failed to bake reflection probe to " + path);
             EditorUtility.ClearProgressBar();
-        }
-
-        public static void ResetProbeSceneTextureInMaterial(ReflectionProbe p)
-        {
-            var renderer = p.GetComponent<Renderer>();
-            renderer.sharedMaterial.SetTexture(_Cubemap, p.texture);
-        }
-
-        public static void ResetProbeSceneTextureInMaterial(PlanarReflectionProbe p)
-        {
         }
 
         static MethodInfo k_Lightmapping_BakeReflectionProbeSnapshot = typeof(UnityEditor.Lightmapping).GetMethod("BakeReflectionProbeSnapshot", BindingFlags.Static | BindingFlags.NonPublic);

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

                                 if (probe != null)
                                 {
                                     EditorReflectionSystem.BakeCustomReflectionProbe(probe, false);
-                                    EditorReflectionSystem.ResetProbeSceneTextureInMaterial(probe);
-                                    EditorReflectionSystem.ResetProbeSceneTextureInMaterial(planarProbe);
                                 }
                             }
                         },
                         {
                             EditorReflectionSystem.BakeCustomReflectionProbe(probe, true);
-                            EditorReflectionSystem.ResetProbeSceneTextureInMaterial(probe);
-                            EditorReflectionSystem.ResetProbeSceneTextureInMaterial(planarProbe);
                         }
                         GUIUtility.ExitGUI();
                     }
                         if (probe != null)
                         {
                             EditorReflectionSystem.BakeReflectionProbeSnapshot(probe);
-                            EditorReflectionSystem.ResetProbeSceneTextureInMaterial(probe);
-                            EditorReflectionSystem.ResetProbeSceneTextureInMaterial(planarProbe);
                         }
                         GUIUtility.ExitGUI();
                     }

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

             Normal
         }
 
-        internal static Color k_GizmoThemeColorExtent = new Color(255f / 255f, 229f / 255f, 148f / 255f, 80f / 255f);
-        internal static Color k_GizmoThemeColorExtentFace = new Color(255f / 255f, 229f / 255f, 148f / 255f, 45f / 255f);
-        internal static Color k_GizmoThemeColorInfluenceBlend = new Color(83f / 255f, 255f / 255f, 95f / 255f, 75f / 255f);
-        internal static Color k_GizmoThemeColorInfluenceBlendFace = new Color(83f / 255f, 255f / 255f, 95f / 255f, 17f / 255f);
-        internal static Color k_GizmoThemeColorInfluenceNormalBlend = new Color(0f / 255f, 229f / 255f, 255f / 255f, 80f / 255f);
-        internal static Color k_GizmoThemeColorInfluenceNormalBlendFace = new Color(0f / 255f, 229f / 255f, 255f / 255f, 36f / 255f);
-        internal static Color k_GizmoThemeColorProjection = new Color(0x00 / 255f, 0xE5 / 255f, 0xFF / 255f, 0x20 / 255f);
-        internal static Color k_GizmoThemeColorProjectionFace = new Color(0x00 / 255f, 0xE5 / 255f, 0xFF / 255f, 0x20 / 255f);
-        internal static Color k_GizmoThemeColorDisabled = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
-        internal static Color k_GizmoThemeColorDisabledFace = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
-
-        internal static readonly Color[][] k_handlesColor = new Color[][]
-        {
-            new Color[]
-            {
-                Color.red,
-                Color.green,
-                Color.blue
-            },
-            new Color[]
-            {
-                new Color(.5f, 0f, 0f, 1f),
-                new Color(0f, .5f, 0f, 1f),
-                new Color(0f, 0f, .5f, 1f)
-            }
-        };
-
         void OnSceneGUI()
         {
             var s = m_UIState;
                 EditorUtility.SetDirty(p);
 
                 s.UpdateOldLocalSpace(p);
-            }
-        }
-
-        [DrawGizmo(GizmoType.Active)]
-        static void RenderGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
-        {
-            var e = GetEditorFor(reflectionProbe);
-            if (e == null || !e.sceneViewEditing)
-                return;
-
-            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
-
-            switch (EditMode.editMode)
-            {
-                // Influence editing
-                case EditMode.SceneViewEditMode.ReflectionProbeBox:
-                    Gizmos_Influence(reflectionProbe, reflectionData, e, true);
-                    break;
-                // Influence fade editing
-                case EditMode.SceneViewEditMode.GridBox:
-                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Standard, true);
-                    break;
-                // Influence normal fade editing
-                case EditMode.SceneViewEditMode.Collider:
-                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Normal, true);
-                    break;
-            }
-        }
-
-        [DrawGizmo(GizmoType.Selected)]
-        static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
-        {
-            var e = GetEditorFor(reflectionProbe);
-            if (e == null || !e.sceneViewEditing)
-                return;
-
-            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
-
-            //Gizmos_Influence(reflectionProbe, reflectionData, e, false);
-            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Standard, false);
-            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Normal, false);
-
-            DrawVerticalRay(reflectionProbe.transform);
-            HDReflectionProbeEditorUtility.ChangeVisibility(reflectionProbe, true);
-        }
-
-        [DrawGizmo(GizmoType.NonSelected)]
-        static void DrawNonSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
-        {
-            var e = GetEditorFor(reflectionProbe);
-            if (e == null || !e.sceneViewEditing)
-                return;
-
-            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
-            if (reflectionData != null)
-                HDReflectionProbeEditorUtility.ChangeVisibility(reflectionProbe, false);
-        }
-
-        static void Gizmos_InfluenceFade(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, InfluenceType type, bool isEdit)
-        {
-            var col = Gizmos.color;
-            var mat = Gizmos.matrix;
-
-            Gizmo6FacesBoxContained box;
-            Vector3 boxCenterOffset;
-            Vector3 boxSizeOffset;
-            float sphereRadiusOffset;
-            Color color;
-            switch (type)
-            {
-                default:
-                case InfluenceType.Standard:
-                    {
-                        box = e != null ? e.m_UIState.alternativeBoxBlendHandle : null;
-                        boxCenterOffset = a.boxBlendCenterOffset;
-                        boxSizeOffset = a.boxBlendSizeOffset;
-                        sphereRadiusOffset = a.sphereBlendRadiusOffset;
-                        color = isEdit ? k_GizmoThemeColorInfluenceBlendFace : k_GizmoThemeColorInfluenceBlend;
-                        break;
-                    }
-                case InfluenceType.Normal:
-                    {
-                        box = e != null ? e.m_UIState.alternativeBoxBlendNormalHandle : null;
-                        boxCenterOffset = a.boxBlendNormalCenterOffset;
-                        boxSizeOffset = a.boxBlendNormalSizeOffset;
-                        sphereRadiusOffset = a.sphereBlendNormalRadiusOffset;
-                        color = isEdit ? k_GizmoThemeColorInfluenceNormalBlendFace : k_GizmoThemeColorInfluenceNormalBlend;
-                        break;
-                    }
-            }
-
-            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
-            switch (a.influenceShape)
-            {
-                case ShapeType.Box:
-                    {
-                        Gizmos.color = color;
-                        if(e != null) // e == null may occure when editor have still not been created at selection while the tool is not used for this part
-                        {
-                            box.DrawHull(isEdit);
-                        }
-                        else
-                        {
-                            if (isEdit)
-                                Gizmos.DrawCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
-                            else
-                                Gizmos.DrawWireCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
-                        }
-                        break;
-                    }
-                case ShapeType.Sphere:
-                    {
-                        Gizmos.color = color;
-                        if (isEdit)
-                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
-                        else
-                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
-                        break;
-                    }
-            }
-
-            Gizmos.matrix = mat;
-            Gizmos.color = col;
-        }
-
-        static void Gizmos_Influence(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, bool isEdit)
-        {
-            var col = Gizmos.color;
-            var mat = Gizmos.matrix;
-
-            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
-            switch (a.influenceShape)
-            {
-                case ShapeType.Box:
-                    {
-                        Gizmos.color = k_GizmoThemeColorExtentFace;
-                        e.m_UIState.alternativeBoxInfluenceHandle.DrawHull(isEdit);
-                        break;
-                    }
-                case ShapeType.Sphere:
-                    {
-                        Gizmos.color = k_GizmoThemeColorExtentFace;
-                        if (isEdit)
-                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius);
-                        else
-                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius);
-                        break;
-                    }
-            }
-
-            Gizmos.matrix = mat;
-            Gizmos.color = col;
-        }
-
-        static void DrawVerticalRay(Transform transform)
-        {
-            Ray ray = new Ray(transform.position, Vector3.down);
-            RaycastHit hit;
-            if (Physics.Raycast(ray, out hit))
-            {
-                Handles.color = Color.green;
-                Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
-                Handles.DrawLine(transform.position - Vector3.up * 0.5f, hit.point);
-                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
-
-                Handles.color = Color.red;
-                Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
-                Handles.DrawLine(transform.position, hit.point);
-                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
             }
         }
     }

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

 {
     partial class HDReflectionProbeEditor
     {
-        void ChangeVisibilityOfAllTargets(bool visibility)
-        {
-            if (targets.Length == 0) return;
-
-            for (var i = 0; i < targets.Length; ++i)
-            {
-                if (targets[i] != null)
-                {
-                    var p = (ReflectionProbe)targets[i];
-                    HDReflectionProbeEditorUtility.ChangeVisibility(p, visibility);
-                }
-            }
-        }
-
-            for (var i = 0; i < targets.Length; ++i)
-            {
-                var p = (ReflectionProbe)targets[i];
-                var a = (HDAdditionalReflectionData)m_AdditionalDataSerializedObject.targetObjects[i];
-                HDReflectionProbeEditorUtility.InitializeProbe(p, a);
-            }
-
             // For an unknown reason, newly created probes sometype have the type "Quad" (value = 1)
             // This type of probe is not supported by Unity since 5.4
             // But we need to force it here so it does not bake into a 2D texture but a Cubemap

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

             Undo.SetCurrentGroupName("Remove HD Reflection Probe");
             Undo.DestroyObjectImmediate(go.GetComponent<ReflectionProbe>());
             Undo.DestroyObjectImmediate(go.GetComponent<HDAdditionalReflectionData>());
-            Undo.DestroyObjectImmediate(go.GetComponent<MeshRenderer>());
-            Undo.DestroyObjectImmediate(go.GetComponent<MeshFilter>());
         }
 
         static Dictionary<ReflectionProbe, HDReflectionProbeEditor> s_ReflectionProbeEditors = new Dictionary<ReflectionProbe, HDReflectionProbeEditor>();
             }
 
             InitializeAllTargetProbes();
-            ChangeVisibilityOfAllTargets(true);
-        void OnDisable()
-        {
-            ChangeVisibilityOfAllTargets(false);
-        }
 
         public override void OnInspectorGUI()
         {
             var flags = visible ? HideFlags.None : HideFlags.HideInInspector;
             for (var i = 0; i < targets.Length; ++i)
             {
-                var target = targets[i];
-                var p = (ReflectionProbe)target;
-                var meshRenderer = p.GetComponent<MeshRenderer>();
-                var meshFilter = p.GetComponent<MeshFilter>();
-
-                meshRenderer.hideFlags = flags;
-                meshFilter.hideFlags = flags;
             }
         }
 

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

 {
     public static class HDReflectionProbeEditorUtility
     {
-        static int _Cubemap = Shader.PropertyToID("_Cubemap");
-        static Material s_PreviewMaterial;
-        static Mesh s_SphereMesh;
-
-        [InitializeOnLoadMethod]
-        static void Initialize()
-        {
-            s_SphereMesh = Resources.GetBuiltinResource(typeof(Mesh), "New-Sphere.fbx") as Mesh;
-        }
-
         public static Matrix4x4 GetLocalSpace(ReflectionProbe probe)
         {
             var t = probe.transform.position;
             return true;
         }
 
-        public static void ResetProbeSceneTextureInMaterial(ReflectionProbe p)
-        {
-            var renderer = p.GetComponent<Renderer>();
-            renderer.sharedMaterial.SetTexture(_Cubemap, p.texture);
-        }
-
         public static float CalculateSphereMaxBlendDistance(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor o)
         {
             return p.influenceSphereRadius.floatValue;
         {
             return p.boxSize.vector3Value * 0.5f;
-        }
-
-        internal static void InitializeProbe(ReflectionProbe p, HDAdditionalReflectionData data)
-        {
-            var meshFilter = p.GetComponent<MeshFilter>() ?? p.gameObject.AddComponent<MeshFilter>();
-            var meshRenderer = p.GetComponent<MeshRenderer>() ?? p.gameObject.AddComponent<MeshRenderer>();
-
-            meshFilter.sharedMesh = s_SphereMesh;
-
-            // Lazy evaluation attempt to avoid shader compil error issue in Editor (The shader is not found the first time
-            // we load after deleting Library folder)
-            if (s_PreviewMaterial == null)
-            {
-                s_PreviewMaterial = new Material(Shader.Find("Debug/ReflectionProbePreview"))
-                {
-                    hideFlags = HideFlags.HideAndDontSave
-                };
-            }
-
-            var material = meshRenderer.sharedMaterial;
-            if (material == null
-                || material == s_PreviewMaterial
-                || material.shader != s_PreviewMaterial.shader)
-            {
-                material = Object.Instantiate(s_PreviewMaterial);
-                material.SetTexture(_Cubemap, p.texture);
-                material.hideFlags = HideFlags.HideAndDontSave;
-                meshRenderer.material = material;
-            }
-
-            meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
-            meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
-            meshRenderer.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion;
-        }
-
-        internal static void ChangeVisibility(ReflectionProbe p, bool visible)
-        {
-            var meshRenderer = p.GetComponent<MeshRenderer>() ?? p.gameObject.AddComponent<MeshRenderer>();
-            meshRenderer.enabled = visible;
         }
     }
 }

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

             if (EditorGUI.EndChangeCheck())
             {
                 s.SetModeTarget(p.mode.intValue);
-                foreach (var targetObject in p.so.targetObjects)
-                    HDReflectionProbeEditorUtility.ResetProbeSceneTextureInMaterial((ReflectionProbe)targetObject);
             }
         }
 

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

             var maxFaceDistance = d.sphereBaseRadius.floatValue;
 
             EditorGUILayout.PropertyField(d.sphereBaseRadius, _.GetContent("Radius"));
-            //EditorGUILayout.PropertyField(d.sphereBaseOffset, _.GetContent("Offset"));
-            EditorGUILayout.Slider(d.sphereInfluenceFade, 0, maxFaceDistance, _.GetContent("Influence Fade"));
-            EditorGUILayout.Slider(d.sphereInfluenceNormalFade, 0, maxFaceDistance, _.GetContent("Influence Normal Fade"));
+            EditorGUILayout.Slider(d.sphereInfluenceFade, 0, maxFaceDistance, _.GetContent("Blend Distance"));
         }
     }
 }

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

             m_DecalProjectorComponent.OnMaterialChange -= OnMaterialChange;
         }
 
+        private void OnDestroy()
+        {
+            DestroyImmediate(m_MaterialEditor);
+        }
+
         public void OnMaterialChange()
         {
             // Update material editor with the new material

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

             ZERO_INITIALIZE(SurfaceDescriptionInputs, output);
 
             $SurfaceDescriptionInputs.WorldSpaceNormal:          output.WorldSpaceNormal =            normalize(input.worldToTangent[2].xyz);
-            $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) unity_ObjectToWorld);      // transposed multiplication by inverse matrix to handle normal scale
-            $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
+            $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M);      // transposed multiplication by inverse matrix to handle normal scale
+            $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);    // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
             $SurfaceDescriptionInputs.WorldSpaceTangent:         output.WorldSpaceTangent =           input.worldToTangent[0].xyz;
             $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          TransformWorldToObjectDir(output.WorldSpaceTangent);

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

             ZERO_INITIALIZE(SurfaceDescriptionInputs, output);
 
             $SurfaceDescriptionInputs.WorldSpaceNormal:          output.WorldSpaceNormal =            normalize(input.worldToTangent[2].xyz);
-            $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) unity_ObjectToWorld);      // transposed multiplication by inverse matrix to handle normal scale
-            $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
+            $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M);      // transposed multiplication by inverse matrix to handle normal scale
+            $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);    // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
             $SurfaceDescriptionInputs.WorldSpaceTangent:         output.WorldSpaceTangent =           input.worldToTangent[0].xyz;
             $SurfaceDescriptionInputs.ObjectSpaceTangent:        output.ObjectSpaceTangent =          TransformWorldToObjectDir(output.WorldSpaceTangent);

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

         {
             widgets.AddRange(new[]
             {
-                new DebugUI.Container
+                new DebugUI.Foldout
-                    displayName = "Lighting Settings",
+                    displayName = "Light Loop Settings",
                     children =
                     {
                         // Uncomment if you re-enable LIGHTLOOP_SINGLE_PASS multi_compile in lit*.shader

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightLoop/cleardispatchindirect.compute

 
 RWBuffer<uint> g_DispatchIndirectBuffer : register( u0 );   // Indirect arguments have to be in a _buffer_, not a structured buffer
 
+#include "LightLoop.cs.hlsl"
+
+    // On iOS, we get a GPU hang/reset based upon the execution of the ClearDispatchIndirect kernel.
+    // The buffer is created using the 'NUM_FEATURE_VARIANTS' constant but we're dispatching a threadgroup of 64 threads, so we are presumably going out of bounds (Metal GPU errors are not terribly descriptive, but this is a common cause).
+    // In DirectX out-of-bounds reads are always zero and out-of-bounds writes are are a no op. 
+    if (dispatchThreadId >= NUM_FEATURE_VARIANTS)
+        return;
+
     g_DispatchIndirectBuffer[dispatchThreadId * 3 + 0] = 0; // ThreadGroupCountX
     g_DispatchIndirectBuffer[dispatchThreadId * 3 + 1] = 1; // ThreadGroupCountY
     g_DispatchIndirectBuffer[dispatchThreadId * 3 + 2] = 1; // ThreadGroupCountZ

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

 
 namespace UnityEngine.Experimental.Rendering
 {
-    [RequireComponent(typeof(ReflectionProbe), typeof(MeshFilter), typeof(MeshRenderer))]
+    [RequireComponent(typeof(ReflectionProbe))]
     public class HDAdditionalReflectionData : MonoBehaviour
     {
         [HideInInspector]

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

   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
-  icon: {instanceID: 0}
+  icon: {fileID: 2800000, guid: 3b77af68825357f47ae9f6d0b9d30f2d, type: 3}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Lighting/Reflection/Volumes/ReflectionProxyVolumeComponent.cs.meta

   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
-  icon: {instanceID: 0}
+  icon: {fileID: 2800000, guid: a9ddbc20ff7d25948976df9d0f76eaf7, type: 3}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

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

         // Init precomputed texture
         //-----------------------------------------------------------------------------
 
-        bool m_isInit;
-
         public Lit() {}
 
         public override void Build(HDRenderPipelineAsset hdAsset)
-
-            m_isInit = false;
         }
 
         public override void Cleanup()
-
-            m_isInit = false;
-            if (m_isInit)
-                return;
-
-
-            m_isInit = true;
         }
 
         public override void Bind()

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

 
         public void RenderInit(FGDIndex index, CommandBuffer cmd)
         {
-            if (m_isInit[(int)index])
+            // Here we have to test IsCreated because in some circumstances (like loading RenderDoc), the texture is internally destroyed but we don't know from C# side.
+            // In this case IsCreated will return false, allowing us to re-render the texture (setting the texture as current RT during DrawFullScreen will automatically re-create it internally)
+            if (m_isInit[(int)index] && m_PreIntegratedFGD[(int)index].IsCreated())
                 return;
 
             using (new ProfilingSample(cmd, "PreIntegratedFGD Material Generation"))

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

         // Init precomputed textures
         //-----------------------------------------------------------------------------
 
-        bool m_isInit;
-
         public StackLit() {}
 
         public override void Build(HDRenderPipelineAsset hdAsset)
-
-            m_isInit = false;
         }
 
         public override void Cleanup()
-
-            m_isInit = false;
-            if (m_isInit)
-                return;
-
-
-            m_isInit = true;
         }
 
         public override void Bind()

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

         _DetailNormalScale("DetailNormal Scale", Range(0.0, 2.0)) = 1
 
         [HideInInspector] _DetailSmoothnessMapShow("DetailSmoothness Map Show", Float) = 0
-        _DetailSmoothnessMap("DetailSmoothness Map", 2D) = "grey" {} // Neutral is 0.5 for detail map
+        _DetailSmoothnessMap("DetailSmoothness Map", 2D) = "lineargrey" {} // Neutral is 0.5 for detail map
         _DetailSmoothnessMapUV("DetailSmoothness Map UV", Float) = 0.0
         _DetailSmoothnessMapUVLocal("DetailSmoothness Map UV Local", Float) = 0.0
         _DetailSmoothnessMapChannel("DetailSmoothness Map Channel", Float) = 0.0

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

                 rendererSupportsLightProbeProxyVolumes = true,
                 rendererSupportsMotionVectors = true,
                 rendererSupportsReceiveShadows = false,
-                rendererSupportsReflectionProbes = true
+                rendererSupportsReflectionProbes = true,
+                rendererSupportsRendererPriority = true
             };
 
             Lightmapping.SetDelegate(GlobalIlluminationUtils.hdLightsDelegate);
             var drawSettings = new DrawRendererSettings(hdCamera.camera, HDShaderPassNames.s_EmptyName)
             {
                 rendererConfiguration = rendererConfiguration,
-                sorting = { flags = SortFlags.CommonTransparent }
+                sorting = { flags = SortFlags.CommonTransparent | SortFlags.RendererPriority }
             };
 
             for (int i = 0; i < passNames.Length; ++i)
                 RenderTargetIdentifier source = m_CameraColorBuffer;
 
                 // For console we are not allowed to resize the windows, so don't use our hack.
-                bool tempHACK = !IsConsolePlatform();
+                // We also don't do the copy if viewport size and render texture size match.
+                bool viewportAndRTSameSize = (hdcamera.actualWidth == m_CameraColorBuffer.rt.width && hdcamera.actualHeight == m_CameraColorBuffer.rt.height);
+                bool tempHACK = !IsConsolePlatform() && !viewportAndRTSameSize;
 
                 if (tempHACK)
                 {

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

         {
             List<DebugUI.Widget> widgets = new List<DebugUI.Widget>();
             widgets.AddRange(
-                new DebugUI.Widget[]
+            new DebugUI.Widget[]
-                new DebugUI.Container
+                new DebugUI.Foldout
                 {
                     displayName = "Rendering Passes",
                     children =
                         new DebugUI.BoolField { displayName = "Enable Postprocess", getter = () => frameSettings.enablePostprocess, setter = value => frameSettings.enablePostprocess = value },
                     }
                 },
-                new DebugUI.Container
+                new DebugUI.Foldout
                 {
                     displayName = "Rendering Settings",
                     children =
                         new DebugUI.BoolField { displayName = "Enable MSAA", getter = () => frameSettings.enableMSAA, setter = value => frameSettings.enableMSAA = value },
                     }
                 },
-                new DebugUI.Container
+                new DebugUI.Foldout
                 {
                     displayName = "XR Settings",
                     children =
                 },
-                new DebugUI.Container
+                new DebugUI.Foldout
                 {
                     displayName = "Lighting Settings",
                     children =

com.unity.render-pipelines.high-definition/HDRP/ShaderVariables.hlsl

 #endif
 }
 
+// Define Model Matrix Macro
+// Note: In order to be able to define our macro to forbid usage of unity_ObjectToWorld/unity_WorldToObject
+// We need to declare inline function. Using uniform directly mean they are expand with the macro
+float4x4 GetUnityObjectToWorld() { return unity_ObjectToWorld; }
+float4x4 GetUnityWorldToObject() { return unity_WorldToObject; }
+
+#define UNITY_MATRIX_M     ApplyCameraTranslationToMatrix(GetUnityObjectToWorld())
+#define UNITY_MATRIX_I_M   ApplyCameraTranslationToInverseMatrix(GetUnityWorldToObject())
+
+#define unity_ObjectToWorld Use_Macro_UNITY_MATRIX_M_instead_of_unity_ObjectToWorld
+#define unity_WorldToObject Use_Macro_UNITY_MATRIX_I_M_instead_of_unity_WorldToObject
+
+// Define View/Projection matrix macro
-
 
 // This define allow to tell to unity instancing that we will use our camera relative functions (ApplyCameraTranslationToMatrix and  ApplyCameraTranslationToInverseMatrix) for the model view matrix
 #define MODIFY_MATRIX_FOR_CAMERA_RELATIVE_RENDERING

com.unity.render-pipelines.high-definition/HDRP/ShaderVariablesMatrixDefsHDCamera.hlsl

 #ifndef UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 #define UNITY_SHADER_VARIABLES_MATRIX_DEFS_HDCAMERA_INCLUDED
 
-#define UNITY_MATRIX_M     ApplyCameraTranslationToMatrix(unity_ObjectToWorld)
-#define UNITY_MATRIX_I_M   ApplyCameraTranslationToInverseMatrix(unity_WorldToObject)
-
 #if defined(USING_STEREO_MATRICES)
 
 #define UNITY_MATRIX_V     _ViewMatrixStereo[unity_StereoEyeIndex]

com.unity.render-pipelines.high-definition/HDRP/ShaderVariablesMatrixDefsLegacyUnity.hlsl

 #ifndef UNITY_SHADER_VARIABLES_MATRIX_DEFS_LEGACY_UNITY_INCLUDED
 #define UNITY_SHADER_VARIABLES_MATRIX_DEFS_LEGACY_UNITY_INCLUDED
 
-#define UNITY_MATRIX_M     ApplyCameraTranslationToMatrix(unity_ObjectToWorld)
-#define UNITY_MATRIX_I_M   ApplyCameraTranslationToInverseMatrix(unity_WorldToObject)
 #define UNITY_MATRIX_V     unity_MatrixV
 #define UNITY_MATRIX_I_V   unity_MatrixInvV
 #define UNITY_MATRIX_P     OptimizeProjectionMatrix(glstate_matrix_projection)

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Icons.meta

+fileFormatVersion: 2
+guid: 97dc5286d61263d47b2705992cffe2d9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    partial class HDReflectionProbeEditor
+    {
+        static Mesh sphere;
+        static Material material;
+
+        [DrawGizmo(GizmoType.Active)]
+        static void RenderGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
+        {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null || !e.sceneViewEditing)
+                return;
+
+            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
+
+            switch (EditMode.editMode)
+            {
+                // Influence editing
+                case EditMode.SceneViewEditMode.ReflectionProbeBox:
+                    Gizmos_Influence(reflectionProbe, reflectionData, e, true);
+                    break;
+                // Influence fade editing
+                case EditMode.SceneViewEditMode.GridBox:
+                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Standard, true);
+                    break;
+                // Influence normal fade editing
+                case EditMode.SceneViewEditMode.Collider:
+                    Gizmos_InfluenceFade(reflectionProbe, reflectionData, e, InfluenceType.Normal, true);
+                    break;
+            }
+        }
+
+        [DrawGizmo(GizmoType.Selected)]
+        static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
+        {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null)
+                return;
+
+            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
+            Gizmos_CapturePoint(reflectionProbe, reflectionData, e);
+
+            if (!e.sceneViewEditing)
+                return;
+
+            //Gizmos_Influence(reflectionProbe, reflectionData, e, false);
+            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Standard, false);
+            Gizmos_InfluenceFade(reflectionProbe, reflectionData, null, InfluenceType.Normal, false);
+
+            DrawVerticalRay(reflectionProbe.transform);
+        }
+
+        static void Gizmos_InfluenceFade(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, InfluenceType type, bool isEdit)
+        {
+            var col = Gizmos.color;
+            var mat = Gizmos.matrix;
+
+            Gizmo6FacesBoxContained box;
+            Vector3 boxCenterOffset;
+            Vector3 boxSizeOffset;
+            float sphereRadiusOffset;
+            Color color;
+            switch (type)
+            {
+                default:
+                case InfluenceType.Standard:
+                    {
+                        box = e != null ? e.m_UIState.alternativeBoxBlendHandle : null;
+                        boxCenterOffset = a.boxBlendCenterOffset;
+                        boxSizeOffset = a.boxBlendSizeOffset;
+                        sphereRadiusOffset = a.sphereBlendRadiusOffset;
+                        color = isEdit ? k_GizmoThemeColorInfluenceBlendFace : k_GizmoThemeColorInfluenceBlend;
+                        break;
+                    }
+                case InfluenceType.Normal:
+                    {
+                        box = e != null ? e.m_UIState.alternativeBoxBlendNormalHandle : null;
+                        boxCenterOffset = a.boxBlendNormalCenterOffset;
+                        boxSizeOffset = a.boxBlendNormalSizeOffset;
+                        sphereRadiusOffset = a.sphereBlendNormalRadiusOffset;
+                        color = isEdit ? k_GizmoThemeColorInfluenceNormalBlendFace : k_GizmoThemeColorInfluenceNormalBlend;
+                        break;
+                    }
+            }
+
+            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
+            switch (a.influenceShape)
+            {
+                case ShapeType.Box:
+                    {
+                        Gizmos.color = color;
+                        if (e != null) // e == null may occure when editor have still not been created at selection while the tool is not used for this part
+                        {
+                            box.DrawHull(isEdit);
+                        }
+                        else
+                        {
+                            if (isEdit)
+                                Gizmos.DrawCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
+                            else
+                                Gizmos.DrawWireCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
+                        }
+                        break;
+                    }
+                case ShapeType.Sphere:
+                    {
+                        Gizmos.color = color;
+                        if (isEdit)
+                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
+                        else
+                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
+                        break;
+                    }
+            }
+
+            Gizmos.matrix = mat;
+            Gizmos.color = col;
+        }
+
+        static void Gizmos_Influence(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, bool isEdit)
+        {
+            var col = Gizmos.color;
+            var mat = Gizmos.matrix;
+
+            Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
+            switch (a.influenceShape)
+            {
+                case ShapeType.Box:
+                    {
+                        Gizmos.color = k_GizmoThemeColorExtentFace;
+                        e.m_UIState.alternativeBoxInfluenceHandle.DrawHull(isEdit);
+                        break;
+                    }
+                case ShapeType.Sphere:
+                    {
+                        Gizmos.color = k_GizmoThemeColorExtentFace;
+                        if (isEdit)
+                            Gizmos.DrawSphere(p.center, a.influenceSphereRadius);
+                        else
+                            Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius);
+                        break;
+                    }
+            }
+
+            Gizmos.matrix = mat;
+            Gizmos.color = col;
+        }
+
+        static void DrawVerticalRay(Transform transform)
+        {
+            Ray ray = new Ray(transform.position, Vector3.down);
+            RaycastHit hit;
+            if (Physics.Raycast(ray, out hit))
+            {
+                Handles.color = Color.green;
+                Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
+                Handles.DrawLine(transform.position - Vector3.up * 0.5f, hit.point);
+                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+
+                Handles.color = Color.red;
+                Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
+                Handles.DrawLine(transform.position, hit.point);
+                Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
+            }
+        }
+
+        static void Gizmos_CapturePoint(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e)
+        {
+            if(sphere == null)
+            {
+                sphere = Resources.GetBuiltinResource<Mesh>("New-Sphere.fbx");
+            }
+            if(material == null)
+            {
+                material = new Material(Shader.Find("Debug/ReflectionProbePreview"));
+            }
+            material.SetTexture("_Cubemap", p.texture);
+            material.SetPass(0);
+            Graphics.DrawMeshNow(sphere, Matrix4x4.TRS(p.transform.position, Quaternion.identity, Vector3.one));
+        }
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Gizmos.cs.meta

+fileFormatVersion: 2
+guid: f0521a8f59de2c548bc5a6796cd32be9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

+using System;
+using UnityEditor.IMGUI.Controls;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    partial class HDReflectionProbeEditor
+    {
+        internal static Color k_GizmoThemeColorExtent = new Color(255f / 255f, 229f / 255f, 148f / 255f, 80f / 255f);
+        internal static Color k_GizmoThemeColorExtentFace = new Color(255f / 255f, 229f / 255f, 148f / 255f, 45f / 255f);
+        internal static Color k_GizmoThemeColorInfluenceBlend = new Color(83f / 255f, 255f / 255f, 95f / 255f, 75f / 255f);
+        internal static Color k_GizmoThemeColorInfluenceBlendFace = new Color(83f / 255f, 255f / 255f, 95f / 255f, 17f / 255f);
+        internal static Color k_GizmoThemeColorInfluenceNormalBlend = new Color(0f / 255f, 229f / 255f, 255f / 255f, 80f / 255f);
+        internal static Color k_GizmoThemeColorInfluenceNormalBlendFace = new Color(0f / 255f, 229f / 255f, 255f / 255f, 36f / 255f);
+        internal static Color k_GizmoThemeColorProjection = new Color(0x00 / 255f, 0xE5 / 255f, 0xFF / 255f, 0x20 / 255f);
+        internal static Color k_GizmoThemeColorProjectionFace = new Color(0x00 / 255f, 0xE5 / 255f, 0xFF / 255f, 0x20 / 255f);
+        internal static Color k_GizmoThemeColorDisabled = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
+        internal static Color k_GizmoThemeColorDisabledFace = new Color(0x99 / 255f, 0x89 / 255f, 0x59 / 255f, 0x10 / 255f);
+
+        internal static readonly Color[][] k_handlesColor = new Color[][]
+        {
+            new Color[]
+            {
+                Color.red,
+                Color.green,
+                Color.blue
+            },
+            new Color[]
+            {
+                new Color(.5f, 0f, 0f, 1f),
+                new Color(0f, .5f, 0f, 1f),
+                new Color(0f, 0f, .5f, 1f)
+            }
+        };
+    }
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Skin.cs.meta

+fileFormatVersion: 2
+guid: 4bdc573336d075b419133b489a094c6a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Icons/PlanarReflection.png.meta

+fileFormatVersion: 2
+guid: 3b77af68825357f47ae9f6d0b9d30f2d
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 6
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Icons/Proxy.png.meta

+fileFormatVersion: 2
+guid: a9ddbc20ff7d25948976df9d0f76eaf7
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 6
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 2ff1115d37a2ce24f910473fc18b2af2
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: