您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
555 行
23 KiB
555 行
23 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEditor.Experimental.UIElements.GraphView;
|
|
using UnityEngine;
|
|
using UnityEngine.Experimental.UIElements;
|
|
using UnityEditor.Graphing;
|
|
using UnityEditor.ShaderGraph.Drawing.Inspector;
|
|
using UnityEngine.Experimental.UIElements.StyleEnums;
|
|
using UnityEngine.Experimental.UIElements.StyleSheets;
|
|
using UnityEngine.Rendering;
|
|
using Edge = UnityEditor.Experimental.UIElements.GraphView.Edge;
|
|
using Object = UnityEngine.Object;
|
|
#if UNITY_2018_1
|
|
using GeometryChangedEvent = UnityEngine.Experimental.UIElements.PostLayoutEvent;
|
|
#endif
|
|
|
|
namespace UnityEditor.ShaderGraph.Drawing
|
|
{
|
|
[Serializable]
|
|
class FloatingWindowsLayout
|
|
{
|
|
public WindowDockingLayout previewLayout = new WindowDockingLayout();
|
|
public WindowDockingLayout blackboardLayout = new WindowDockingLayout();
|
|
public Vector2 masterPreviewSize = new Vector2(400, 400);
|
|
}
|
|
|
|
public class GraphEditorView : VisualElement, IDisposable
|
|
{
|
|
MaterialGraphView m_GraphView;
|
|
MasterPreviewView m_MasterPreviewView;
|
|
|
|
private EditorWindow m_EditorWindow;
|
|
|
|
AbstractMaterialGraph m_Graph;
|
|
PreviewManager m_PreviewManager;
|
|
SearchWindowProvider m_SearchWindowProvider;
|
|
EdgeConnectorListener m_EdgeConnectorListener;
|
|
BlackboardProvider m_BlackboardProvider;
|
|
|
|
const string k_FloatingWindowsLayoutKey = "UnityEditor.ShaderGraph.FloatingWindowsLayout";
|
|
FloatingWindowsLayout m_FloatingWindowsLayout;
|
|
|
|
public Action saveRequested { get; set; }
|
|
|
|
public Action convertToSubgraphRequested
|
|
{
|
|
get { return m_GraphView.onConvertToSubgraphClick; }
|
|
set { m_GraphView.onConvertToSubgraphClick = value; }
|
|
}
|
|
|
|
public Action showInProjectRequested { get; set; }
|
|
|
|
public MaterialGraphView graphView
|
|
{
|
|
get { return m_GraphView; }
|
|
}
|
|
|
|
PreviewManager previewManager
|
|
{
|
|
get { return m_PreviewManager; }
|
|
set { m_PreviewManager = value; }
|
|
}
|
|
|
|
public GraphEditorView(EditorWindow editorWindow, AbstractMaterialGraph graph, string assetName)
|
|
{
|
|
m_Graph = graph;
|
|
AddStyleSheetPath("Styles/GraphEditorView");
|
|
m_EditorWindow = editorWindow;
|
|
previewManager = new PreviewManager(graph);
|
|
|
|
string serializedWindowLayout = EditorUserSettings.GetConfigValue(k_FloatingWindowsLayoutKey);
|
|
if (!string.IsNullOrEmpty(serializedWindowLayout))
|
|
{
|
|
m_FloatingWindowsLayout = JsonUtility.FromJson<FloatingWindowsLayout>(serializedWindowLayout);
|
|
if (m_FloatingWindowsLayout.masterPreviewSize.x > 0f && m_FloatingWindowsLayout.masterPreviewSize.y > 0f)
|
|
previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.masterPreviewSize);
|
|
}
|
|
|
|
previewManager.RenderPreviews();
|
|
|
|
var toolbar = new IMGUIContainer(() =>
|
|
{
|
|
GUILayout.BeginHorizontal(EditorStyles.toolbar);
|
|
if (GUILayout.Button("Save Asset", EditorStyles.toolbarButton))
|
|
{
|
|
if (saveRequested != null)
|
|
saveRequested();
|
|
}
|
|
GUILayout.Space(6);
|
|
if (GUILayout.Button("Show In Project", EditorStyles.toolbarButton))
|
|
{
|
|
if (showInProjectRequested != null)
|
|
showInProjectRequested();
|
|
}
|
|
GUILayout.FlexibleSpace();
|
|
GUILayout.EndHorizontal();
|
|
});
|
|
Add(toolbar);
|
|
|
|
var content = new VisualElement { name = "content" };
|
|
{
|
|
m_GraphView = new MaterialGraphView(graph) { name = "GraphView", persistenceKey = "MaterialGraphView" };
|
|
m_GraphView.SetupZoom(0.05f, ContentZoomer.DefaultMaxScale);
|
|
m_GraphView.AddManipulator(new ContentDragger());
|
|
m_GraphView.AddManipulator(new SelectionDragger());
|
|
m_GraphView.AddManipulator(new RectangleSelector());
|
|
m_GraphView.AddManipulator(new ClickSelector());
|
|
m_GraphView.AddManipulator(new GraphDropTarget(graph));
|
|
m_GraphView.RegisterCallback<KeyDownEvent>(OnSpaceDown);
|
|
content.Add(m_GraphView);
|
|
|
|
m_BlackboardProvider = new BlackboardProvider(assetName, graph);
|
|
m_GraphView.Add(m_BlackboardProvider.blackboard);
|
|
Rect blackboardLayout = m_BlackboardProvider.blackboard.layout;
|
|
blackboardLayout.x = 10f;
|
|
blackboardLayout.y = 10f;
|
|
m_BlackboardProvider.blackboard.layout = blackboardLayout;
|
|
|
|
m_MasterPreviewView = new MasterPreviewView(assetName, previewManager, graph) { name = "masterPreview" };
|
|
|
|
WindowDraggable masterPreviewViewDraggable = new WindowDraggable(null, this);
|
|
m_MasterPreviewView.AddManipulator(masterPreviewViewDraggable);
|
|
m_GraphView.Add(m_MasterPreviewView);
|
|
|
|
//m_BlackboardProvider.onDragFinished += UpdateSerializedWindowLayout;
|
|
//m_BlackboardProvider.onResizeFinished += UpdateSerializedWindowLayout;
|
|
masterPreviewViewDraggable.OnDragFinished += UpdateSerializedWindowLayout;
|
|
m_MasterPreviewView.previewResizeBorderFrame.OnResizeFinished += UpdateSerializedWindowLayout;
|
|
|
|
m_GraphView.graphViewChanged = GraphViewChanged;
|
|
|
|
RegisterCallback<GeometryChangedEvent>(ApplySerializewindowLayouts);
|
|
}
|
|
|
|
m_SearchWindowProvider = ScriptableObject.CreateInstance<SearchWindowProvider>();
|
|
m_SearchWindowProvider.Initialize(editorWindow, m_Graph, m_GraphView);
|
|
m_GraphView.nodeCreationRequest = (c) =>
|
|
{
|
|
m_SearchWindowProvider.connectedPort = null;
|
|
SearchWindow.Open(new SearchWindowContext(c.screenMousePosition), m_SearchWindowProvider);
|
|
};
|
|
|
|
m_EdgeConnectorListener = new EdgeConnectorListener(m_Graph, m_SearchWindowProvider);
|
|
|
|
foreach (var node in graph.GetNodes<INode>())
|
|
AddNode(node);
|
|
|
|
foreach (var edge in graph.edges)
|
|
AddEdge(edge);
|
|
|
|
Add(content);
|
|
}
|
|
|
|
void OnSpaceDown(KeyDownEvent evt)
|
|
{
|
|
if(evt.keyCode == KeyCode.Space && !evt.shiftKey && !evt.altKey && !evt.ctrlKey && !evt.commandKey)
|
|
{
|
|
if (graphView.nodeCreationRequest == null)
|
|
return;
|
|
|
|
Vector2 referencePosition;
|
|
referencePosition = evt.imguiEvent.mousePosition;
|
|
Vector2 screenPoint = m_EditorWindow.position.position + referencePosition;
|
|
|
|
graphView.nodeCreationRequest(new NodeCreationContext() { screenMousePosition = screenPoint });
|
|
}
|
|
else if (evt.keyCode == KeyCode.F1)
|
|
{
|
|
if (m_GraphView.selection.OfType<MaterialNodeView>().Count() == 1)
|
|
{
|
|
var nodeView = (MaterialNodeView)graphView.selection.First();
|
|
if(nodeView.node.documentationURL != null)
|
|
System.Diagnostics.Process.Start(nodeView.node.documentationURL);
|
|
}
|
|
}
|
|
}
|
|
|
|
GraphViewChange GraphViewChanged(GraphViewChange graphViewChange)
|
|
{
|
|
if (graphViewChange.edgesToCreate != null)
|
|
{
|
|
foreach (var edge in graphViewChange.edgesToCreate)
|
|
{
|
|
var leftSlot = edge.output.GetSlot();
|
|
var rightSlot = edge.input.GetSlot();
|
|
if (leftSlot != null && rightSlot != null)
|
|
{
|
|
m_Graph.owner.RegisterCompleteObjectUndo("Connect Edge");
|
|
m_Graph.Connect(leftSlot.slotReference, rightSlot.slotReference);
|
|
}
|
|
}
|
|
graphViewChange.edgesToCreate.Clear();
|
|
}
|
|
|
|
if (graphViewChange.movedElements != null)
|
|
{
|
|
foreach (var element in graphViewChange.movedElements)
|
|
{
|
|
var node = element.userData as INode;
|
|
if (node == null)
|
|
continue;
|
|
|
|
var drawState = node.drawState;
|
|
drawState.position = element.GetPosition();
|
|
node.drawState = drawState;
|
|
}
|
|
}
|
|
|
|
var nodesToUpdate = m_NodeViewHashSet;
|
|
nodesToUpdate.Clear();
|
|
|
|
if (graphViewChange.elementsToRemove != null)
|
|
{
|
|
m_Graph.owner.RegisterCompleteObjectUndo("Remove Elements");
|
|
m_Graph.RemoveElements(graphViewChange.elementsToRemove.OfType<MaterialNodeView>().Select(v => (INode) v.node),
|
|
graphViewChange.elementsToRemove.OfType<Edge>().Select(e => (IEdge) e.userData));
|
|
foreach (var edge in graphViewChange.elementsToRemove.OfType<Edge>())
|
|
{
|
|
if (edge.input != null)
|
|
{
|
|
var materialNodeView = edge.input.node as MaterialNodeView;
|
|
if (materialNodeView != null)
|
|
nodesToUpdate.Add(materialNodeView);
|
|
}
|
|
if (edge.output != null)
|
|
{
|
|
var materialNodeView = edge.output.node as MaterialNodeView;
|
|
if (materialNodeView != null)
|
|
nodesToUpdate.Add(materialNodeView);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var node in nodesToUpdate)
|
|
node.UpdatePortInputVisibilities();
|
|
|
|
UpdateEdgeColors(nodesToUpdate);
|
|
|
|
return graphViewChange;
|
|
}
|
|
|
|
void OnNodeChanged(INode inNode, ModificationScope scope)
|
|
{
|
|
if (m_GraphView == null)
|
|
return;
|
|
|
|
var dependentNodes = new List<INode>();
|
|
NodeUtils.CollectNodesNodeFeedsInto(dependentNodes, inNode);
|
|
foreach (var node in dependentNodes)
|
|
{
|
|
var theViews = m_GraphView.nodes.ToList().OfType<MaterialNodeView>();
|
|
var viewsFound = theViews.Where(x => x.node.guid == node.guid).ToList();
|
|
foreach (var drawableNodeData in viewsFound)
|
|
drawableNodeData.OnModified(scope);
|
|
}
|
|
}
|
|
|
|
HashSet<MaterialNodeView> m_NodeViewHashSet = new HashSet<MaterialNodeView>();
|
|
|
|
public void HandleGraphChanges()
|
|
{
|
|
previewManager.HandleGraphChanges();
|
|
previewManager.RenderPreviews();
|
|
m_BlackboardProvider.HandleGraphChanges();
|
|
|
|
foreach (var node in m_Graph.removedNodes)
|
|
{
|
|
node.UnregisterCallback(OnNodeChanged);
|
|
var nodeView = m_GraphView.nodes.ToList().OfType<MaterialNodeView>().FirstOrDefault(p => p.node != null && p.node.guid == node.guid);
|
|
if (nodeView != null)
|
|
{
|
|
nodeView.Dispose();
|
|
nodeView.userData = null;
|
|
m_GraphView.RemoveElement(nodeView);
|
|
}
|
|
}
|
|
|
|
foreach (var node in m_Graph.addedNodes)
|
|
{
|
|
AddNode(node);
|
|
}
|
|
|
|
foreach (var node in m_Graph.pastedNodes)
|
|
{
|
|
var nodeView = m_GraphView.nodes.ToList().OfType<MaterialNodeView>().FirstOrDefault(p => p.node != null && p.node.guid == node.guid);
|
|
m_GraphView.AddToSelection(nodeView);
|
|
}
|
|
|
|
var nodesToUpdate = m_NodeViewHashSet;
|
|
nodesToUpdate.Clear();
|
|
|
|
foreach (var edge in m_Graph.removedEdges)
|
|
{
|
|
var edgeView = m_GraphView.graphElements.ToList().OfType<Edge>().FirstOrDefault(p => p.userData is IEdge && Equals((IEdge)p.userData, edge));
|
|
if (edgeView != null)
|
|
{
|
|
var nodeView = edgeView.input.node as MaterialNodeView;
|
|
if (nodeView != null && nodeView.node != null)
|
|
{
|
|
nodesToUpdate.Add(nodeView);
|
|
}
|
|
edgeView.output.Disconnect(edgeView);
|
|
edgeView.input.Disconnect(edgeView);
|
|
|
|
edgeView.output = null;
|
|
edgeView.input = null;
|
|
|
|
m_GraphView.RemoveElement(edgeView);
|
|
}
|
|
}
|
|
|
|
foreach (var edge in m_Graph.addedEdges)
|
|
{
|
|
var edgeView = AddEdge(edge);
|
|
if (edgeView != null)
|
|
nodesToUpdate.Add((MaterialNodeView)edgeView.input.node);
|
|
}
|
|
|
|
foreach (var node in nodesToUpdate)
|
|
node.UpdatePortInputVisibilities();
|
|
|
|
UpdateEdgeColors(nodesToUpdate);
|
|
}
|
|
|
|
void AddNode(INode node)
|
|
{
|
|
var nodeView = new MaterialNodeView { userData = node };
|
|
m_GraphView.AddElement(nodeView);
|
|
nodeView.Initialize(node as AbstractMaterialNode, m_PreviewManager, m_EdgeConnectorListener);
|
|
node.RegisterCallback(OnNodeChanged);
|
|
nodeView.MarkDirtyRepaint();
|
|
|
|
if (m_SearchWindowProvider.nodeNeedsRepositioning && m_SearchWindowProvider.targetSlotReference.nodeGuid.Equals(node.guid))
|
|
{
|
|
m_SearchWindowProvider.nodeNeedsRepositioning = false;
|
|
foreach (var element in nodeView.inputContainer.Union(nodeView.outputContainer))
|
|
{
|
|
var port = element as ShaderPort;
|
|
if (port == null)
|
|
continue;
|
|
if (port.slot.slotReference.Equals(m_SearchWindowProvider.targetSlotReference))
|
|
{
|
|
port.RegisterCallback<GeometryChangedEvent>(RepositionNode);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void RepositionNode(GeometryChangedEvent evt)
|
|
{
|
|
var port = evt.target as ShaderPort;
|
|
if (port == null)
|
|
return;
|
|
port.UnregisterCallback<GeometryChangedEvent>(RepositionNode);
|
|
var nodeView = port.node as MaterialNodeView;
|
|
if (nodeView == null)
|
|
return;
|
|
var offset = nodeView.mainContainer.WorldToLocal(port.GetGlobalCenter() + new Vector3(3f, 3f, 0f));
|
|
var position = nodeView.GetPosition();
|
|
position.position -= offset;
|
|
nodeView.SetPosition(position);
|
|
var drawState = nodeView.node.drawState;
|
|
drawState.position = position;
|
|
nodeView.node.drawState = drawState;
|
|
nodeView.MarkDirtyRepaint();
|
|
port.MarkDirtyRepaint();
|
|
}
|
|
|
|
Edge AddEdge(IEdge edge)
|
|
{
|
|
var sourceNode = m_Graph.GetNodeFromGuid(edge.outputSlot.nodeGuid);
|
|
if (sourceNode == null)
|
|
{
|
|
Debug.LogWarning("Source node is null");
|
|
return null;
|
|
}
|
|
var sourceSlot = sourceNode.FindOutputSlot<MaterialSlot>(edge.outputSlot.slotId);
|
|
|
|
var targetNode = m_Graph.GetNodeFromGuid(edge.inputSlot.nodeGuid);
|
|
if (targetNode == null)
|
|
{
|
|
Debug.LogWarning("Target node is null");
|
|
return null;
|
|
}
|
|
var targetSlot = targetNode.FindInputSlot<MaterialSlot>(edge.inputSlot.slotId);
|
|
|
|
var sourceNodeView = m_GraphView.nodes.ToList().OfType<MaterialNodeView>().FirstOrDefault(x => x.node == sourceNode);
|
|
if (sourceNodeView != null)
|
|
{
|
|
var sourceAnchor = sourceNodeView.outputContainer.Children().OfType<ShaderPort>().FirstOrDefault(x => x.slot.Equals(sourceSlot));
|
|
|
|
var targetNodeView = m_GraphView.nodes.ToList().OfType<MaterialNodeView>().FirstOrDefault(x => x.node == targetNode);
|
|
var targetAnchor = targetNodeView.inputContainer.Children().OfType<ShaderPort>().FirstOrDefault(x => x.slot.Equals(targetSlot));
|
|
|
|
var edgeView = new Edge
|
|
{
|
|
userData = edge,
|
|
output = sourceAnchor,
|
|
input = targetAnchor
|
|
};
|
|
edgeView.output.Connect(edgeView);
|
|
edgeView.input.Connect(edgeView);
|
|
m_GraphView.AddElement(edgeView);
|
|
sourceNodeView.RefreshPorts();
|
|
targetNodeView.RefreshPorts();
|
|
sourceNodeView.UpdatePortInputTypes();
|
|
targetNodeView.UpdatePortInputTypes();
|
|
|
|
return edgeView;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
Stack<MaterialNodeView> m_NodeStack = new Stack<MaterialNodeView>();
|
|
|
|
void UpdateEdgeColors(HashSet<MaterialNodeView> nodeViews)
|
|
{
|
|
var nodeStack = m_NodeStack;
|
|
nodeStack.Clear();
|
|
foreach (var nodeView in nodeViews)
|
|
nodeStack.Push(nodeView);
|
|
while (nodeStack.Any())
|
|
{
|
|
var nodeView = nodeStack.Pop();
|
|
nodeView.UpdatePortInputTypes();
|
|
foreach (var anchorView in nodeView.outputContainer.Children().OfType<Port>())
|
|
{
|
|
foreach (var edgeView in anchorView.connections.OfType<Edge>())
|
|
{
|
|
var targetSlot = edgeView.input.GetSlot();
|
|
if (targetSlot.valueType == SlotValueType.DynamicVector || targetSlot.valueType == SlotValueType.DynamicMatrix || targetSlot.valueType == SlotValueType.Dynamic)
|
|
{
|
|
var connectedNodeView = edgeView.input.node as MaterialNodeView;
|
|
if (connectedNodeView != null && !nodeViews.Contains(connectedNodeView))
|
|
{
|
|
nodeStack.Push(connectedNodeView);
|
|
nodeViews.Add(connectedNodeView);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
foreach (var anchorView in nodeView.inputContainer.Children().OfType<Port>())
|
|
{
|
|
var targetSlot = anchorView.GetSlot();
|
|
if (targetSlot.valueType != SlotValueType.DynamicVector)
|
|
continue;
|
|
foreach (var edgeView in anchorView.connections.OfType<Edge>())
|
|
{
|
|
var connectedNodeView = edgeView.output.node as MaterialNodeView;
|
|
if (connectedNodeView != null && !nodeViews.Contains(connectedNodeView))
|
|
{
|
|
nodeStack.Push(connectedNodeView);
|
|
nodeViews.Add(connectedNodeView);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandleEditorViewChanged(GeometryChangedEvent evt)
|
|
{
|
|
m_BlackboardProvider.blackboard.layout = m_FloatingWindowsLayout.blackboardLayout.GetLayout(m_GraphView.layout);
|
|
}
|
|
|
|
void StoreBlackboardLayoutOnGeometryChanged(GeometryChangedEvent evt)
|
|
{
|
|
UpdateSerializedWindowLayout();
|
|
}
|
|
|
|
void ApplySerializewindowLayouts(GeometryChangedEvent evt)
|
|
{
|
|
UnregisterCallback<GeometryChangedEvent>(ApplySerializewindowLayouts);
|
|
|
|
if (m_FloatingWindowsLayout != null)
|
|
{
|
|
// Restore master preview layout
|
|
m_FloatingWindowsLayout.previewLayout.ApplyPosition(m_MasterPreviewView);
|
|
m_MasterPreviewView.previewTextureView.style.width = StyleValue<float>.Create(m_FloatingWindowsLayout.masterPreviewSize.x);
|
|
m_MasterPreviewView.previewTextureView.style.height = StyleValue<float>.Create(m_FloatingWindowsLayout.masterPreviewSize.y);
|
|
|
|
// Restore blackboard layout, and make sure that it remains in the view.
|
|
Rect blackboardRect = m_FloatingWindowsLayout.blackboardLayout.GetLayout(this.layout);
|
|
|
|
// Make sure the dimensions are sufficiently large.
|
|
blackboardRect.width = Mathf.Clamp(blackboardRect.width, 160f, m_GraphView.contentContainer.layout.width);
|
|
blackboardRect.height = Mathf.Clamp(blackboardRect.height, 160f, m_GraphView.contentContainer.layout.height);
|
|
|
|
// Make sure that the positionining is on screen.
|
|
blackboardRect.x = Mathf.Clamp(blackboardRect.x, 0f, Mathf.Max(1f, m_GraphView.contentContainer.layout.width - blackboardRect.width - blackboardRect.width));
|
|
blackboardRect.y = Mathf.Clamp(blackboardRect.y, 0f, Mathf.Max(1f, m_GraphView.contentContainer.layout.height - blackboardRect.height - blackboardRect.height));
|
|
|
|
// Set the processed blackboard layout.
|
|
m_BlackboardProvider.blackboard.layout = blackboardRect;
|
|
|
|
previewManager.ResizeMasterPreview(m_FloatingWindowsLayout.masterPreviewSize);
|
|
}
|
|
else
|
|
{
|
|
m_FloatingWindowsLayout = new FloatingWindowsLayout();
|
|
}
|
|
|
|
// After the layout is restored from the previous session, start tracking layout changes in the blackboard.
|
|
m_BlackboardProvider.blackboard.RegisterCallback<GeometryChangedEvent>(StoreBlackboardLayoutOnGeometryChanged);
|
|
|
|
// After the layout is restored, track changes in layout and make the blackboard have the same behavior as the preview w.r.t. docking.
|
|
RegisterCallback<GeometryChangedEvent>(HandleEditorViewChanged);
|
|
}
|
|
|
|
void UpdateSerializedWindowLayout()
|
|
{
|
|
if (m_FloatingWindowsLayout == null)
|
|
m_FloatingWindowsLayout = new FloatingWindowsLayout();
|
|
|
|
m_FloatingWindowsLayout.previewLayout.CalculateDockingCornerAndOffset(m_MasterPreviewView.layout, m_GraphView.layout);
|
|
m_FloatingWindowsLayout.previewLayout.ClampToParentWindow();
|
|
|
|
m_FloatingWindowsLayout.blackboardLayout.CalculateDockingCornerAndOffset(m_BlackboardProvider.blackboard.layout, m_GraphView.layout);
|
|
m_FloatingWindowsLayout.blackboardLayout.ClampToParentWindow();
|
|
|
|
if (m_MasterPreviewView.expanded)
|
|
{
|
|
m_FloatingWindowsLayout.masterPreviewSize = m_MasterPreviewView.previewTextureView.layout.size;
|
|
}
|
|
|
|
string serializedWindowLayout = JsonUtility.ToJson(m_FloatingWindowsLayout);
|
|
EditorUserSettings.SetConfigValue(k_FloatingWindowsLayoutKey, serializedWindowLayout);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
if (m_GraphView != null)
|
|
{
|
|
saveRequested = null;
|
|
convertToSubgraphRequested = null;
|
|
showInProjectRequested = null;
|
|
foreach (var node in m_GraphView.Children().OfType<MaterialNodeView>())
|
|
node.Dispose();
|
|
m_GraphView = null;
|
|
}
|
|
if (previewManager != null)
|
|
{
|
|
previewManager.Dispose();
|
|
previewManager = null;
|
|
}
|
|
if (m_SearchWindowProvider != null)
|
|
{
|
|
Object.DestroyImmediate(m_SearchWindowProvider);
|
|
m_SearchWindowProvider = null;
|
|
}
|
|
}
|
|
}
|
|
}
|