public void Init()
{
_graph = new GraphModel();
_user1 = _graph.CreateNode("user");
var user2 = _graph.CreateNode("user");
var tweet = _graph.CreateNode("tweet");
_graph.CreateEdge(_user1, tweet, "tweeted");
_graph.CreateEdge(user2, tweet, "retweeted");
_graph.CreateEdge(_user1, user2, "followed");
_graph.CreateEdge(_user1, _user1, "followed");
}
public void Init()
{
_graph = new GraphModel();
_user1 = _graph.CreateNode("user");
var user2 = _graph.CreateNode("user");
var tweet = _graph.CreateNode("tweet");
_graph.CreateEdge(_user1, tweet, "tweeted");
_graph.CreateEdge(user2, tweet, "retweeted");
_graph.CreateEdge(_user1, user2, "followed");
_graph.CreateEdge(_user1, _user1, "followed");
}
public IEnumerator PanToNodeChangesViewTransform()
{
var operatorModel = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-100, -100));
var nodeA = GraphModel.CreateNode <Type0FakeNodeModel>("A", Vector2.zero);
var nodeB = GraphModel.CreateNode <Type0FakeNodeModel>("B", new Vector2(100, 100));
CommandDispatcher.Dispatch(new ReframeGraphViewCommand(Vector3.zero, Vector3.one));
yield return(null);
yield return(SendPanToNodeAndRefresh(operatorModel));
yield return(SendPanToNodeAndRefresh(nodeA));
yield return(SendPanToNodeAndRefresh(nodeB));
IEnumerator SendPanToNodeAndRefresh(NodeModel nodeModel)
{
var node = nodeModel.GetUI <GraphElement>(GraphView);
Vector3 pOrig = GraphView.ContentViewContainer.transform.position;
GraphView.DispatchFrameAndSelectElementsCommand(true, node);
yield return(null);
Vector3 p = GraphView.ContentViewContainer.transform.position;
Assert.AreNotEqual(pOrig, p, "ViewTransform position did not change");
Assert.That(GraphView.GetSelection().
Where(n => ReferenceEquals(n, nodeModel)).Any,
() =>
{
var graphViewSelection = String.Join(",", GraphView.GetSelection());
return($"Selection doesn't contain {nodeModel} {nodeModel.Title} but {graphViewSelection}");
});
}
}
public void Test_SplitEdgeAndInsertNodeCommand([Values] TestingMode mode)
{
var constant = GraphModel.CreateConstantNode(typeof(int).GenerateTypeHandle(), "Constant", Vector2.zero);
var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var binary1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
GraphModel.CreateEdge(binary0.Input0, constant.OutputPort);
TestPrereqCommandPostreq(mode,
() =>
{
RefreshReference(ref constant);
RefreshReference(ref binary0);
RefreshReference(ref binary1);
var edge = GetEdge(0);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(binary0.Input0, Is.ConnectedTo(constant.OutputPort));
return(new SplitEdgeAndInsertExistingNodeCommand(edge, binary1));
},
() =>
{
RefreshReference(ref constant);
RefreshReference(ref binary0);
RefreshReference(ref binary1);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(binary1.Input0, Is.ConnectedTo(constant.OutputPort));
Assert.That(binary0.Input0, Is.ConnectedTo(binary1.Output0));
});
}
public void DataPortDoesNotConnectToExecutionPort()
{
var node1 = GraphModel.CreateNode <NodeType1>("test1", Vector2.zero);
var node2 = GraphModel.CreateNode <NodeType4>("test2", 100 * Vector2.right);
Assert.IsNull(node2.GetPortFitToConnectTo(node1.DataOut0));
}
public void Test_CreateNodeFromOutputPort_NoConnection(TestingMode testingMode)
{
var db = new GraphElementSearcherDatabase(Stencil).AddMethods(typeof(Vector2),
BindingFlags.Static | BindingFlags.Public).Build();
var item = (GraphNodeModelSearcherItem)db.Search("distance", out _).First();
var node0 = GraphModel.CreateNode <Type1FakeNodeModel>("Node0", Vector2.zero);
var output0 = node0.Output;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
var newNode = GetNode(1);
Assert.That(newNode, Is.TypeOf <FunctionCallNodeModel>());
var portModel = node0.OutputsByDisplayOrder.First();
Assert.That(portModel.ConnectionPortModels.Count(), Is.EqualTo(0));
});
}
public void OneGroupIterationSystem_SharedAndRegularComponents([Values(CodeGenMode.NoJobs)] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
var query = GraphModel.CreateComponentQuery("query");
var positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
var renderType = typeof(RenderMesh).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, renderType, ComponentDefinitionFlags.Shared);
var queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
var onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
var posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
var renderComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == renderType), Vector2.zero);
var logTranslation = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
var logRenderMesh = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 1);
GraphModel.CreateEdge(logTranslation.GetParameterPorts().First(), posComponent.OutputPort);
GraphModel.CreateEdge(logRenderMesh.GetParameterPorts().First(), renderComponent.OutputPort);
},
(manager, entityIndex, e) =>
{
manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
});
manager.AddSharedComponentData(e, new RenderMesh());
},
(manager, entityIndex, e) => Assert.Pass());
}
public IEnumerator RefreshUIPreservesSelection()
{
var nodeA = GraphModel.CreateNode <Type0FakeNodeModel>("A", new Vector2(100, -100));
var nodeB = GraphModel.CreateNode <Type0FakeNodeModel>("B", new Vector2(100, 100));
MarkGraphViewStateDirty();
yield return(null);
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, nodeA));
yield return(SendPanToNodeAndRefresh(nodeA));
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, nodeB));
yield return(SendPanToNodeAndRefresh(nodeB));
IEnumerator SendPanToNodeAndRefresh(NodeModel nodeModel)
{
yield return(null);
Assert.That(GraphView.GetSelection().
Where(n => ReferenceEquals(n, nodeModel)).Any,
() =>
{
var graphViewSelection = String.Join(",", GraphView.GetSelection().Select(x =>
x.ToString()));
return($"Selection doesn't contain {nodeModel} {nodeModel.Title} but {graphViewSelection}");
});
}
}
public void DefinePortsInNewOrderReusesExistingPorts()
{
var node = GraphModel.CreateNode <PortOrderTestNodeModel>("test", Vector2.zero);
node.MakePortsFromNames(new List <string> {
"A", "B", "C"
});
node.DefineNode();
Assert.That(node.InputsById.Count, Is.EqualTo(3));
var A = node.InputsById["A"];
var B = node.InputsById["B"];
var C = node.InputsById["C"];
Assert.That(A, Is.Not.Null);
Assert.That(B, Is.Not.Null);
Assert.That(C, Is.Not.Null);
Assert.That(node.IsSorted, Is.True);
node.RandomizePorts();
Assert.That(node.IsSorted, Is.False);
node.DefineNode();
Assert.That(node.InputsById.Count, Is.EqualTo(3));
Assert.That(ReferenceEquals(A, node.InputsById["A"]), Is.True);
Assert.That(ReferenceEquals(B, node.InputsById["B"]), Is.True);
Assert.That(ReferenceEquals(C, node.InputsById["C"]), Is.True);
}
public void Test_DeleteElementsAction_MiniGraph([Values] TestingMode mode)
{
var method = GraphModel.CreateFunction("TestFunction", Vector2.zero);
var node0 = method.CreateStackedNode <Type0FakeNodeModel>("Fake0", 0);
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero);
GraphModel.CreateEdge(node0.Input0, node1.Output0);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetStackCount(), Is.EqualTo(1));
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var n0 = GetStackedNode(0, 0) as Type0FakeNodeModel;
var n1 = GetNode(1) as Type0FakeNodeModel;
Assert.NotNull(n0);
Assert.NotNull(n1);
Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0));
return(new DeleteElementsAction(method, node0, node1));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(0));
Assert.That(GetStackCount(), Is.EqualTo(0));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
});
}
public void Test_ChangeNodeColorCommand_Capabilities([Values] TestingMode mode)
{
var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
var node2 = GraphModel.CreateNode <Type0FakeNodeModel>("Node2", Vector2.zero);
var node3 = GraphModel.CreateNode <Type0FakeNodeModel>("Node3", Vector2.zero);
node1.SetCapability(Capabilities.Colorable, false);
TestPrereqCommandPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(Get(node0).Color, Is.EqualTo(Color.clear));
Assert.That(Get(node1).Color, Is.EqualTo(Color.clear));
Assert.That(Get(node2).Color, Is.EqualTo(Color.clear));
Assert.That(Get(node3).Color, Is.EqualTo(Color.clear));
return(new ChangeElementColorCommand(Color.red, node0, node1, node2));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(4));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(Get(node0).Color, Is.EqualTo(Color.red));
Assert.That(Get(node1).Color, Is.EqualTo(Color.clear));
Assert.That(Get(node2).Color, Is.EqualTo(Color.red));
Assert.That(Get(node3).Color, Is.EqualTo(Color.clear));
});
}
public void TestRandomNodeModelAllowsVariousTypes([Values] RandomSupportedTypes randomType, [Values] RandomNodeModel.ParamVariant variant)
{
GUID nodeGuid = GUID.Generate();
TestPrereqActionPostreq(TestingMode.Action, () =>
{
var n = GraphModel.CreateNode <RandomNodeModel>(RandomNodeModel.MakeTitle(RandomNodeModel.DefaultMethod), preDefineSetup: m =>
{
m.Variant = variant;
m.MethodBaseName = randomType.ToString();
}, guid: nodeGuid);
Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(1));
return(new RefreshUIAction(UpdateFlags.All));
}, () =>
{
Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(1));
Assert.That(GraphModel.NodesByGuid.TryGetValue(nodeGuid, out var n), Is.True);
var rng = n as RandomNodeModel;
Assert.That(rng, Is.Not.Null);
Assert.That(rng.RngMethod.Name, Does.EndWith(randomType.ToString()));
int expectedParams = 0;
if (randomType != RandomSupportedTypes.Bool && variant != RandomNodeModel.ParamVariant.NoParameters)
{
expectedParams = variant == RandomNodeModel.ParamVariant.Max ? 1 : 2;
}
Assert.That(rng.RngMethod.GetParameters().Length, Is.EqualTo(expectedParams));
});
public void Test_CreateNodeFromOutputPort(TestingMode testingMode, GroupingMode groupingMode)
{
var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("add", out _).First();
var inGroupTest = groupingMode == GroupingMode.Grouped;
var node0 = GraphModel.CreateNode <Type1FakeNodeModel>("Node0", Vector2.zero);
var output0 = node0.Output;
var group = inGroupTest ? GraphModel.CreateGroupNode(string.Empty, Vector2.zero) : null;
TestPrereqActionPostreq(testingMode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 2 : 1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item, null, group));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(inGroupTest ? 3 : 2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newNode = GetNode(inGroupTest ? 2 : 1);
Assert.That(newNode, Is.TypeOf <BinaryOperatorNodeModel>());
Assert.That(newNode.IsGrouped, Is.EqualTo(inGroupTest));
Assert.That(newNode.GroupNodeModel, Is.EqualTo(group));
var portModel = node0.Output;
Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(newNode.InputsByDisplayOrder.First()));
});
}
public IEnumerator CollapsibleNodeCollapsesOnClick()
{
var nodeModel = GraphModel.CreateNode <IONodeModel>();
// Add a port to make the node collapsible.
nodeModel.AddInputPort("port", PortType.Data, TypeHandle.Void, null, PortOrientation.Horizontal, PortModelOptions.NoEmbeddedConstant);
MarkGraphViewStateDirty();
yield return(null);
var node = nodeModel.GetUI <GraphElement>(GraphView);
var collapseButton = node.SafeQ <CollapseButton>(CollapsibleInOutNode.collapseButtonPartName);
Assert.IsNotNull(collapseButton);
Assert.IsFalse(collapseButton.value);
Assert.IsFalse(nodeModel.Collapsed);
var clickPosition = collapseButton.parent.LocalToWorld(collapseButton.layout.center);
// Move the mouse over to make the button appear.
EventHelper.MouseMoveEvent(new Vector2(0, 0), clickPosition);
EventHelper.MouseMoveEvent(clickPosition, clickPosition + Vector2.down);
EventHelper.Click(clickPosition);
yield return(null);
Assert.IsTrue(nodeModel.Collapsed);
}
public IEnumerator DuplicateNodeAndEdgeCreatesEdgeToOriginalNode()
{
var declaration0 = GraphModel.CreateGraphVariableDeclaration(typeof(int).GenerateTypeHandle(), "decl0", ModifierFlags.None, true);
var nodeA = GraphModel.CreateVariableNode(declaration0, new Vector2(100, -100));
var nodeB = GraphModel.CreateNode <Type0FakeNodeModel>("A", new Vector2(100, 100));
var edge = GraphModel.CreateEdge(nodeB.Input0, nodeA.OutputPort) as EdgeModel;
MarkGraphViewStateDirty();
yield return(null);
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, new GraphElementModel[] { nodeB, edge }));
GraphView.Focus();
using (var evt = ExecuteCommandEvent.GetPooled("Duplicate"))
{
evt.target = GraphView;
GraphView.SendEvent(evt);
}
yield return(null);
Assert.AreEqual(3, GraphModel.NodeModels.Count);
Assert.AreEqual(2, GraphModel.EdgeModels.Count);
foreach (var edgeModel in GraphModel.EdgeModels)
{
Assert.AreEqual(nodeA.OutputPort, edgeModel.FromPort);
}
}
public void Test_DeleteElementsAction_OneEdge([Values] TestingMode mode)
{
var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", new Vector2(-200, 0));
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", new Vector2(200, 0));
var input0 = node0.Input0;
var input1 = node0.Input1;
var input2 = node0.Input2;
var output0 = node1.Output0;
var output1 = node1.Output1;
var output2 = node1.Output2;
var edge0 = GraphModel.CreateEdge(input0, output0);
GraphModel.CreateEdge(input1, output1);
GraphModel.CreateEdge(input2, output2);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(3));
Assert.That(input0, Is.ConnectedTo(output0));
Assert.That(input1, Is.ConnectedTo(output1));
Assert.That(input2, Is.ConnectedTo(output2));
return(new DeleteElementsAction(edge0));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(input0, Is.Not.ConnectedTo(output0));
Assert.That(input1, Is.ConnectedTo(output1));
Assert.That(input2, Is.ConnectedTo(output2));
});
}
public void ShufflingPortsPreserveConnections()
{
var node = GraphModel.CreateNode <PortOrderTestNodeModel>("test", Vector2.zero);
node.MakePortsFromNames(new List <string> {
"A", "B", "C"
});
node.DefineNode();
var decl = GraphModel.CreateGraphVariableDeclaration("myInt", TypeHandle.Int, true);
var nodeA = GraphModel.CreateVariableNode(decl, Vector2.up);
var nodeB = GraphModel.CreateVariableNode(decl, Vector2.zero);
var nodeC = GraphModel.CreateVariableNode(decl, Vector2.down);
GraphModel.CreateEdge(node.InputsById["A"], nodeA.OutputPort);
GraphModel.CreateEdge(node.InputsById["B"], nodeB.OutputPort);
GraphModel.CreateEdge(node.InputsById["C"], nodeC.OutputPort);
Assert.That(nodeA.OutputPort, Is.ConnectedTo(node.InputsById["A"]));
Assert.That(nodeB.OutputPort, Is.ConnectedTo(node.InputsById["B"]));
Assert.That(nodeC.OutputPort, Is.ConnectedTo(node.InputsById["C"]));
Assert.That(node.IsSorted, Is.True);
node.RandomizePorts();
Assert.That(node.IsSorted, Is.False);
node.DefineNode();
Assert.That(nodeA.OutputPort, Is.ConnectedTo(node.InputsById["A"]));
Assert.That(nodeB.OutputPort, Is.ConnectedTo(node.InputsById["B"]));
Assert.That(nodeC.OutputPort, Is.ConnectedTo(node.InputsById["C"]));
}
public void Test_MoveElementsActionForMultipleTypes([Values] TestingMode mode)
{
var deltaMove = new Vector2(50, -75);
var itemSize = new Vector2(100, 100);
var origNodePosition = Vector2.zero;
var newNodePosition = deltaMove;
var node = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var origStickyPosition = new Rect(Vector2.one * -100, itemSize);
var newStickyPosition = new Rect(origStickyPosition.position + deltaMove, itemSize);
var stickyNote = (StickyNoteModel)GraphModel.CreateStickyNote(origStickyPosition);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(origNodePosition));
Assert.That(GetStickyNote(0).Position, Is.EqualTo(origStickyPosition));
return(new MoveElementsAction(deltaMove, new[] { node }, new[] { stickyNote }));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.That(GetStickyNoteCount(), Is.EqualTo(1));
Assert.That(GetNode(0).Position, Is.EqualTo(newNodePosition));
Assert.That(GetStickyNote(0).Position.position, Is.EqualTo(newStickyPosition.position));
});
}
public void Test_RemoveNodesAction([Values] TestingMode mode)
{
var constantA = GraphModel.CreateConstantNode("constantA", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var binary0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
IPortModel outputPort = constantA.OutputPort;
GraphModel.CreateEdge(binary0.Input0, outputPort);
IPortModel outputPort1 = binary0.Output0;
GraphModel.CreateEdge(binary1.InputPortA, outputPort1);
TestPrereqActionPostreq(mode,
() =>
{
var nodeToDeleteAndBypass = GraphModel.NodeModels.OfType <Type0FakeNodeModel>().First();
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(nodeToDeleteAndBypass.Input0, Is.ConnectedTo(constantA.OutputPort));
Assert.That(binary1.InputPortA, Is.ConnectedTo(nodeToDeleteAndBypass.Output0));
return(new RemoveNodesAction(new INodeModel[] { nodeToDeleteAndBypass }, new INodeModel[] { nodeToDeleteAndBypass }));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(binary1.InputPortA, Is.ConnectedTo(constantA.OutputPort));
});
}
public void OneGroupIterationSystem([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set");
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
(manager, entityIndex, e) => manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
}),
(manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f)));
}
public IEnumerator Test_DuplicateCommandSkipsSingleInstanceModels()
{
GraphModel.CreateStack("stack", new Vector2(200, 50));
Vector2 position = new Vector2(200, 150);
GraphModel.CreateNode <UniqueInstanceFunctionModel>("Start", position);
Store.Dispatch(new RefreshUIAction(UpdateFlags.All));
yield return(null);
Assert.That(GetGraphElements().Count, Is.EqualTo(2));
Helpers.MouseClickEvent(GetGraphElement(0).GetGlobalCenter()); // Ensure we have focus
yield return(null);
GraphView.selection.Add(GetGraphElement(0));
GraphView.selection.Add(GetGraphElement(1));
Helpers.ExecuteCommand("Duplicate");
yield return(null);
Store.Dispatch(new RefreshUIAction(UpdateFlags.All));
yield return(null);
Assert.That(GetGraphElements().Count, Is.EqualTo(3), "Duplicate should have skipped the Start event function node");
}
public IEnumerator TestRebuildIsDoneOnce()
{
m_GraphViewStateObserver.UpdateType = UpdateType.None;
Type0FakeNodeModel model;
using (var updater = CommandDispatcher.State.GraphViewState.UpdateScope)
{
model = GraphModel.CreateNode <Type0FakeNodeModel>("Node 0", Vector2.zero);
updater.MarkNew(model);
}
yield return(null);
Assert.That(m_GraphViewStateObserver.UpdateType, Is.EqualTo(UpdateType.Complete));
m_GraphViewStateObserver.UpdateType = UpdateType.None;
yield return(null);
Assert.That(m_GraphViewStateObserver.UpdateType, Is.EqualTo(UpdateType.None));
m_GraphViewStateObserver.UpdateType = UpdateType.None;
CommandDispatcher.Dispatch(new DeleteElementsCommand(model));
yield return(null);
Assert.That(m_GraphViewStateObserver.UpdateType, Is.EqualTo(UpdateType.Partial));
m_GraphViewStateObserver.UpdateType = UpdateType.None;
yield return(null);
Assert.That(m_GraphViewStateObserver.UpdateType, Is.EqualTo(UpdateType.None));
}
public IEnumerator FrameNextElementWorks()
{
var nodeA = GraphModel.CreateNode <Type0FakeNodeModel>("A", new Vector2(-1000, 100));
var nodeB = GraphModel.CreateNode <Type0FakeNodeModel>("B", new Vector2(100, 100));
var nodeC = GraphModel.CreateNode <Type0FakeNodeModel>("C", new Vector2(1000, 100));
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, nodeB));
yield return(null);
var initialPos = GraphView.ContentViewContainer.transform.position;
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeA));
Assert.IsTrue(CommandDispatcher.State.SelectionState.IsSelected(nodeB));
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeC));
GraphView.DispatchFrameNextCommand(e => true);
yield return(null);
Assert.AreNotEqual(initialPos, GraphView.ContentViewContainer.transform.position);
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeA));
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeB));
Assert.IsTrue(CommandDispatcher.State.SelectionState.IsSelected(nodeC));
// Check that cycling work.
CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, nodeC));
yield return(null);
GraphView.DispatchFrameNextCommand(e => true);
yield return(null);
Assert.IsTrue(CommandDispatcher.State.SelectionState.IsSelected(nodeA));
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeB));
Assert.IsFalse(CommandDispatcher.State.SelectionState.IsSelected(nodeC));
}
public void Test_DuplicateAction_OneNode([Values] TestingMode mode)
{
GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(1));
var nodeModel = GetNode(0);
Assert.That(nodeModel, Is.TypeOf <Type0FakeNodeModel>());
TargetInsertionInfo info = new TargetInsertionInfo();
info.OperationName = "Duplicate";
info.Delta = Vector2.one;
info.TargetStackInsertionIndex = -1;
IEditorDataModel editorDataModel = m_Store.GetState().EditorDataModel;
VseGraphView.CopyPasteData copyPasteData = VseGraphView.GatherCopiedElementsData(x => x, new List <IGraphElementModel> {
nodeModel
});
return(new PasteSerializedDataAction(GraphModel, info, editorDataModel, copyPasteData.ToJson()));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GraphModel.NodeModels.Count(n => n == null), Is.Zero);
});
}
public void Test_Translate_Constructor()
{
FunctionModel a = GraphModel.CreateFunction("A", Vector2.zero);
// Debug.Log(...)
MethodInfo logMethod = typeof(Debug).GetMethod(nameof(Debug.Log), new[] { typeof(object) });
Assume.That(logMethod, Is.Not.Null);
FunctionCallNodeModel log = a.CreateStackedNode <FunctionCallNodeModel>("Log", 0, SpawnFlags.Default, n => n.MethodInfo = logMethod);
// new Vector4(x, y)
ConstructorInfo ctor = typeof(Vector4).GetConstructor(new[] { typeof(float), typeof(float) });
Assume.That(ctor, Is.Not.Null);
FunctionCallNodeModel newV4 = GraphModel.CreateNode <FunctionCallNodeModel>("New Vector4", Vector2.left * 200, SpawnFlags.Default, n => n.MethodInfo = ctor);
GraphModel.CreateEdge(log.GetParameterPorts().First(), newV4.OutputPort);
var b = new RoslynTranslator(Stencil);
var c = b.Translate(GraphModel, CompilationOptions.Default);
SyntaxNode d = c.GetRoot();
StatementSyntax stmt = d.DescendantNodes().OfType <MethodDeclarationSyntax>().First(n => n.Identifier.ValueText == "A")
.Body.Statements.First();
ExpressionSyntax arg = ((InvocationExpressionSyntax)((ExpressionStatementSyntax)stmt).Expression).ArgumentList.Arguments.Single().Expression;
Assert.That(arg.ToFullString(), Is.EqualTo("new UnityEngine.Vector4(0F, 0F)"));
}
public void GetPortFitToConnectToReturnNullForIncompatiblePorts()
{
var node1 = GraphModel.CreateNode <NodeType1>("test1", Vector2.zero);
var node2 = GraphModel.CreateNode <NodeType2>("test2", 100 * Vector2.right);
Assert.IsNull(node2.GetPortFitToConnectTo(node1.DataOut0));
}
protected static OnUpdateEntitiesNodeModel SetupOnUpdate(GraphModel graph, IHasMainOutputPort query)
{
var onUpdate = graph.CreateNode <OnUpdateEntitiesNodeModel>("On Update", Vector2.zero);
graph.CreateEdge(onUpdate.InstancePort, query.OutputPort);
return(onUpdate);
}
public IEnumerator DraggingFromPortCreateGhostEdge()
{
var nodeModel = GraphModel.CreateNode <SingleOutputNodeModel>();
MarkGraphViewStateDirty();
yield return(null);
var portModel = nodeModel.Ports.First();
var port = portModel.GetUI <Port>(GraphView);
Assert.IsNotNull(port);
Assert.IsNull(port.EdgeConnector.edgeDragHelper.edgeCandidateModel);
var portConnector = port.SafeQ(PortConnectorPart.connectorUssName);
var clickPosition = portConnector.parent.LocalToWorld(portConnector.layout.center);
Vector2 move = new Vector2(0, 100);
EventHelper.DragToNoRelease(clickPosition, clickPosition + move);
yield return(null);
// edgeCandidateModel != null is the sign that we have a ghost edge
Assert.IsNotNull(port.EdgeConnector.edgeDragHelper.edgeCandidateModel);
EventHelper.MouseUpEvent(clickPosition + move);
yield return(null);
}
public void Test_CloneGraph_MiniGraph([Values] TestingMode mode)
{
var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Node0", Vector2.zero);
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Node1", Vector2.zero);
GraphModel.CreateEdge(node0.Input0, node1.Output0);
var newGraphAsset = GraphAssetCreationHelpers <TestGraphAssetModel> .CreateInMemoryGraphAsset(CreatedGraphType, "Test_Copy");
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var n0 = GetNode(0) as Type0FakeNodeModel;
var n1 = GetNode(1) as Type0FakeNodeModel;
Assert.NotNull(n0);
Assert.NotNull(n1);
Assert.That(n0.Input0, Is.ConnectedTo(n1.Output0));
Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(0));
Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(0));
newGraphAsset.GraphModel.CloneGraph(GraphModel);
Assert.That(newGraphAsset.GraphModel.NodeModels.Count, Is.EqualTo(2));
Assert.That(newGraphAsset.GraphModel.EdgeModels.Cast <EdgeModel>().Count(), Is.EqualTo(1));
var nn0 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(0) as Type0FakeNodeModel;
var nn1 = newGraphAsset.GraphModel.NodeModels.Cast <NodeModel>().ElementAt(1) as Type0FakeNodeModel;
Assert.NotNull(nn0);
Assert.NotNull(nn1);
Assert.AreNotEqual(nn0, n0);
Assert.AreNotEqual(nn1, n1);
Assert.That(nn0.Input0, Is.ConnectedTo(nn1.Output0));
}
public void Test_CreateNodeFromOutputPort(TestingMode testingMode)
{
var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("add", out _).First();
var node0 = GraphModel.CreateNode <Type3FakeNodeModel>("Node0", Vector2.zero);
TestPrereqActionPostreq(testingMode,
() =>
{
RefreshReference(ref node0);
var output0 = node0.Output;
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromOutputPortAction(output0, Vector2.down, item));
},
() =>
{
RefreshReference(ref node0);
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newNode = GetNode(1);
Assert.That(newNode, Is.TypeOf <BinaryOperatorNodeModel>());
var newEdge = GetEdge(0);
Assert.That(newEdge.InputPortModel.DataType, Is.EqualTo(newEdge.OutputPortModel.DataType));
var portModel = node0.Output;
Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(newNode.InputsByDisplayOrder.First()));
});
}
public void Test_CreateNodeFromOutputPort(TestingMode testingMode)
{
var gedb = new GraphElementSearcherDatabase(Stencil, GraphModel);
Type3FakeNodeModel.AddToSearcherDatabase(GraphModel, gedb);
var db = gedb.Build();
var item = (GraphNodeModelSearcherItem)db.Search(nameof(Type3FakeNodeModel))[0];
var node0 = GraphModel.CreateNode <Type3FakeNodeModel>("Node0", Vector2.zero);
TestPrereqCommandPostreq(testingMode,
() =>
{
RefreshReference(ref node0);
var output0 = node0.Output;
Assert.That(GetNodeCount(), Is.EqualTo(1));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
return(new CreateNodeFromPortCommand(new[] { output0 }, Vector2.down, item));
},
() =>
{
RefreshReference(ref node0);
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
var newNode = GetNode(1);
Assert.That(newNode, Is.TypeOf <Type3FakeNodeModel>());
var newEdge = GetEdge(0);
Assert.That(newEdge.ToPort.DataTypeHandle, Is.EqualTo(newEdge.FromPort.DataTypeHandle));
var portModel = node0.Output;
Assert.That(portModel.GetConnectedPorts().Single(), Is.EqualTo(newNode.InputsByDisplayOrder.First()));
});
}
