public static UniGraphEditor Create(UniGraph uniGraph)
{
var graph = CreateInstance <UniGraphEditor>();
graph.Initialize(uniGraph);
return(graph);
}
public static UniGameFlowWindow Open(UniGraph graph)
{
var window = CreateWindow(graph);
window.Show();
return(window);
}
public static void Show(UniGraph graph)
{
var window = GetWindow <UnityGraphWindow>(graph.name);
window.Initialize(graph);
window.Show();
}
public void Open(UniGraph graph)
{
if (graph == null)
{
return;
}
_graph = graph;
_activeGraphName = _graph.name;
GUILayout.Space(10);
GUILayout.BeginHorizontal();
GUILayout.BeginVertical();
if (GUILayout.Button("Show Graph(obsolete)", GUILayout.Height(26)))
{
NodeEditorWindow.Open(graph);
}
if (GUILayout.Button("Show Graph", GUILayout.Height(26)))
{
UniGameFlowWindow.Open(graph);
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.Space(10);
}
public static UniGameFlowWindow CreateWindow(UniGraph graph)
{
var window = SelectWindow(graph);
window.Initialize(graph);
return(window);
}
public void Initialize(UniGraph uniGraph)
{
_targetGraph = uniGraph;
_graphId = uniGraph.id;
_guid = uniGraph.Guid;
Reload();
}
private void CreateNodes(UniGraph uniGraph)
{
foreach (var graphNode in uniGraph.Nodes)
{
var editorNode = UnityGraphUniNode.Create(graphNode);
_uniNodes.Add(editorNode);
AddNode(editorNode);
}
}
public static UniGameFlowWindow SelectWindow(UniGraph graph)
{
var window = windows.FirstOrDefault(x => x.titleContent.text == graph.name && x.IsEmpty);
window = window ?? windows.FirstOrDefault(x => x.IsEmpty);
window = window ?? CreateInstance <UniGameFlowWindow>();
return(window);
}
public override void OnEnable()
{
base.OnEnable();
graph = Node as UniGraph;
if (Application.isPlaying == false)
{
graph?.Validate();
}
}
private void InitializeGraph(UniGraph uniGraph)
{
if (!AssetEditorTools.IsPureEditorMode)
{
return;
}
uniGraph.Initialize();
uniGraph.Validate();
}
public void Initialize(INode node, UniGraph ownerGraph)
{
sourceId = node.Id;
nodeName = node.ItemName;
sourceGraph = ownerGraph;
nodeSubject.Value = node;
position = new Rect(node.Position, new Vector2(node.Width, 100));
UpdatePorts();
}
public static void Select(UniGraph uniGraph)
{
var window = UniGameFlowWindow.Windows.
FirstOrDefault(x => x.IsEmpty);
if (window == null)
{
return;
}
window.Initialize(uniGraph);
}
private async UniTask LaunchGraph(UniGraph graph, IDisposableContext context)
{
if (awaitGraph)
{
await graph.ExecuteAsync(context);
}
else
{
graph.ExecuteAsync(context)
.AttachExternalCancellation(LifeTime.TokenSource)
.Forget();
}
}
/// <summary>
/// Prints the graph.
/// </summary>
/// <param name="e">Arguments of event</param>
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (!Visible)
{
return;
}
SetGraphConfiguration();
if (!ReadOnly)
{
UniGraph.RegisterService(ServiceUrl);
}
}
public static IEnumerable <INode> ConvertNodes(UniGraph graph, UniGraphAsset graphAsset)
{
var nodes = graphAsset.nodes;
foreach (var node in nodes)
{
if (node is UniBaseNode)
{
continue;
}
var bufferNode = new GraphProcessorNode(graph, node);
yield return(bufferNode);
}
}
public virtual UniGraphAsset CreateAssetGraph(UniGraph uniGraph)
{
if (Application.isPlaying == false)
{
InitializeGraph(uniGraph);
}
_graphName = uniGraph.name;
var graphAsset = uniGraph.useVariants
? CreateInstance <UniGraphAsset>()
: uniGraph.serializedGraph;
if (!graphAsset && Application.isPlaying == false)
{
graphAsset = CreateInstance <UniGraphAsset>();
uniGraph.serializedGraph = graphAsset;
graphAsset.SaveAssetAsNested(uniGraph.gameObject);
uniGraph.gameObject.MarkDirty();
}
graphAsset.name = _graphName;
if (AssetGraph && uniGraph.name == _graphName)
{
graphAsset.position = AssetGraph.position;
graphAsset.scale = AssetGraph.scale;
}
var sourceGraph = uniGraph;
if (!uniGraph.useVariants)
{
var stage = PrefabStageUtility.GetPrefabStage(uniGraph.gameObject);
if (Application.isPlaying == false && stage != null && !string.IsNullOrEmpty(stage.assetPath))
{
var asset = AssetDatabase.LoadAssetAtPath <GameObject>(stage.assetPath);
sourceGraph = asset.GetComponent <UniGraph>();
}
}
AssetGraph = graphAsset;
AssetGraph.ConnectToGraph(sourceGraph);
return(AssetGraph);
}
private void SaveGroupInfo(UniGraph graphData)
{
graphData.nodeGroups.Clear();
foreach (var groupView in groupViews)
{
var groupData = groupView.group;
var groupInfo = new NodesGroup()
{
color = groupData.color,
position = groupData.position,
size = groupData.size,
title = groupData.title,
nodeIds = GetNodesIdsByGuid(groupData.innerNodeGUIDs),
};
graphData.nodeGroups.Add(groupInfo);
}
}
private void UpdateCache(UniGraph sourceGraph)
{
var sourceObject = new SerializedObject(sourceGraph);
var serializableNodesProperty = sourceObject.
FindProperty(nameof(sourceGraph.serializableNodes));
var assetNodesProperty = sourceObject.
FindProperty(nameof(sourceGraph.nodes));
var serializableNodes = sourceObject.
GetEditorNodes(serializableNodesProperty, sourceGraph.serializableNodes);
var assetNodes = sourceObject.
GetEditorNodes(assetNodesProperty, sourceGraph.nodes);
foreach (var data in serializableNodes.Concat(assetNodes))
{
nodeDataCache[data.Node] = data;
}
}
private void CreateGroupViews(UniGraph graphData)
{
graphData.nodeGroups.RemoveAll(x => x == null);
foreach (var group in graphData.nodeGroups)
{
var title = string.IsNullOrEmpty(group.Title) ? string.Empty : group.Title;
var groupData = new Group(title, group.Size)
{
color = group.Color,
position = group.Position,
innerNodeGUIDs = nodeViews.
OfType <UniNodeView>().
Where(x => group.NodeIds.Contains(x.Id)).
Select(x => x.Guid).
ToList()
};
AddGroup(groupData);
}
}
public virtual UniAssetGraph CreateAssetGraph(UniGraph uniGraph)
{
if (Application.isPlaying == false)
{
InitializeGraph(uniGraph);
}
var graphAsset = ScriptableObject.CreateInstance <UniAssetGraph>();
if (AssetGraph && uniGraph.name == _graphName)
{
graphAsset.position = AssetGraph.position;
graphAsset.scale = AssetGraph.scale;
}
_graphName = uniGraph == null ? string.Empty : uniGraph.name;
graphAsset.name = _graphName;
AssetGraph = graphAsset;
AssetGraph.Activate(uniGraph);
return(AssetGraph);
}
private void SaveStackNodeInfo(UniGraph graphData)
{
foreach (var groupView in stackNodeViews)
{
}
}
public void Initialize(UniGraph uniGraph, UniGraphEditor graphEditor)
{
_uniGraph = uniGraph;
graph = graphEditor;
}
public void ConnectToGraph(UniGraph graph)
{
sourceGraph = graph;
//update dynamic graph ports
UpdateGraph();
}
public void Activate(UniGraph graph)
{
sourceGraph = graph;
//update dynamic graph ports
UpdateGraph();
}
public void Initialize(UniGraph uniGraph)
{
_uniGraph = uniGraph;
CreateNodes(_uniGraph);
}
public void Initialize(UniGraph graph)
{
_graphEditor = UniGraphEditor.Create(graph);
_graphGuiEditor = _graphEditor.GetEditor();
}
public GraphProcessorNode(UniGraph graph, BaseNode node)
{
this.graph = graph;
this.node = node;
}
