public void InitBasicGraph(VSGraphModel graph)
{
Stencil stencil = graph.Stencil;
AssetDatabase.SaveAssets();
var method = graph.CreateFunction("method", Vector2.left * 200);
method.CreateFunctionVariableDeclaration("l", typeof(int).GenerateTypeHandle(stencil));
method.CreateFunctionParameterDeclaration("a", typeof(int).GenerateTypeHandle(stencil));
var log = method.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true));
var abs = graph.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Mathf), "Abs", true), new Vector2(-350, 100));
graph.CreateEdge(log.GetParameterPorts().First(), abs.OutputPort);
var xDecl = graph.CreateGraphVariableDeclaration("x", typeof(float).GenerateTypeHandle(stencil), true);
var xUsage = graph.CreateVariableNode(xDecl, new Vector2(-450, 100));
graph.CreateEdge(abs.GetParameterPorts().First(), xUsage.OutputPort);
var stack001 = graph.CreateStack(string.Empty, new Vector2(-200, 300));
stack001.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), "Log", true));
var method2 = graph.CreateFunction("method2", Vector2.left * 800);
method2.CreateFunctionRefCallNode(method);
}
static State AddToGroupNode(State previousState, AddToGroupNodeAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
//TODO: Clean previous group
// Get only the items that are not in the "new" group
List <INodeModel> nodesToGroup = action.NodeModels.Where(m => m.GroupNodeModel != action.GroupNodeModel).ToList();
// And remove the nodes from their previous group
RemoveFromGroupNode(nodesToGroup);
var nodesToStack = new List <INodeModel>();
foreach (NodeModel nodeModel in nodesToGroup.OfType <NodeModel>().Where(n => n.IsStacked))
{
nodeModel.GroupNodeModel = null;
nodesToStack.Add(nodeModel);
}
if (nodesToStack.Any())
{
var stack = graphModel.CreateStack(string.Empty, action.NewStackPosition);
stack.MoveStackedNodes(nodesToStack, 0);
nodesToGroup.Add(stack);
}
// Exclude all the nodes that were put into the new stack from the list of nodes to add.
((GroupNodeModel)action.GroupNodeModel).AddNodes(nodesToGroup.Except(nodesToStack));
return(previousState);
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Move Stacked Node(s)");
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
static State SplitStack(State previousState, SplitStackAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
Undo.RegisterCompleteObjectUndo((Object)graphModel.AssetModel, "Move stacked nodes");
if (action.SplitIndex > 0 && action.SplitIndex < action.StackModel.NodeModels.Count())
{
// Get the list of nodes to move to another stack.
var nodeModels = action.StackModel.NodeModels.Skip(action.SplitIndex).ToList();
if (nodeModels.Any())
{
// Get old stack (stack A)
var stackA = action.StackModel;
// Create new stack (stack B).
var stackB = graphModel.CreateStack(((NodeModel)stackA).Title + "_split", stackA.Position + Vector2.up * 300);
// Move the list of nodes to this new stack.
stackB.MoveStackedNodes(nodeModels, 0);
// if the stack had a condition node or anything providing the actual port models, we need to move
// the nodes BEFORE fetching the port models, as stack.portModels will actually return the condition
// port models
var stackAOutputPortModel = stackA.OutputPorts.First();
var stackBInputPortModel = stackB.InputPorts.First();
var stackBOutputPortModel = stackB.OutputPorts.First();
// Connect the edges that were connected to the old stack to the new one.
var previousEdgeConnections = graphModel.GetEdgesConnections(stackAOutputPortModel).ToList();
foreach (var edge in previousEdgeConnections)
{
graphModel.CreateEdge(edge.InputPortModel, stackBOutputPortModel);
graphModel.DeleteEdge(edge);
}
// Connect the new stack with the old one.
IEdgeModel newEdge = graphModel.CreateEdge(stackBInputPortModel, stackAOutputPortModel);
graphModel.LastChanges.ChangedElements.Add(stackA);
graphModel.LastChanges.ModelsToAutoAlign.Add(newEdge);
}
}
return(previousState);
}
static State CreateStacksForNodes(State previousState, CreateStacksForNodesAction action)
{
VSGraphModel graphModel = (VSGraphModel)previousState.CurrentGraphModel;
var affectedStacks = action.Stacks.SelectMany(stackOption => stackOption.NodeModels).OfType <NodeModel>()
.Select(model => model.ParentStackModel).Distinct();
foreach (var stack in affectedStacks)
{
Undo.RegisterCompleteObjectUndo(stack.NodeAssetReference, "Move Stacked Node(s)");
}
foreach (var stackOptions in action.Stacks)
{
var stack = graphModel.CreateStack(string.Empty, stackOptions.Position);
if (stackOptions.NodeModels != null)
{
stack.MoveStackedNodes(stackOptions.NodeModels, 0);
}
}
return(previousState);
}
