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 void DeleteElementsCommandDeletesAndUnselects([Values] TestingMode mode)
{
var node0 = GraphModel.CreateNode <Type0FakeNodeModel>("Minus", Vector2.zero);
var node1 = GraphModel.CreateNode <Type0FakeNodeModel>("Fake1", Vector2.zero);
GraphModel.CreateEdge(node0.Input0, node1.Output0);
m_CommandDispatcher.Dispatch(new SelectElementsCommand(SelectElementsCommand.SelectionMode.Replace, node0));
TestPrereqCommandPostreq(mode,
() =>
{
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.IsTrue(m_CommandDispatcher.State.SelectionState.IsSelected(node0));
Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1));
return(new DeleteElementsCommand(node0, node1));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(0));
Assert.That(GetEdgeCount(), Is.EqualTo(0));
Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node0));
Assert.IsFalse(m_CommandDispatcher.State.SelectionState.IsSelected(node1));
});
}
public void ExtractTwoNodesConnectedToTheSameNodeDifferentPorts([Values] TestingMode mode)
{
var stack = GraphModel.CreateFunction("F", Vector2.zero);
var set = stack.CreateStackedNode <SetVariableNodeModel>("set");
var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero);
var varB = GraphModel.CreateVariableNode(m_BDecl, Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, varA.OutputPort);
GraphModel.CreateEdge(set.ValuePort, varB.OutputPort);
Undo.IncrementCurrentGroup();
TestPrereqActionPostreq(mode, () =>
{
set = stack.NodeModels.OfType <SetVariableNodeModel>().Single();
Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero);
Assert.That(set.InstancePort, Is.ConnectedTo(varA.OutputPort));
Assert.That(set.ValuePort, Is.ConnectedTo(varB.OutputPort));
return(new RefactorExtractMacroAction(new List <IGraphElementModel> {
varA, varB
}, Vector2.zero, null));
}, () =>
{
var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single();
Assert.That(macroRef, Is.Not.Null);
var macroRefOutputPorts = macroRef.OutputVariablePorts.ToList();
Assert.That(macroRefOutputPorts.Count, Is.EqualTo(2));
Assert.That(macroRefOutputPorts[0], Is.ConnectedTo(set.InstancePort));
Assert.That(macroRefOutputPorts[1], Is.ConnectedTo(set.ValuePort));
Assert.That(macroRef.Macro.Stencil, Is.TypeOf <MacroStencil>());
Assert.That(((MacroStencil)macroRef.Macro.Stencil).ParentType, Is.EqualTo(GraphModel.Stencil.GetType()));
});
}
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 TestCreateNodeOnEdge_WithOutputNodeConnectedToUnknown([Values] TestingMode mode)
{
var constantNode = GraphModel.CreateConstantNode("int1", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var addNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GraphModel.CreateEdge(addNode.InputPortA, constantNode.OutputPort);
GraphModel.CreateEdge(addNode.InputPortB, constantNode.OutputPort);
var db = new GraphElementSearcherDatabase(Stencil).AddBinaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("multiply", out _)[0];
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(addNode, Is.Not.Null);
Assert.That(addNode.InputPortA, Is.ConnectedTo(constantNode.OutputPort));
var edge = GraphModel.EdgeModels.First();
return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item));
},
() =>
{
var multiplyNode = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().ToList()[1];
Assert.IsNotNull(multiplyNode);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(3));
Assert.That(constantNode.OutputPort, Is.ConnectedTo(multiplyNode.InputPortA));
Assert.That(multiplyNode.OutputPort, Is.ConnectedTo(addNode.InputPortA));
Assert.That(constantNode.OutputPort, Is.Not.ConnectedTo(addNode.InputPortA));
}
);
}
public void TestCreateNodeOnEdge_BothPortsConnected([Values] TestingMode mode)
{
var constant = GraphModel.CreateConstantNode("int", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var unary = GraphModel.CreateUnaryOperatorNode(UnaryOperatorKind.Minus, Vector2.zero);
var edge = GraphModel.CreateEdge(unary.InputPort, constant.OutputPort);
var db = new GraphElementSearcherDatabase(Stencil).AddUnaryOperators().Build();
var item = (GraphNodeModelSearcherItem)db.Search("minus", out _)[0];
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(unary.InputPort, Is.ConnectedTo(constant.OutputPort));
return(new CreateNodeOnEdgeAction(edge, Vector2.zero, item));
},
() =>
{
var unary2 = GraphModel.NodeModels.OfType <UnaryOperatorNodeModel>().ToList()[1];
Assert.IsNotNull(unary2);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(2));
Assert.That(constant.OutputPort, Is.ConnectedTo(unary2.InputPort));
Assert.That(unary2.OutputPort, Is.ConnectedTo(unary.InputPort));
Assert.IsFalse(GraphModel.EdgeModels.Contains(edge));
}
);
}
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 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 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 NestedIfs()
{
var a = GraphModel.CreateFunction("A", Vector2.zero);
StackBaseModel b, c;
CreateIfThenElseStacks(a, "b", "c", out b, out c);
var d = GraphModel.CreateStack("d", Vector2.left);
var e = GraphModel.CreateStack("e", Vector2.left);
b.CreateStackedNode <Type0FakeNodeModel>("b");
c.CreateStackedNode <Type0FakeNodeModel>("c");
d.CreateStackedNode <Type0FakeNodeModel>("d");
e.CreateStackedNode <Type0FakeNodeModel>("e");
var cIfNode = c.CreateStackedNode <IfConditionNodeModel>("if_c");
GraphModel.CreateEdge(b.InputPorts[0], cIfNode.ThenPort);
GraphModel.CreateEdge(d.InputPorts[0], cIfNode.ElsePort);
GraphModel.CreateEdge(e.InputPorts[0], b.OutputPorts[0]);
GraphModel.CreateEdge(e.InputPorts[0], d.OutputPorts[0]);
// as C has an if node, a common descendant of (C,X) must be a descendant of (B,D,X), here E
Assert.That(RoslynTranslator.FindCommonDescendant(a, a, c), Is.EqualTo(e));
Assert.That(RoslynTranslator.FindCommonDescendant(a, b, c), Is.EqualTo(e));
}
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 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 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 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 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());
}
[Test] // TODO: fix jobs
public void OnExitWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, graphModel =>
{
var group = graphModel.CreateComponentQuery("g");
var positionType = typeof(Translation).GenerateTypeHandle(Stencil);
group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None);
group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
var update = graphModel.CreateNode <OnEndEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort);
var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
IVariableModel entityVariable = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(Stencil)), Vector2.zero);
GraphModel.CreateEdge(log.GetParameterPorts().First(), entityVariable.OutputPort);
},
EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))),
EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Translation))),
EachEntity((manager, i, e) =>
{
LogAssert.NoUnexpectedReceived();
LogAssert.Expect(LogType.Log, $"Entity({i}:1)");
manager.RemoveComponent <Rotation>(e);
}),
EachEntity((manager, i, e) => {})
);
}
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 void MacroPortsRemainConnectedAfterMacroAssetDeletion()
{
FunctionCallNodeModel[] log;
CreateStackAndLogs(out _, out log);
var binOp = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero);
GraphModel.CreateEdge(log[0].GetParameterPorts().First(), binOp.OutputPort);
GraphModel.CreateEdge(binOp.InputPortA, varA.OutputPort);
GraphModel.CreateEdge(binOp.InputPortB, varA.OutputPort);
TestPrereqActionPostreq(TestingMode.Action, () =>
{
binOp = GraphModel.NodeModels.OfType <BinaryOperatorNodeModel>().Single();
Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3));
Assert.That(GraphModel.NodeModels.OfType <MacroRefNodeModel>().Count(), Is.Zero);
Assert.That(binOp.InputPortA, Is.ConnectedTo(varA.OutputPort));
Assert.That(binOp.InputPortB, Is.ConnectedTo(varA.OutputPort));
Assert.That(binOp.OutputPort, Is.ConnectedTo(log[0].GetParameterPorts().First()));
return(new RefactorExtractMacroAction(new List <IGraphElementModel> {
binOp
}, Vector2.zero, null));
}, () =>
{
Assert.That(GraphModel.NodeModels.Count, Is.EqualTo(3));
var macroRef = GraphModel.NodeModels.OfType <MacroRefNodeModel>().Single();
macroRef.GraphAssetModel = null;
macroRef.DefineNode();
Assert.That(macroRef, Is.Not.Null);
Assert.That(macroRef.InputVariablePorts.First(), Is.ConnectedTo(varA.OutputPort));
Assert.That(macroRef.OutputVariablePorts.First(), Is.ConnectedTo(log[0].GetParameterPorts().First()));
});
}
[Test] // TODO: fix jobs
public void OnEnterWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, graphModel =>
{
var group = graphModel.CreateComponentQuery("g");
var positionType = typeof(Translation).GenerateTypeHandle(Stencil);
group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None);
group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero);
var update = graphModel.CreateNode <OnStartEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort);
var set = update.CreateStackedNode <SetPositionNodeModel>("set", 0, SpawnFlags.Default, n => n.Mode = SetPositionNodeModel.TranslationMode.Float3);
set.Add = true; // increment so we can detect multiple runs if they happen
((Float3ConstantModel)set.InputConstantsById["Value"]).value = new Vector3(1f, 0.0f, 0.0f);
IVariableModel posComponent = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
},
EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))),
EachEntity((manager, i, e) =>
{
manager.AddComponent(e, typeof(Translation)); // will make the entity enter the query
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0));
}),
EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // translate ran once
EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))) // not twice
);
}
public void Test_SplitEdgeAndInsertNodeAction([Values] TestingMode mode)
{
var constant = GraphModel.CreateConstantNode("Constant", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var edge = GraphModel.CreateEdge(binary0.InputPortA, constant.OutputPort);
TestPrereqActionPostreq(mode,
() =>
{
RefreshReference(ref constant);
RefreshReference(ref binary0);
RefreshReference(ref binary1);
edge = GetEdge(0);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(binary0.InputPortA, Is.ConnectedTo(constant.OutputPort));
return(new SplitEdgeAndInsertNodeAction(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.InputPortA, Is.ConnectedTo(constant.OutputPort));
Assert.That(binary0.InputPortA, Is.ConnectedTo(binary1.OutputPort));
});
}
public void ExtractLinkedThreeNodesWithOneSharedInput()
{
// a > b && a < c
FunctionCallNodeModel[] log;
CreateStackAndLogs(out _, out log);
var greater = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.GreaterThan, Vector2.zero);
var lower = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.LessThan, Vector2.zero);
var and = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.LogicalAnd, Vector2.zero);
var varA = GraphModel.CreateVariableNode(m_ADecl, Vector2.zero);
var varB = GraphModel.CreateVariableNode(m_BDecl, Vector2.zero);
var varC = GraphModel.CreateVariableNode(m_CDecl, Vector2.zero);
List <IGraphElementModel> extract = new List <IGraphElementModel>
{
greater, lower, and,
};
GraphModel.CreateEdge(log[0].GetParameterPorts().First(), and.OutputPort);
extract.Add(GraphModel.CreateEdge(and.InputPortA, greater.OutputPort));
extract.Add(GraphModel.CreateEdge(and.InputPortB, lower.OutputPort));
GraphModel.CreateEdge(greater.InputPortA, varA.OutputPort);
GraphModel.CreateEdge(greater.InputPortB, varB.OutputPort);
GraphModel.CreateEdge(lower.InputPortA, varA.OutputPort);
GraphModel.CreateEdge(lower.InputPortB, varC.OutputPort);
TestExtractMacro(extract,
new IO(varA.OutputPort, varB.OutputPort, varC.OutputPort),
new IO(log[0].GetParameterPorts().First()));
}
public void Test_ChangeStackedNode([Values] TestingMode mode)
{
var decl = GraphModel.CreateGraphVariableDeclaration("a", TypeHandle.Bool, true);
var stackModel = GraphModel.CreateStack(string.Empty, Vector2.zero);
var set = stackModel.CreateStackedNode <SetVariableNodeModel>("set");
var v1 = GraphModel.CreateVariableNode(decl, Vector2.left);
var v2 = GraphModel.CreateVariableNode(decl, Vector2.left);
GraphModel.CreateEdge(set.InstancePort, v1.OutputPort);
GraphModel.CreateEdge(set.ValuePort, v2.OutputPort);
var db = new GraphElementSearcherDatabase(Stencil).AddNodesWithSearcherItemAttribute().Build();
var item = (StackNodeModelSearcherItem)db.Search("log", out _)[0];
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1));
Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <SetVariableNodeModel>());
set = (SetVariableNodeModel)stackModel.NodeModels.Single();
Assert.That(v1.OutputPort, Is.ConnectedTo(set.InstancePort));
Assert.That(v2.OutputPort, Is.ConnectedTo(set.ValuePort));
return(new ChangeStackedNodeAction(set, stackModel, item));
},
() =>
{
Assert.That(stackModel.NodeModels.Count, Is.EqualTo(1));
Assert.That(stackModel.NodeModels.Single(), Is.TypeOf <LogNodeModel>());
var log = stackModel.NodeModels.OfType <LogNodeModel>().Single();
Assert.That(v1.OutputPort, Is.ConnectedTo(log.InputPort));
Assert.That(v2.OutputPort.Connected, Is.False);
});
}
public void Test_CreateStackedNodeFromOutputPort_NoNodeCreated([Values] TestingMode mode)
{
var stack1 = GraphModel.CreateStack("Stack1", Vector2.zero);
var stack2 = GraphModel.CreateStack("Stack2", Vector2.zero);
var edge = GraphModel.CreateEdge(stack1.InputPorts[0], stack2.OutputPorts[0]);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetEdgeCount(), Is.EqualTo(1));
return(new CreateStackedNodeFromOutputPortAction(
stack1.OutputPorts[0],
stack1,
0,
new StackNodeModelSearcherItem(
new NodeSearcherItemData(typeof(int)),
data => Enumerable.Empty <IGraphElementModel>().ToArray(),
""),
new List <IEdgeModel> {
edge
}));
},
() =>
{
Assert.That(GetEdgeCount(), Is.EqualTo(0));
});
}
public void Test_ConvertVariableNodeToConstantNodeAction([Values] TestingMode mode)
{
var declaration0 = GraphModel.CreateGraphVariableDeclaration("decl0", typeof(int).GenerateTypeHandle(Stencil), true);
var node0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var node1 = GraphModel.CreateVariableNode(declaration0, Vector2.zero);
IPortModel outputPort = node1.OutputPort;
GraphModel.CreateEdge(node0.InputPortA, outputPort);
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1));
Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>());
var n0 = (BinaryOperatorNodeModel)GetNode(0);
var n1 = (VariableNodeModel)GetNode(1);
Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort));
return(new ConvertVariableNodesToConstantNodesAction(node1));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1));
Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>());
var n0 = (BinaryOperatorNodeModel)GetNode(0);
var n1 = (IntConstantModel)GetNode(1);
Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort));
});
}
public void Test_ConvertConstantNodeToVariableNodeAction([Values] TestingMode mode)
{
var binary = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var constant = GraphModel.CreateConstantNode("const0", typeof(int).GenerateTypeHandle(Stencil), Vector2.zero);
IPortModel outputPort = constant.OutputPort;
GraphModel.CreateEdge(binary.InputPortA, outputPort);
TestPrereqActionPostreq(mode,
() =>
{
var c = GraphModel.GetAllNodes().OfType <IConstantNodeModel>().First();
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0));
Assert.That(GetNode(1), Is.TypeOf <IntConstantModel>());
var n0 = (BinaryOperatorNodeModel)GetNode(0);
var n1 = (IntConstantModel)GetNode(1);
Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort));
return(new ConvertConstantNodesToVariableNodesAction(c));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(1));
Assert.That(GetNode(1), Is.TypeOf <VariableNodeModel>());
var n0 = (BinaryOperatorNodeModel)GetNode(0);
var n1 = (VariableNodeModel)GetNode(1);
Assert.That(n0.InputPortA, Is.ConnectedTo(n1.OutputPort));
Assert.That(n1.DataType, Is.EqualTo(typeof(int).GenerateTypeHandle(Stencil)));
});
}
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 SendEventNestedTest([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, graphModel =>
{
// group1 - Position
var group1 = graphModel.CreateComponentQuery("g1");
group1.AddComponent(graphModel.Stencil, typeof(Translation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var group1Instance = graphModel.CreateVariableNode(group1, Vector2.zero);
// group2 - Scale (will add RenderMesh)
var group2 = graphModel.CreateComponentQuery("g2");
group2.AddComponent(graphModel.Stencil, typeof(Scale).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var group2Instance = graphModel.CreateVariableNode(group2, Vector2.zero);
// update group 1
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, group1Instance.OutputPort);
// nested update group 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateEntities, 0) as ForAllEntitiesNodeModel;
graphModel.CreateEdge(forAllNode.InputPort, group2Instance.OutputPort);
graphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil);
SendEventNodeModel set = forAllStack.CreateStackedNode <SendEventNodeModel>("set", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle);
TypeHandle entityType = typeof(Entity).GenerateTypeHandle(Stencil);
IVariableModel entityVar = GraphModel.CreateVariableNode(forAllStack.FunctionParameterModels.Single(p => p.DataType == entityType), Vector2.zero);
var firstFieldInput = set.EntityPort;
GraphModel.CreateEdge(firstFieldInput, entityVar.OutputPort);
}
);
}
public IEnumerator EndToEndMoveDependencyWithPanning()
{
var stackModel0 = GraphModel.CreateStack(string.Empty, new Vector2(100, -100));
var stackModel1 = GraphModel.CreateStack(string.Empty, new Vector2(100, 100));
GraphModel.CreateEdge(stackModel1.InputPorts[0], stackModel0.OutputPorts[0]);
Store.Dispatch(new RefreshUIAction(UpdateFlags.All));
yield return(null);
GraphView.FrameAll();
yield return(null);
bool needsMouseUp = false;
try
{
using (var scheduler = GraphView.CreateTimerEventSchedulerWrapper())
{
GraphElement stackNode = GraphView.UIController.ModelsToNodeMapping[stackModel0];
Vector2 startPos = stackNode.GetPosition().position;
Vector2 otherStartPos = stackModel1.Position;
Vector2 nodeRect = stackNode.hierarchy.parent.ChangeCoordinatesTo(Window.rootVisualElement, stackNode.layout.center);
// Move the movable node.
Vector2 pos = nodeRect;
Vector2 target = new Vector2(Window.rootVisualElement.layout.xMax - 20, pos.y);
needsMouseUp = true;
bool changed = false;
GraphView.viewTransformChanged += view => changed = true;
Helpers.MouseDownEvent(pos);
yield return(null);
Helpers.MouseMoveEvent(pos, target);
Helpers.MouseDragEvent(pos, target);
yield return(null);
scheduler.TimeSinceStartup += GraphViewTestHelpers.SelectionDraggerPanInterval;
scheduler.UpdateScheduledEvents();
Helpers.MouseUpEvent(target);
needsMouseUp = false;
Assume.That(changed, Is.True);
yield return(null);
Vector2 delta = stackNode.GetPosition().position - startPos;
Assert.That(stackModel1.Position, Is.EqualTo(otherStartPos + delta));
}
}
finally
{
if (needsMouseUp)
{
Helpers.MouseUpEvent(Vector2.zero);
}
}
}
public void Test_ItemizeSystemConstantNodeAction([Values] TestingMode mode)
{
void PreDefineSetup(SystemConstantNodeModel m)
{
m.ReturnType = typeof(float).GenerateTypeHandle(Stencil);
m.DeclaringType = typeof(Mathf).GenerateTypeHandle(Stencil);
m.Identifier = "PI";
}
var constant = GraphModel.CreateNode <SystemConstantNodeModel>("Constant", Vector2.zero, SpawnFlags.Default, PreDefineSetup);
var binary0 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
var binary1 = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
IPortModel outputPort = constant.OutputPort;
GraphModel.CreateEdge(binary0.InputPortA, outputPort);
IPortModel outputPort1 = constant.OutputPort;
GraphModel.CreateEdge(binary0.InputPortB, outputPort1);
IPortModel outputPort2 = constant.OutputPort;
GraphModel.CreateEdge(binary1.InputPortA, outputPort2);
IPortModel outputPort3 = constant.OutputPort;
GraphModel.CreateEdge(binary1.InputPortB, outputPort3);
TestPrereqActionPostreq(mode,
() =>
{
RefreshReference(ref constant);
RefreshReference(ref binary0);
RefreshReference(ref binary1);
Assert.That(GetNodeCount(), Is.EqualTo(3));
Assert.That(GetEdgeCount(), Is.EqualTo(4));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0));
Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(1));
Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA));
Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortB));
Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA));
Assert.That(constant.OutputPort, Is.ConnectedTo(binary1.InputPortB));
return(new ItemizeSystemConstantNodeAction(constant));
},
() =>
{
RefreshReference(ref constant);
RefreshReference(ref binary0);
RefreshReference(ref binary1);
Assert.That(GetNodeCount(), Is.EqualTo(6));
Assert.That(GetEdgeCount(), Is.EqualTo(4));
Assert.That(GetAllNodes().OfType <SystemConstantNodeModel>().Count(), Is.EqualTo(4));
Assert.That(GetVariableDeclarationCount(), Is.EqualTo(0));
Assert.That(constant.OutputPort, Is.ConnectedTo(binary0.InputPortA));
Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary0.InputPortB));
Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortA));
Assert.That(constant.OutputPort, Is.Not.ConnectedTo(binary1.InputPortB));
});
}
public void Test_EditPropertyGroupNodeAction_AddRemove([Values] TestingMode mode)
{
IConstantNodeModel constant = GraphModel.CreateConstantNode("toto", typeof(Vector3).GenerateTypeHandle(Stencil), Vector2.zero);
GetPropertyGroupNodeModel property = GraphModel.CreateGetPropertyGroupNode(Vector2.zero);
GraphModel.CreateEdge(property.InstancePort, constant.OutputPort);
Type type = typeof(GameObject);
MemberInfo memberInfo = type.GetMembers()[0];
var newMember = new TypeMember
{
Path = new List <string> {
memberInfo.Name
},
Type = memberInfo.GetUnderlyingType().GenerateTypeHandle(Stencil)
};
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0));
return(new EditPropertyGroupNodeAction(
EditPropertyGroupNodeAction.EditType.Add,
property,
newMember));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1));
});
TestPrereqActionPostreq(mode,
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(1));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(1));
return(new EditPropertyGroupNodeAction(
EditPropertyGroupNodeAction.EditType.Remove,
property,
newMember));
},
() =>
{
Assert.That(GetNodeCount(), Is.EqualTo(2));
Assert.That(GetEdgeCount(), Is.EqualTo(1));
Assert.That(property.GetPortsForMembers().Count(), Is.EqualTo(0));
Assert.That(property.OutputsByDisplayOrder.Count(), Is.EqualTo(0));
});
}
