Merge pull request #1280 from Unity-Technologies/volume-improvements-next

Volume improvements

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/Drawers/ColorParameterDrawer.cs

                 return false;
 
             var o = parameter.GetObjectRef<ColorParameter>();
-            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.showAlpha);
+            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.hdr);
             return true;
         }
     }

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeComponentListEditor.cs

 {
     public sealed class VolumeComponentListEditor
     {
+        public VolumeProfile asset { get; private set; }
+
-        VolumeProfile m_Asset;
         SerializedObject m_SerializedObject;
         SerializedProperty m_ComponentsProperty;
 
             Assert.IsNotNull(asset);
             Assert.IsNotNull(serializedObject);
 
-            m_Asset = asset;
+            this.asset = asset;
             m_SerializedObject = serializedObject;
             m_ComponentsProperty = serializedObject.Find((VolumeProfile x) => x.components);
             Assert.IsNotNull(m_ComponentsProperty);
 
         void OnUndoRedoPerformed()
         {
-            m_Asset.isDirty = true;
+            asset.isDirty = true;
 
             // Dumb hack to make sure the serialized object is up to date on undo (else there'll be
             // a state mismatch when this class is used in a GameObject inspector).
             m_Editors.Clear();
 
             // Recreate editors for existing settings, if any
-            for (int i = 0; i < m_Asset.components.Count; i++)
-                CreateEditor(m_Asset.components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
+            var components = asset.components;
+            for (int i = 0; i < components.Count; i++)
+                CreateEditor(components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
         }
 
         public void Clear()
 
         public void OnGUI()
         {
-            if (m_Asset == null)
+            if (asset == null)
-            if (m_Asset.isDirty)
+            if (asset.isDirty)
-                m_Asset.isDirty = false;
+                asset.isDirty = false;
-                || AssetDatabase.IsOpenForEdit(m_Asset, StatusQueryOptions.UseCachedIfPossible);
+                || AssetDatabase.IsOpenForEdit(asset, StatusQueryOptions.UseCachedIfPossible);
 
             using (new EditorGUI.DisabledScope(!isEditable))
             {
                     {
                         var r = hscope.rect;
                         var pos = new Vector2(r.x + r.width / 2f, r.yMax + 18f);
-                        FilterWindow.Show(pos, new VolumeComponentProvider(m_Asset, this));
+                        FilterWindow.Show(pos, new VolumeComponentProvider(asset, this));
                     }
                 }
             }
             Undo.RegisterCreatedObjectUndo(component, "Add Volume Component");
 
             // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(component, m_Asset);
+            // Only when we're not dealing with an instantiated asset
+            if (EditorUtility.IsPersistent(asset))
+                AssetDatabase.AddObjectToAsset(component, asset);
 
             // Grow the list first, then add - that's how serialized lists work in Unity
             m_ComponentsProperty.arraySize++;
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
-            AssetDatabase.SaveAssets();
+            if (EditorUtility.IsPersistent(asset))
+            {
+                EditorUtility.SetDirty(asset);
+                AssetDatabase.SaveAssets();
+            }
 
             // Create & store the internal editor object for this effect
             CreateEditor(component, componentProp, forceOpen: true);
             Undo.DestroyObjectImmediate(component);
 
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
             AssetDatabase.SaveAssets();
         }
 
             Undo.RegisterCreatedObjectUndo(newComponent, "Reset Volume Component");
 
             // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(newComponent, m_Asset);
+            AssetDatabase.AddObjectToAsset(newComponent, asset);
 
             // Put it in the reserved space
             property.objectReferenceValue = newComponent;
             Undo.DestroyObjectImmediate(prevComponent);
 
             // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
             AssetDatabase.SaveAssets();
         }
 

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeEditor.cs

             get { return target as Volume; }
         }
 
+        VolumeProfile profileRef
+        {
+            get { return actualTarget.HasInstantiatedProfile() ? actualTarget.profile : actualTarget.sharedProfile; }
+        }
+
         void OnEnable()
         {
             var o = new PropertyFetcher<Volume>(serializedObject);
             var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
             var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);
 
-            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent("Profile|A reference to a profile asset."));
+            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Profile (Instance)|A copy of a profile asset." : "Profile|A reference to a profile asset."));
-                var profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+                VolumeProfile profile = null;
+
+                if (actualTarget.HasInstantiatedProfile())
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, actualTarget.profile, typeof(VolumeProfile), false);
+                else
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+
+                    if (actualTarget.HasInstantiatedProfile()) // Clear the instantiated profile, from now on we're using shared again
+                        actualTarget.profile = null;
                 }
 
                 EditorGUI.EndProperty();
                     var scene = actualTarget.gameObject.scene;
                     var asset = VolumeProfileFactory.CreateVolumeProfile(scene, targetName);
                     m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
-                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent("Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
+                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Save|Save the instantiated profile" : "Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
-                    var origin = (VolumeProfile)m_Profile.objectReferenceValue;
-                    var path = AssetDatabase.GetAssetPath(origin);
+                    var origin = profileRef;
+                    var path = AssetDatabase.GetAssetPath(m_Profile.objectReferenceValue);
                     path = AssetDatabase.GenerateUniqueAssetPath(path);
 
                     var asset = Instantiate(origin);
                     AssetDatabase.Refresh();
 
                     m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
                     assetHasChanged = true;
                 }
             }
-            if (m_Profile.objectReferenceValue == null)
+            if (m_Profile.objectReferenceValue == null && !actualTarget.HasInstantiatedProfile())
             {
                 if (assetHasChanged)
                     m_ComponentList.Clear(); // Asset wasn't null before, do some cleanup
-                if (assetHasChanged)
-                    RefreshEffectListEditor((VolumeProfile)m_Profile.objectReferenceValue);
+                if (assetHasChanged || profileRef != m_ComponentList.asset)
+                    RefreshEffectListEditor(profileRef);
 
                 if (!multiEdit)
                 {

ScriptableRenderPipeline/Core/CoreRP/Volume/Volume.cs

             }
         }
 
+        public bool HasInstantiatedProfile()
+        {
+            return m_InternalProfile != null;
+        }
+
         // Needed for state tracking (see the comments in Update)
         int m_PreviousLayer;
         float m_PreviousPriority;

ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeManager.cs

     public sealed class VolumeManager
     {
         //>>> System.Lazy<T> is broken in Unity (legacy runtime) so we'll have to do it ourselves :|
-        static volatile VolumeManager s_Instance;
-        static object s_LockObj = new UnityObject();
+        static readonly VolumeManager s_Instance = new VolumeManager();
+        public static VolumeManager instance { get { return s_Instance; } }
-        public static VolumeManager instance
-        {
-            get
-            {
-                // Double-lock checking
-                if (s_Instance == null)
-                {
-                    lock (s_LockObj) // Lock on a separate object to avoid deadlocks
-                    {
-                        if (s_Instance == null)
-                            s_Instance = new VolumeManager();
-                    }
-                }
-
-                return s_Instance;
-            }
-        }
+        // Explicit static constructor to tell the C# compiler not to mark type as beforefieldinit
+        static VolumeManager() { }
         //<<<
 
         // Internal stack