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 void Test_CreateInsertLoopNode([Values] TestingMode mode)
{
GraphModel.CreateStack(string.Empty, Vector2.zero);
GraphModel.CreateLoopStack <ForEachHeaderModel>(Vector2.right * 100);
TestPrereqActionPostreq(mode,
() =>
{
var loopStack = GetStack(1) as LoopStackModel;
var stack = GetStack(0);
Assert.That(stack.NodeModels.Count, Is.EqualTo(0));
var portModel = loopStack.InputPort;
Assert.That(portModel.Connected, Is.False);
return(new CreateInsertLoopNodeAction(
loopStack.InputPorts.First(), stack, -1, (LoopStackModel)portModel.NodeModel));
},
() =>
{
var loopStack = GetStack(1) as LoopStackModel;
var stack = GetStack(0);
Assert.That(stack.NodeModels.Count, Is.EqualTo(1));
var loopNode = stack.NodeModels.First() as ForEachNodeModel;
Assert.That(loopNode, Is.Not.Null);
Assert.NotNull(loopNode);
var portModel = loopNode.OutputPort;
Assert.That(portModel.Connected, Is.True);
Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(loopStack.InputPort));
});
}
public void TestCreateEdge_CannotConnectForEachNodeToWhileStack()
{
var stack = GraphModel.CreateStack("", Vector2.zero);
var forEach = stack.CreateStackedNode <ForEachNodeModel>();
var whileStack = GraphModel.CreateLoopStack <WhileHeaderModel>(Vector2.zero);
var edgeCount = GetEdgeCount();
m_Store.Dispatch(new CreateEdgeAction(whileStack.InputPort, forEach.OutputPort));
Assert.That(GetEdgeCount(), Is.EqualTo(edgeCount));
}
public void InstrumentCooldownNodeModelDoesNotThrow()
{
var start = GraphModel.CreateEventFunction(typeof(TestStencil.TestArchetype).GetMethod("Start"), Vector2.zero);
var cooldown = GraphModel.CreateLoopStack <ForEachHeaderModel>(Vector2.down);
var loopNode = cooldown.CreateLoopNode(start, -1);
GraphModel.CreateEdge(cooldown.InputPort, loopNode.OutputPort);
var result = GraphModel.CreateTranslator().TranslateAndCompile(GraphModel, AssemblyType.None, CompilationOptions.Tracing);
Assert.That(result.status, Is.EqualTo(CompilationStatus.Succeeded));
LogAssert.NoUnexpectedReceived();
}
public IEnumerator MovingAStackMovesTheConnectedLoopStack([Values] TestingMode mode)
{
var stackModel0 = GraphModel.CreateStack(string.Empty, new Vector2(-100, -100));
var loopStack = GraphModel.CreateLoopStack <WhileHeaderModel>(new Vector2(50, 50));
var whileModel = loopStack.CreateLoopNode(stackModel0, 0);
GraphModel.CreateEdge(loopStack.InputPort, whileModel.OutputPort);
yield return(TestMove(mode,
mouseDelta: new Vector2(20, 10),
movedNodes: new INodeModel[] { stackModel0 },
expectedMovedDependencies: new INodeModel[] { loopStack }
));
}
public void NestedIterationSystem_DifferentGroups_DifferentComponents([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
// query1 - Position
ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Rotation too
ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None);
IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// set query1.translation = ...
SetPropertyGroupNodeModel set = forAllStack.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 == translationType), 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.AddComponentData(e, new Rotation());
},
(manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f)));
}
public void TestRemoveComponent_ForEachContext([Values] CodeGenMode mode)
{
SetupTestGraph(mode, graphModel =>
{
// query1 - Position
var query1 = graphModel.CreateComponentQuery("g1");
query1.AddComponent(graphModel.Stencil, typeof(Translation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var query1Instance = graphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Scale (will add RenderMesh)
var query2 = graphModel.CreateComponentQuery("g2");
query2.AddComponent(graphModel.Stencil, typeof(Scale).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None);
var query2Instance = graphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
graphModel.CreateEdge(onUpdateEntities.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateEntities, 0) as ForAllEntitiesNodeModel;
graphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
graphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// Remove Scale component
var addComponent = forAllStack.CreateStackedNode <RemoveComponentNodeModel>("remove");
addComponent.ComponentType = typeof(Scale).GenerateTypeHandle(Stencil);
var entityInstance = graphModel.CreateVariableNode(
forAllStack.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)
),
Vector2.zero);
graphModel.CreateEdge(addComponent.EntityPort, entityInstance.OutputPort);
},
(manager, entityIndex, e) =>
{
// HACK as there is no Single update method as entry point (just the on UpdateEntities right now)
var toAdd = entityIndex == 0 ? typeof(Translation) : typeof(Scale);
manager.AddComponent(e, toAdd);
},
(manager, entityIndex, e) => Assert.That(!manager.HasComponent <Scale>(e)));
}
public void NestedIterationSystem_DifferentGroups_NestedLocalVariable([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, g =>
{
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
// query1 - Position
ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Rotation too
ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None);
IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
var decl = forAllStack.CreateFunctionVariableDeclaration("x", TypeHandle.Int);
// set query1.translation = ...
SetVariableNodeModel set = forAllStack.CreateStackedNode <SetVariableNodeModel>("set");
IVariableModel posComponent = GraphModel.CreateVariableNode(decl, Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
});
}
public void NestedIteration_DifferentGroups_DifferentEntitiesAccess([Values] CodeGenMode mode)
{
SetupTestGraph(mode, graph =>
{
var translationType = typeof(Translation).GenerateTypeHandle(Stencil);
var scaleType = typeof(Scale).GenerateTypeHandle(Stencil);
// query1 - Position
var query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
var query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Scale
var query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, scaleType, ComponentDefinitionFlags.None);
var query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
var update = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(update.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(update, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// entity from query 1
var entity1 = graph.CreateVariableNode(
update.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// entity from query 2
var entity2 = graph.CreateVariableNode(
forAllStack.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// set a new Translation to entities of query1
var setTranslation = forAllStack.CreateStackedNode <SetComponentNodeModel>("set translation");
setTranslation.ComponentType = typeof(Translation).GenerateTypeHandle(graph.Stencil);
setTranslation.DefineNode();
((FloatConstantModel)setTranslation.InputConstantsById["z"]).value = 10f;
graph.CreateEdge(setTranslation.EntityPort, entity1.OutputPort);
// set a new Scale to entities of query2
var setScale = forAllStack.CreateStackedNode <SetComponentNodeModel>("set scale");
setScale.ComponentType = typeof(Scale).GenerateTypeHandle(graph.Stencil);
setScale.DefineNode();
((FloatConstantModel)setScale.InputConstantsById["Value"]).value = 30f;
graph.CreateEdge(setScale.EntityPort, entity2.OutputPort);
},
(manager, index, entity) =>
{
if (index % 2 == 0)
{
manager.AddComponentData(entity, new Translation());
}
else
{
manager.AddComponentData(entity, new Scale());
}
},
(manager, index, entity) =>
{
if (manager.HasComponent <Translation>(entity))
{
Assert.That(manager.GetComponentData <Translation>(entity).Value.z, Is.EqualTo(10f));
}
if (manager.HasComponent <Scale>(entity))
{
Assert.That(manager.GetComponentData <Scale>(entity).Value, Is.EqualTo(30f));
}
}
);
}
void SpawnAllNodeModelsInGraph(VSGraphModel graphModel)
{
StackModel stack;
FunctionModel funcModel;
//--Floating Nodes--
//Stack-Derived NodeModels
stack = GraphModel.CreateNode <StackModel>("StackModel");
funcModel = GraphModel.CreateNode <FunctionModel>("FunctionModel");
var methodInfo = TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true);
GraphModel.CreateEventFunction(methodInfo, Vector2.zero);
GraphModel.CreateNode <OnEndEntitiesNodeModel>("OnEndEntitiesNodeModel");
GraphModel.CreateNode <OnEventNodeModel>("OnEventNodeModel");
GraphModel.CreateNode <OnStartEntitiesNodeModel>("OnStartEntitiesNodeModel");
var onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("OnUpdateEntitiesNodeModel");
GraphModel.CreateNode <PostUpdate>("PostUpdate");
GraphModel.CreateNode <PreUpdate>("PreUpdate");
GraphModel.CreateNode <KeyDownEventModel>("KeyDownEventModel");
GraphModel.CreateLoopStack(typeof(ForEachHeaderModel), Vector2.zero);
GraphModel.CreateLoopStack(typeof(WhileHeaderModel), Vector2.zero);
GraphModel.CreateLoopStack(typeof(ForAllEntitiesStackModel), Vector2.zero);
//Constant-typed NodeModels
GraphModel.CreateNode <BooleanConstantNodeModel>("BooleanConstantNodeModel");
GraphModel.CreateNode <ColorConstantModel>("ColorConstantModel");
GraphModel.CreateNode <CurveConstantNodeModel>("CurveConstantNodeModel");
GraphModel.CreateNode <DoubleConstantModel>("DoubleConstantModel");
GraphModel.CreateNode <EnumConstantNodeModel>("EnumConstantNodeModel");
GraphModel.CreateNode <FloatConstantModel>("FloatConstantModel");
GraphModel.CreateNode <GetPropertyGroupNodeModel>("GetPropertyGroupNodeModel");
GraphModel.CreateNode <InputConstantModel>("InputConstantModel");
GraphModel.CreateNode <IntConstantModel>("IntConstantModel");
GraphModel.CreateNode <LayerConstantModel>("LayerConstantModel");
GraphModel.CreateNode <LayerMaskConstantModel>("LayerMaskConstantModel");
GraphModel.CreateNode <ObjectConstantModel>("ObjectConstantModel");
GraphModel.CreateNode <QuaternionConstantModel>("QuaternionConstantModel");
GraphModel.CreateNode <StringConstantModel>("StringConstantModel");
GraphModel.CreateNode <TagConstantModel>("TagConstantModel");
GraphModel.CreateNode <TypeConstantModel>("TypeConstantModel");
GraphModel.CreateNode <Vector2ConstantModel>("Vector2ConstantModel");
GraphModel.CreateNode <Vector3ConstantModel>("Vector3ConstantModel");
GraphModel.CreateNode <Vector4ConstantModel>("Vector4ConstantModel");
GraphModel.CreateNode <ConstantSceneAssetNodeModel>("ConstantSceneAssetNodeModel");
GraphModel.CreateNode <Float2ConstantModel>("Float2ConstantModel");
GraphModel.CreateNode <Float3ConstantModel>("Float3ConstantModel");
GraphModel.CreateNode <Float4ConstantModel>("Float4ConstantModel");
//Misc
void DefineSystemConstant(SystemConstantNodeModel m)
{
m.ReturnType = typeof(float).GenerateTypeHandle(Stencil);
m.DeclaringType = typeof(Mathf).GenerateTypeHandle(Stencil);
m.Identifier = "PI";
}
GraphModel.CreateNode <SystemConstantNodeModel>("SystemConstantNodeModel", Vector2.zero, SpawnFlags.Default, DefineSystemConstant);
GraphModel.CreateNode <GroupNodeModel>("GroupNodeModel");
GraphModel.CreateNode <GetInputNodeModel>("GetInputNodeModel");
GraphModel.CreateNode <GetOrCreateComponentNodeModel>("GetOrCreateComponentNodeModel");
GraphModel.CreateNode <GetSingletonNodeModel>("GetSingletonNodeModel");
GraphModel.CreateNode <ThisNodeModel>("ThisNodeModel");
VariableDeclarationModel decl = graphModel.CreateGraphVariableDeclaration("MyVariableName", typeof(int).GenerateTypeHandle(graphModel.Stencil), true);
GraphModel.CreateVariableNode(decl, Vector2.zero);
GraphModel.CreateNode <MacroRefNodeModel>("MacroRefNodeModel");
GraphModel.CreateInlineExpressionNode("2+2", Vector2.zero);
GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero);
GraphModel.CreateUnaryOperatorNode(UnaryOperatorKind.PostIncrement, Vector2.zero);
//--Stack-Contained Nodes--
stack.CreateStackedNode <AddComponentNodeModel>();
stack.CreateStackedNode <DestroyEntityNodeModel>();
stack.CreateStackedNode <ForAllEntitiesNodeModel>();
stack.CreateStackedNode <ForEachNodeModel>();
stack.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true));
stack.CreateFunctionRefCallNode(funcModel);
stack.CreateStackedNode <InstantiateNodeModel>();
stack.CreateStackedNode <IfConditionNodeModel>();
stack.CreateStackedNode <LogNodeModel>();
stack.CreateStackedNode <RemoveComponentNodeModel>();
stack.CreateStackedNode <SetComponentNodeModel>();
stack.CreateStackedNode <SetPositionNodeModel>();
stack.CreateStackedNode <SetRotationNodeModel>();
stack.CreateStackedNode <WhileNodeModel>();
stack.CreateStackedNode <SetPropertyGroupNodeModel>();
stack.CreateStackedNode <SetVariableNodeModel>();
funcModel.CreateStackedNode <ReturnNodeModel>();
TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil);
onUpdateModel.CreateStackedNode <SendEventNodeModel>("SendEventNodeModel", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle);
}
