public INodeModel CreateStackedNode(Type nodeTypeToCreate, string nodeName = "", int index = -1, SpawnFlags spawnFlags = SpawnFlags.Default, Action <NodeModel> preDefineSetup = null, GUID?guid = null)
{
SpawnFlags createNodeFlags = (spawnFlags & SpawnFlags.CreateNodeAsset) | SpawnFlags.Orphan; // we don't want to CreateNode to add the node to the graph nor to register undo
var graphModel = (GraphModel)GraphModel;
NodeModel nodeModel = (NodeModel)graphModel.CreateNodeInternal(nodeTypeToCreate, nodeName, Vector2.zero, createNodeFlags, preDefineSetup, guid);
graphModel.RegisterNodeGuid(nodeModel);
if (!spawnFlags.IsOrphan())
{
if (spawnFlags.IsUndoable())
{
Undo.RegisterCreatedObjectUndo(nodeModel.NodeAssetReference, "Create Node");
Undo.RegisterCompleteObjectUndo(NodeAssetReference, "Add Node");
AddStackedNode(nodeModel, index);
EditorUtility.SetDirty(NodeAssetReference);
}
else
{
AddStackedNode(nodeModel, index);
}
}
nodeModel.DefineNode();
return(nodeModel);
}
public INodeModel CreateStackedNode(Type nodeTypeToCreate, string nodeName = "", int index = -1, SpawnFlags spawnFlags = SpawnFlags.Default, Action <NodeModel> preDefineSetup = null)
{
if (nodeTypeToCreate == null)
{
throw new InvalidOperationException("Cannot create node with a null type");
}
NodeModel nodeModel;
if (spawnFlags.IsSerializable())
{
nodeModel = (NodeModel)SpawnNodeAsset(nodeTypeToCreate).Model;
}
else
{
nodeModel = (NodeModel)Activator.CreateInstance(nodeTypeToCreate);
}
nodeModel.Title = nodeName ?? nodeTypeToCreate.Name;
nodeModel.Position = Vector2.zero;
nodeModel.GraphModel = GraphModel;
nodeModel.ParentStackModel = this;
preDefineSetup?.Invoke(nodeModel);
nodeModel.DefineNode();
if (!spawnFlags.IsOrphan())
{
if (spawnFlags.IsUndoable())
{
Undo.RegisterCreatedObjectUndo(nodeModel.NodeAssetReference, "Create Node");
AddStackedNode(nodeModel, index);
}
else
{
AddStackedNodeNoUndo(nodeModel, index);
}
}
return(nodeModel);
AbstractNodeAsset SpawnNodeAsset(Type typeToSpawn)
{
var genericNodeAssetType = typeof(NodeAsset <>).MakeGenericType(typeToSpawn);
var derivedTypes = TypeCache.GetTypesDerivedFrom(genericNodeAssetType);
if (derivedTypes.Count == 0)
{
throw new InvalidOperationException($"No NodeAssets of type NodeAsset<{typeToSpawn.Name}>");
}
Assert.AreEqual(derivedTypes.Count, 1,
$"Multiple NodeAssets of type NodeAsset<{typeToSpawn.Name}> have been found");
return(ScriptableObject.CreateInstance(derivedTypes[0]) as AbstractNodeAsset);
}
}
#pragma warning restore CS0649
#pragma warning restore CS0414
void CreateNodesAndValidateGraphModel(GraphNodeModelSearcherItem item, SpawnFlags mode,
Action <List <INodeModel> > assertNodesCreation)
{
var initialNodes = GraphModel.NodeModels.ToList();
var initialEdges = GraphModel.EdgeModels.ToList();
item.CreateElements.Invoke(new GraphNodeCreationData(GraphModel, Vector2.zero, mode));
// If nodes are created as Orphan, graphModel should not be modified
if (mode.IsOrphan())
{
CollectionAssert.AreEqual(initialNodes, GraphModel.NodeModels);
CollectionAssert.AreEqual(initialEdges, GraphModel.EdgeModels);
return;
}
assertNodesCreation.Invoke(initialNodes);
}
void CreateNodesAndValidateStackModel(StackNodeModelSearcherItem item, SpawnFlags mode,
Action <List <INodeModel>, IStackModel> assertNodesCreation)
{
var stack = GraphModel.CreateStack("stack", Vector2.zero);
var initialGraphNodes = GraphModel.NodeModels.ToList();
item.CreateElements.Invoke(new StackNodeCreationData(stack, -1, spawnFlags: mode));
// If nodes are created as Orphan, graphModel and stackModel should not be modified
if (mode.IsOrphan())
{
Assert.AreEqual(stack.NodeModels.Count(), 0);
CollectionAssert.AreEqual(initialGraphNodes, GraphModel.NodeModels);
return;
}
assertNodesCreation.Invoke(initialGraphNodes, stack);
}
